C++ c++；成员函数映射的find（）

我有两个继承类。我希望允许类将其函数存储在一个映射中。如何通过键创建find函数？函数的继承会起作用吗（MyClass_2没有自己的doSmth（）函数，它应该从MyClass中添加doSmth（））？我的尝试如下

template<class T>
class Class1
{
    typedef void(T::*MyFunction)();
    map<string, MyFunction> functionMap;
    public:
        void addFunc(string funcName, MyFunction function) {
            functionMap.insert(pair<string, MyFunction>(funcName, function));
        }

        bool findFunc(string key) {
            typename map<string, MyFunction>::iterator it;

            it = functionMap.find(key.c_str());
        }
};


class MyClass {

    Class1<MyClass> class1;

    void addFunc() {
        class1.addFunc("Func1", &MyClass::doSmth);
    }

    void findAndCallFunc(string key) {
        class1.findFunc(key);
    }

    void doSmth();

};

class MyClass_2: MyClass {

    Class1<MyClass_2> class1;

    void addFunc() {
        class1.addFunc("Func1", &MyClass_2::doSmth);
    }

}

模板
一班
{
typedef void（T:：*MyFunction）（）；
地图功能图；
公众：
void addFunc（字符串funcName，MyFunction）{
insert（对（functname，function））；
}
bool findFunc（字符串键）{
typename映射：：迭代器；
it=functionMap.find（key.c_str（））；
}
};
类MyClass{
1类；
void addFunc（）{
class1.addFunc（“Func1”，&MyClass:：doSmth）；
}
void findAndCallFunc（字符串键）{
类别1.findFunc（钥匙）；
}
void doSmth（）；
};
类别MyClass_2:MyClass{
1类；
void addFunc（）{
类1.addFunc（“Func1”和MyClass_2:：doSmth）；
}
}

编辑：我测试了我的程序。它起作用了。我的问题是，如果我从MyClass_2的对象调用fundAndCallFunc。它不是MyClass_2的class1，而是MyClass的class1。

---

我应该改变什么？

这里有两个显而易见的问题：

• 您的

  findFunc

  方法只是查找函数，它对函数没有任何作用（尝试调用它或返回方法指针），并且它声明为返回

  bool

  ，而不是

  MyFunction

  ——不确定您希望它做什么

• 您的

  doSmth

  方法在MyClass中是私有的，因此您无法在MyClass_2中访问它。您需要将其设置为受保护或公开

---

正如Chris所说，您的

findFunc

应该返回实际函数：

MyFunction findFunc(string key)
{
  const map<string, MyFunction>::const_iterator it = functionMap.find(key);
  return it == functionMap.end() ? NULL : it->second;
}

在

addFunc

中，您会说

functionMap.insert(std::make_pair(funcName, std::make_pair(this, function)));

用法：假设

it=functionMap.find（“key”）

。然后你可以说：

MyClass * const p = it->second.first;
MyFunction      f = it->second.second;

p->*f();  // invoke -- yes, it's operator->*() in action

MyClass * const p = it->second.first;
MyFunction      f = it->second.second;

p->*f();  // invoke -- yes, it's operator->*() in action