(我看到之前有人在 SO 上提出过类似的问题，但我看到的问题似乎并没有完全触及我的用例。特别是，我想知道我的编译失败是错误的结果，或者是我尝试的结果是 verboten。)

背景

我希望实现委托(delegate)模式，用于事件处理。我认为也许满足我需求的最佳方法是成员函数指针映射，由 std::string 索引(代表事件类型。)

我开始尝试使用 std::function 来完成此操作，但遇到了一些问题，然后决定仅使用原始 MFP 进行尝试。 (我仍然愿意考虑 std::function，我会接受一个答案，该答案显示了如何使用该方法在下面完成我的确切需求。但我仍然想知道有什么问题我目前的方法。)

我能够通过一个类来完成这项工作。但是我实际上希望委托(delegate)映射由抽象基类提供，然后让派生类将其委托(delegate)注册到该映射中。除非我在下面的代码中犯了一些错误，否则这似乎是不可能的；看来成员函数指针不能是多态的。

我得到的编译错误是这样的:

mfp5.cpp: In constructor ‘Derived::Derived()’:
mfp5.cpp:41:21: error: cannot convert ‘int (Derived::*)(const Base::EventContext&)’ to ‘std::map<std::basic_string<char>, int (Base::*)(const Base::EventContext&)>::mapped_type {aka int (Base::*)(const Base::EventContext&)}’ in assignment
_delegates["foo"] = &Derived::FooEventHandler;

问题

1. 我是不是在下面的代码中犯了错误，或者这真的是不允许的吗？简而言之，我有一个 Base::* 的 std::map，我想在其中插入一些 Derived::*。
2. 是否有其他推荐的方法来完成此任务？

代码

class Base
{
  public:
    struct EventContext
    {
      int data1;
    };
    Base() {}
    virtual int ProcessEvent(std::string event, EventContext ctx) =0;

  protected:
    typedef int (Base::* EventHandler)(const EventContext& context);
    typedef std::map<std::string, EventHandler> EventDelegateMap;
    EventDelegateMap _delegates;
};

.

class Derived: Base
{
  public:
    Derived();
    int ProcessEvent(std::string event, EventContext ctx);

  private:
    int FooEventHandler(const EventContext& context);
    int BarEventHandler(const EventContext& context);
    int QuxEventHandler(const EventContext& context);
};

Derived::Derived() :Base()
{
  _delegates["foo"] = &Derived::FooEventHandler;  // error
  _delegates["bar"] = &Derived::BarEventHandler;  // error
  _delegates["qux"] = &Derived::QuxEventHandler;  // error
}

最佳答案

看来你想使用std::function，我会这样说:

class Base
{
  public:
    struct EventContext
    {
      int data1;
    };
    Base() {}
    virtual int ProcessEvent(std::string event, EventContext ctx) =0;

  protected:
    typedef std::function<int(const EventContext&)> HandlerType;
    typedef std::map<std::string, HandlerType> EventDelegateMap;
    EventDelegateMap _delegates;
};

class Derived: Base
{
  public:
    Derived();
    int ProcessEvent(std::string event, EventContext ctx){ return 0; }

  private:
    int FooEventHandler(const EventContext& context){ return 0; }
    int BarEventHandler(const EventContext& context){ return 0; }
    int QuxEventHandler(const EventContext& context){ return 0; }
};

Derived::Derived() :Base()
{
    auto self = this; // Some gcc versions cannot capture this correctly.
    _delegates["foo"] = [=](const EventContext& context) { return self->FooEventHandler(context); };
    _delegates["bar"] = [=](const EventContext& context) { return self->BarEventHandler(context); };
    _delegates["qux"] = [=](const EventContext& context) { return self->QuxEventHandler(context); };
}

应该工作...

编辑:正如@Joachim 在他的评论中提到的，您也可以使用 std::bind() 生成所需的 std::function 对象，例如

_delegates["foo"] = std::bind(&Derived::FooEventHandler, this, std::placeholders::_1);

我使用 lambda 来表明在现实中，您可以在 lambda 中实现整个逻辑。这种方法的主要优点是，如果您要实现更多的处理程序，则工作量会更少，而且我总是赞成更少的工作量……:)

关于c++ - 具有派生成员函数指针的多态性？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/20186661/