c++ - 通过继承与对象引用进行回调

Question

比较以下两个变体（应该做同样的事情）

class Foo
    {
    public:
        void void doStuff()
            {
            //...
            doStuffImpl();
            //...
            }

        virtual void doStuffImpl()=0;
        void affectStateInFoo()
            {}
    };

class Bar:public Foo
    {
    public:
        void doStuffImpl()
            {
            affectStateInFoo();
            }
    };

和

class Foo;

class Callback
    {
    public:
        virtual void doStuff(Foo& foo)=0;
    };

class Foo
    {
    public:
        Foo(Callback& o):obj(o){}

        void void doStuff()
            {
            //...
            obj.doStuff(*this);
            //...
            }

        void affectStateInFoo()
            {}

        Callback& obj;
    };

class Bar:public Callback
    {
    public:
        void doStuff(Foo& foo)
            {
            foo.affectStateInFoo();
            }
    };

什么时候更喜欢这两种变体之一？

Answer 1

您的第一个方法需要Bar继承 from Foo，它与这些类紧密结合。对于回调，这并不总是您想要做的。你的第二种方法不需要这个。

如果您实际上扩展了一个类，我将使用第一种方法，但对于通知，我将使用第二种方法，或者如 Igor R. 在评论中提到的那样使用函数指针，如对象。

Answer 2

我更喜欢第二个，因为它更易于使用模拟进行单元测试。但那只是我的个人意见。

Answer 3

对于面向对象的新手来说，每个继承的过度操作是常见的失败。

使用委托，你称之为回调，通常更灵活。

• 班级人数较少
• 可能重用“回调”类
• 在运行时而不是编译时可交换