Question

注意：下面的代码示例不是真正的代码，真正的代码在这里粘贴要复杂得多，所以这个例子可能看起来很荒谬，但并不重要。

struct Base
{
    void beginEvent(int a)
    {
        impl(a, &Base::onBeginEvent, &Base::onBeginEvent);
    }

    void endEvent(int a)
    {
        impl(a, &Base::onEndEvent, &Base::onEndEvent);
    }

    void impl(int a, void (Base::*func1)(int), void (Base::*func2)(int, int))
    {
        //some complicated behavior
        //...
        (this->*func1)(a);
        (this->*func2)(a, -a);
    }

    virtual void onBeginEvent(int a){}
    virtual void onBeginEvent(int a, int negativeA){}
    virtual void onEndEvent(int a){}
    virtual void onEndEvent(int a, int negativeA){}
};

和

struct Derived : public Base
{
    void onBeginEvent(int a) { std::cout << a << "\n"; }
    void onEndEvent(int a, int b) { std::cout << a << "==(-(" << b << "))\n"; }
};

int main() 
{
    Derived d;

    d.beginEvent(3);
    d.endEvent(9);

    return 0;
}

我的问题是：是否真的有必要定义impl函数的方式void (Base::*func1)(int)和void (Base::*func2)(int, int)即使我知道它是一个成员函数指针（在这种情况下为&Base::onBeginEvent）？

当只提供其中一个时，我显然得到的太少了。在打电话时要多说些什么。我不想要可变函数或其他东西，我想要有限数量的方法可以Base提供给Derived。派生可能只需要调用一个或任何提供的方法子集。但我知道，它们只会在同一个符号上超载。我的目标不是让它适用于一些疯狂的解决方法，我只想知道，如果我可以减少发布的代码。

：Full ideone working example

修改在我的实际代码中，thme impl方法非常复杂，在开始和结束时只是使用不同的调用来结束impl ...

Answer 1

如何用多态行为替换函数指针，这实际上是相同的，但更多的OO，更直观，更容易阅读。

以下是一个例子：

struct Base
{
    void beginEvent(int a)
    {
        implBegin(a);
    }

    void endEvent(int a)
    {
        implEnd(a);
    }

// Consider making the rest of the methods protected    
// protected:

    // This is effectively a Template Method Design pattern
    // This method may not be necessary, in which case just
    // move the code to beginEvent()
    void implBegin(int a)
    {
        onBeginEvent(a);
        onBeginEvent(a, -a);
    }

    // This is effectively a Template Method Design pattern
    // This method may not be necessary, in which case just
    // move the code to endEvent()
    void implEnd(int a)
    {
        onEndEvent(a);
        onEndEvent(a, -a);
    }

    virtual void onBeginEvent(int a){}
    virtual void onBeginEvent(int a, int negativeA){}
    virtual void onEndEvent(int a){}
    virtual void onEndEvent(int a, int negativeA){}
};

struct Derived : public Base
{
    // Notice I defined these as virtual
    virtual void onBeginEvent(int a) { std::cout << a << "\n"; }
    virtual void onEndEvent(int a, int b) { std::cout << a << "==(-(" << b << "))\n"; }
};

int main() 
{
    Derived d;

    d.beginEvent(3);
    d.endEvent(9);

    return 0;
}

请注意，implBegin（）和impleEnd（）可能不是必需的你可以在beginEvent（）和endEvent（）中做同样的事情这是指向Template Method设计模式的链接。

另一种方法是按原样定义Base，但也许称之为EventManager，并创建EventHandlers的类层次结构，可能是EventBase和EventDerived。然后可以将EventHandlers注入到EventManager中（通过setEventHandler（）方法）。

Answer 2

你说...the way it takes void (Base::*func1)(int) and void (Base::*func2)(int, int) even though I know that it is one member function pointer...，谁告诉你他们都是一个功能？仅仅因为2个函数具有相同的名称，它绝不意味着它们具有相同的功能。他们的地址和除名字之外的所有东西都不同。所以他们是2个不同的功能而不是一个功能

重载成员函数的成员函数指针

2 个答案: