不同类方法间高效共享数据的设计方案——A封装B/C/D场景

假设有类A封装了类B、C和D。类B拥有回调函数B::callback()，该函数生成的数据需先经C::foo()处理，最终由D::foo()完成处理。

初始代码如下：

class A{
   public:
      void f(){
         B.run();
         //C.run();
         //D.run();
      }

   private:
      B b;
      C c;
      D d;
};

class B{
   public:
      void run(){
        set_process(callback,void* arg);  // external_lib::set_process
      }
      void callback(){
         data = get_data();
      }

   private:
      float *data;
};

class C{
   public:
      void foo(float *data){
          // 处理数据
      }
};

class D{
   public:
      void foo(float *data){
          // 最终处理数据
      }
};

我的问题是：应如何设计数据流，以实现B、C和D之间的数据共享？

当前基础方案及问题 #

我当前采用的是一种基础方案：定义一个非成员静态函数void helper()，在B::callback()中调用它，通过成员函数指针调用C::foo()和D::foo()，代码如下：

void helper(float* data,void* args){
    static_cast<C*>(args)->foo(data);
    static_cast<D*>(args)->foo(data);
}

class A{
//...
};

void B::callback(){
    data = get_data();
    void *args = nullptr;
    helper(data,args);
}

但由于我开发的是实时应用，希望找到优化方案。该方案的问题在于类型转换时会创建B和C的副本，我曾考虑将helper()设为A的成员函数A::helper()，通过函数指针传递给B，至少可以对c和d进行引用转换，但这会让逻辑更复杂。

最终可行方案 #

方案思路 #

在A中创建成员函数A::share_data，用于将数据传递给C::foo和D::foo，通过创建setter并结合std::function和std::bind将该函数传递给B。这样B就可以调用A的成员函数，将数据共享给其他成员对象。

完整示例代码 #

class A{
   public:
      void f(){
         b.set_caller(std::bind(&A::share_data,this,std::placeholders::_1));
         B.run();
         //C.run();
         //D.run();
      }
      
      void share_data(float *data){
         c.foo(data);
         d.foo(data);
      }
   private:
      B b;
      C c;
      D d;
};

class B{
   public:
      void run(){
        set_process(callback,void* arg);  // external_lib::set_process
      }
      void callback(){
         data = get_data();
         _share_data(data);
      }

      void set_caller(std::function<void(float*)> A_member_f){
          _share_data=A_member_f;
      }
   private:
      float *data;
      std::function<void(float*)> _share_data;
};

欢迎各位提出意见。

内容的提问来源于stack exchange，提问作者cestpasmoi