Question

我正在寻找一个优雅的解决方案。我试图找到一个指定的设计模式并为此案例提供解决方案，但我找不到。

我有一个用于存储常规对象的基类，稍后会调用它。我希望执行将分为两部分：

A必须有一个总是发生的部分（do1st（））。
用户定义的代码（do2nd（））。

例如：

class InvokeBase
{
public:
    InvokeBase(void *ptr) : context_(ptr) {}
    virtual ~InvokeBase () {}
    void operator()() = 0; 
protected:
    void do1st() {//Mandatory code to execute for every InvokeBase type when calling operator()};
    void * context_;
};

class InvokeDerived : public InvokeBase
{
public: 
    InvokeDerived(void *ptr) : base(ptr){}
    virtual ~InvokeDerived();
    void do2nd() {//User defined code}
    void operator()()  
    {
        do1st();  // << How to force this execution?
        do2nd();
    } 
};

void main()
{
     InvokeBase *t = new InvokeDerived();
     t(); // << here i want the execution order will be do1st and then do2nd. 
}

诀窍是我想do1st将永远执行，我不必从InvokeDerived调用它。我想允许用户从InvokeBase继承，并保证在调用operator（）时始终会调用do1st。

Answer 1

这是模板方法模式：将具有半灵活行为的函数跨类层次结构拆分为多个部分，并使虚拟仅变更为：

class InvokeBase
{
public:
    InvokeBase(void *ptr) : context_(ptr) {}
    virtual ~InvokeBase () {}
    void operator()() // this is non-virtual (this is the template method)
    {
        do1st();
        do2nd(); // this resolves to virtual call
    }

protected:
    void do1st() { /* fixed code here */ };
    virtual void do2nd() = 0; // variable part here
    void * context_;
};

class InvokeDerived : public InvokeBase
{
public: 
    InvokeDerived(void *ptr) : base(ptr){}
    virtual ~InvokeDerived() = default;

protected:
    void do2nd() override
    {
        // code speciffic to InvokeDerived here
    }
};

必须调用第一个设计模式

1 个答案: