c++ - 装饰器模式 : how can I call(back) some members of decorator wrappers from the core class

Question

我正在按照 here 中的示例实现装饰器模式:

• 类 I:是接口(interface)类，核心类和装饰器基类都是通用的
• 类 A:是核心类
• 类 D:是装饰器基类
• 类X、Y、Z:继承自装饰器基类并扩展< em>核心类动态

类 A 中有一个方法 (A::endTraining())，它在计时器变量结束时触发(也存在于类 中) >A).该方法需要调用X、Y和Z类的一些成员。
是否可以？这是好的做法吗？怎么办？

例如，创建一种机制来在 A 类中注册 pointers-to-XYZ::endTraining 是正确的方法吗？

(仅显示相关位)

typedef void (D::*pCallback_fn)(void);

class I 
{
  public:
    virtual void endTraining() = 0;
    virtual void regTrainingCallbacks(pCallback_fn ptrFn) = 0;
};

class A: public I {
  public:

    void endTraining() {
        //do stuff
        //then do stuff in D (and its derivatives)
        //   by iterating through fnList
    }
    void regTrainingCallbacks(pCallback_fn ptrFn) 
    { 
        fnList.push_back( ptrFn ); 
    }
  private:
    std::list<pCallback_fn> fnList;
};

class D: public I {
  public:
    D(I *inner) {
        m_wrappee = inner;
    }
    void regTrainingCallbacks(pCallback_fn ptrFn) 
    { 
        m_wrappee->regTrainingCallbacks(ptrFn); 
    }
  private:
    I *m_wrappee;
};

class X /*,Y,Z*/ : public D {
  public:
    X(I *core): D(core)
    {
        D::regTrainingCallbacks( this->*endTraining() ); //
    }
  private:
    void endTraining(){
      //do stuff when called by A::endTraining() through D
    }
};

可以做什么？

Answer 1

解决原始设计中的一个错误，其中“训练器”(注册训练回调的实体)本身必须是一个回调(通知器 - 前类 A - 是否有任何理由必须本身就是一个回调？)。

我更改了类名以证明它们的职责。

MainTrainingProcess 替换了原始的 class A(其实例将被 D-es 包装)和 D 本身。

class EndTrainingListener
{
public:
  virtual ~EndTrainingListener() { }

  virtual void endTraining()=0;
};

class ITrainingProcess
{
public:
  virtual ~ITrainingProcess() { }
  virtual void regTrainingCallbacks(EndTrainingListener* callback) = 0;
};

class MainTrainingProcess : public ITrainingProcess {
public:
  virtual ~MainTrainingProcess() {
    // destroy other resources used during training
  }

  virtual void regTrainingCallbacks(EndTrainingListener* callback) {
    this->listeners.push_back(callback);
  }

  void train() {
    // do training stuff
    // ...
    // do my specific actions at the end of training
    // ...

    // finish by notifying all listeners
    this->atEndTraining();
  }
protected:
  void atEndTraining() {
    for(auto l : this->listeners) {
      l->endTraining();
    }
  }

  std::list<EndTrainingListener*> listeners;
};

class X /*Y, Z*/ : public EndTrainingListener {
public:
  virtual ~X();

  virtual void endTraining() {
    // do specific stuff
  }
};