Question

我有一个场景，我想我是否可以应用任何设计模式。场景是这样的：基类有2个派生类，在main函数中我们需要对派生类进行相同的操作。我需要用c ++。

例如：

Class Base
{
    virtual bool DoWeHaveToPerformOperation()=0;
    virtual void PerformOperation()=0;
};

Class Derived1:public Base
{
    bool DoWeHaveToPerformOperation();
    void PerformOperation();
};

Class Derived2:public Base
{
    bool DoWeHaveToPerformOperation();
    void PerformOperation();
};

int main()
{
    Derived1 d1;
    if(d1.DoWeHaveToPerformOperation())
    {
        d1.PerformOperation();
    }

    Derived2 d2;
    if(d2.DoWeHaveToPerformOperation())
    {
        d2.PerformOperation();
    }
}

我想知道是否有一些我可以如何优化代码（或者如果有一种可以使用的模式），而不是像main中那样编写。我想到的至少是移动单独函数的公共代码，并为

这两个对象调用它

CheckAndOperate(Base* b)
{
    if(b->DoWeHaveToPerformOperation())
    {
        b->PerformOperation();
    }
}

并为两个派生对象调用它。但我觉得它仍然可以优化..

int main()
{
    base* b1=new derived1();
    CheckAndOperate(b1);
    base* b2=new derived2();
    CheckAndOperate(b2);
    delete b1;
    delete b2;
}

有什么建议吗？。

Answer 1

Template Method模式通常会处理此类事情。

Class Base
{
public:
    void PerformOperation()
    {
        if(DoWeHaveToPerformOperation())
        {
            DoPerformOperation();
        }
    }

protected:
    virtual bool DoWeHaveToPerformOperation()=0;
    virtual void DoPerformOperation() = 0;
};

Class Derived1:public Base
{
    bool DoWeHaveToPerformOperation();
    void DoPerformOperation();
};

Class Derived2:public Base
{
    bool DoWeHaveToPerformOperation();
    void DoPerformOperation();
};

int main()
{
    Derived1 d1;
    d1.PerformOperation();

    Derived2 d2;
    d2.PerformOperation();

    return 0;
}

Answer 2

是的，将公共代码放入函数中是正确的做法。

void CheckAndOperate(Base &b) {
  if(b.DoWeHaveToPerformOperation()) {
    b.PerformOperation();
  }
}

此外，您的示例并不需要动态分配：

int main() {
  Derived1 d1;
  CheckAndOperate(d1);
  Derived2 d2;
  CheckAndOperate(d2);
}

编译器可能能够执行内联和虚拟化，但如果您想鼓励它，您可以在模板中实现共享代码：

template<typename CheckableAndOperatable>
void CheckAndOperate(CheckableAndOperatable &x) {
  if(x.DoWeHaveToPerformOperation()) {
    x.PerformOperation();
  }
}

在C ++ 11中，你可以通过制作派生的实现方法final来进一步发展;编译器知道如果它有一个派生类型，那么它总是可以对最终方法进行半虚拟化调用：

class Derived1 : public Base {
public:
    bool DoWeHaveToPerformOperation() final;
    void PerformOperation() final;
};

任何设计模式，以将相同的操作应用于所有派生对象

2 个答案: