这个简单但有用的模式是不是太简单了，不可能成为一个真正的模式

Is this simple but useful pattern too simple to be a real pattern?

本文关键字：模式 简单 能成为 一个 有用 是不是      更新时间：2023-10-16

覆盖派生函数行为，同时仍调用其父函数的同一函数，例如参见C:：foo（）。它仍然有A:：foo的行为，但扩展了它。作为一个模式太简单了吗？

class A
{
public:
    virtual ~A() {}
    virtual void foo(){ MSG("A::foo");}
};
class B : public A
{
public:
    virtual void foo(){ MSG("B::foo");}
};
class C : public B
{
public:
    virtual void foo(){ 
        A::foo(); //here still have the behaviour of A::foo but extended it
        MSG("C::foo");
    }
};
void callFoo(A* p)
{
    p->foo();
}
int main()
{
    boost::scoped_ptr<A> myPtr(new A());
    callFoo(myPtr.get());
    myPtr.reset(new B());
    callFoo(myPtr.get());
    myPtr.reset(new C());
    callFoo(myPtr.get());
    return 0;
}

"简单但有用的模式"指的是"语言特性"。你不能只使用一次语言功能就称之为模式。这不是一种模式。只是你在使用一种语言功能。我的意思是，祝贺你，我还认为使用语言功能是用一种语言构建程序的一种重要方式，但是，这与任何模式都相去甚远。

设计元素不需要复杂才能被称为"模式"。

然而，有一项要求是它是有用的；它使制作正确、连贯、高效和灵活的设计变得更加容易。在基类中实现有用的功能，然后给派生类增加负担，让它们记住手动调用它，并不能真正满足这一要求，所以我很想把它称为"反模式"。添加一个中间基类，并期望派生类实现者找出他们真正想要的覆盖，这更像是一个"混乱的混乱"。

如果你想要一个真正的模式（在一本著名的书中用大写字母描述）来解决这种情况，那么Template方法可能是合适的——基类包含一个非虚拟函数，该函数执行一些常见的功能，将部分工作委托给可以重写的私有、纯虚拟

class FooInterface {
public:
    virtual ~FooInterface() {}
    virtual void foo() = 0;
};
class A {
public:
    void foo(FooInterface & impl) {
        MSG("A::foo"); // Happens whatever the implementation does
        impl.foo();
    }
};
class C : public FooInterface {
    virtual void foo() {
        // We don't have to worry about A at all
        MSG("C::foo");
    }
};

相关文章：