C++ 打字地图<；国际，A类>；至<；国际，B级>；在C++；

我有一个函数，它接受一个映射作为参数，如下所示

function do_dope_stuff(int arg1, std::map<uint32_t, parent_class>& my_object){
    //do some programmer magic
}

function do_dope_stuff（int arg1，std:：map&my_对象）{
//做一些程序员的魔术
}

然后从两个不同的位置调用此函数，其中一个映射ID为dervired对象类型

do_dope_stuff(int, std::map<uint32_t, child_class1>&) 

or

do_dope_stuff(int, std::map<uint32_t, child_class2>&)

do_dope_stuff（int，std:：map&）
或
do_dope_stuff（int，std:：map&）

---

这显然不起作用，因为没有匹配的函数调用，因为映射是不同类型的。因此，我的基本问题是，我如何才能对映射进行类型转换以使其工作，而不必创建这个巨大映射的副本，并显式地将各个对象转换为兼容的类型。因为child_class对象可以升级到父类，但是编译器不喜欢我尝试在映射上使用C样式转换。我也不想更改函数原型或使其过载，因为它用于大型测试台。

不太确定这是否是您要寻找的，或者它是否可以工作，但是： 你可以

在函数定义中使用模板

有一个映射到对象指针而不是对象，复制指针比复制对象便宜

传递一个指向映射的指针（或者可能是一个空指针），并在函数中重铸该指针

---

使用指向基（父类）的指针或引用，例如：

void do_dope_stuff(int arg1, std::map<uint32_t, parent_class&>& my_object){
    //do some programmer magic
}

void do_dope_stuff(int, std::map<uint32_t, parent_class&>&) {...}


void do_dope_stuff(int, std::map<uint32_t, parent_class&>&) {...}

template<typename T>
void do_dope_stuff(int arg1, T& my_object){
        //do some programmer magic
}

template<typename T>
void do_dope_stuff(int, T&) {...}

template<typename T>
void do_dope_stuff(int, T&) {...}

void do_dope_stuff（int arg1，std:：map和my_对象）{
//做一些程序员的魔术
}
void do_dope_stuff（int，std:：map&）{…}
void do_dope_stuff（int，std:：map&）{…}

或者，如果需要静态多态性，则使用模板，例如：

void do_dope_stuff(int arg1, std::map<uint32_t, parent_class&>& my_object){
    //do some programmer magic
}

void do_dope_stuff(int, std::map<uint32_t, parent_class&>&) {...}


void do_dope_stuff(int, std::map<uint32_t, parent_class&>&) {...}

template<typename T>
void do_dope_stuff(int arg1, T& my_object){
        //do some programmer magic
}

template<typename T>
void do_dope_stuff(int, T&) {...}

template<typename T>
void do_dope_stuff(int, T&) {...}

模板
void do_dope_stuff（int arg1、T和my_对象）{
//做一些程序员的魔术
}
模板
void do_dope_stuff（int，T&）{…}
模板
void do_dope_stuff（int，T&）{…}

设计的问题在于地图包含值。由于派生类的对象可能比父类的对象包含更多的数据，所以即使可以进行某些强制转换（事实并非如此），也会有

多态性方法

另一种方法可以是以一种多元的方式设计类，并在地图中存储对象值，而不是一个指向对象的智能指针：

std::map<uint32_t, shared_ptr<parent_class>> my_map;
my_map[777]=make_shared<parent_class>(); 
my_map[911]=make_shared<child_class>(); // you can mix ! 
my_map[89]=make_shared<parent_class>(); 
do_dope_stuff(1, my_map);

这里有一个包装不同的箱子

仅限模板，如果您想坚持您的原始设计

但也许您希望坚持最初的设计，在映射中保留值，并避免多态性

然后，您可以将函数定义为模板。但是您需要在编译时知道映射中必须处理的对象的类型，然后映射中的所有对象都必须是相同的类型。这看起来像：

template <typename T>
void do_dope_stuff(int arg1, std::map<uint32_t, T>& my_object) {
    //do some programmer magic 
}

模板
void do_dope_stuff（int arg1，std:：map和my_对象）{
//做一些程序员的魔术
}

“我如何才能键入地图”-如果没有，请尽可能使用函数模板。