如何将数据传递给“通用”观察者？作为参数还是作为单个结构？

Question

我正忙于向旧版 C++ 应用程序添加通用观察者机制（使用 Visual Studio 2010，但不使用 .Net，因此不可能使用 .Net 委托）。

在设计中，我希望尽可能地将特定于应用程序的部分与通用观察者机制分开。

实现观察者的最合乎逻辑的方式似乎是这样的：

class IDoThisObserver
   {
   public:
      void handlDoThis(int arg1, int arg2) = 0;
   };

对于每种类型的观察者（IDoThisObserver、IDoThatObserver，...），方法（handleDoThis、handleDoThat）的参数都是不同的。

存储观察者的通用方式仍然存在，如下所示：

template<typename T>
class ObserverContainer
   {
   public:
      void addObserver (T &t) {m_observers.push_back(&t);}
   private:
      std::list<T*> m_observers;
   };

调用观察者不能通用，因为每个观察者类型的参数都不同。

另一种方法是将所有参数“打包”到一个参数中，如下所示：

struct DoThisInfo
   {
   DoThisInfo (int arg1, int arg2) : m_arg1(arg1), m_arg2(arg2) {}
   int m_arg1;
   int m_arg2;
   };

然后定义一个更通用的观察者，如下所示：

template<typename T>
class IObserver
   {
   public:
      void notify(const T &t) = 0;
   };

然后这些观察者的集合将变成这样：

template<typename T>
class ObserverContainer
   {
   public:
      void addObserver (IObserver<T> &obs) {m_observers.push_back(&obs);}
   private:
      std::list<IObserver<T>*> m_observers;
   };

现在，可以集中添加更多逻辑这个ObserverContainer，包括调用所有的观察者。呼叫的“发起者”只需创建并填写通知结构。

想要从多种观察者继承的类需要这样做：

class MyObserver : public IObserver<NotifyThis>, public IObserver<NotifyThat>
   {
   ...
   };

以下哪种方法（具有多个显式参数或一个结构参数的观察者）似乎是最好的？这两种方法有什么优点或缺点吗？

编辑：我进一步研究了替代方法，槽/信号方法似乎是另一个不错的候选者。我应该了解 Slot/Signal 中的任何重要缺点吗？

Answer 1

我认为您的任何一种方法都不符合您的要求。然而，使用包含传递给所有观察者的数据集的 DataCarrier 进行一点修改，其中每个观察者都知道要读取什么内容，就可以达到目的。下面的示例代码可能会清除它（注意我还没有编译）

 enum Type {
    NOTIFY_THIS,
    NOTIFY_THAT
 };

 struct Data {
 virtual Type getType() = 0;
 };

 struct NotifyThisData: public Data {
    NotifyThisData(int _a, int _b):a(_a), b(_b) { }
    int a,b;
    Type getType() { return NOTIFY_THIS; }
 };

 struct NotifyThatData: public Data {
    NotifyThatData(std::string _str):str(_str) { }
    std::string str;
    Type getType() { return NOTIFY_THAT; }
 };

 struct DataCarrier {
    std::vector<Data*> m_TypeData;  
 };

 class IObserver {
 public:
     virtual void handle(DataCarrier& data) = 0;
 };

 class NotifyThis: public virtual IObserver {
 public:
         virtual void handle(DataCarrier& data) {
                 vector<Data*>::iterator iter = find_if(data.m_TypeData.begin(), data.m_TypeData.end(), bind2nd(functor(), NOTIFY_THIS);
                 if (iter == data.m_TypeData.end())
                         return;
                 NotifyThisData* d = dynamic_cast<NotifyThisData*>(*iter);
                 std::cout << "NotifyThis a: " << d->a << " b: " << d->b << "\n";
         }
 };

 class NotifyThat: public virtual IObserver {
 public:
         virtual void handle(DataCarrier& data) {
                 vector<Data*>::iterator iter = find_if(data.m_TypeData.begin(), data.m_TypeData.end(), bind2nd(functor(),NOTIFY_THAT);
                 if (iter == data.m_TypeData.end())
                         return;            
                 NotifyThatData* d = dynamic_cast<NotifyThatData*>(*iter);
                 std::cout << "NotifyThat str: " << d->str << "\n";
         }
 };

 class ObserverContainer
    {
    public:
       void addObserver (IObserver* obs) {m_observers.push_back(obs);}
       void notify(DataCarrier& d) {
                 for (unsigned i=0; i < m_observers.size(); ++i) {
                         m_observers[i]->handle(d);
                 }
         }
    private:
       std::vector<IObserver*> m_observers;
    };

 class MyObserver: public NotifyThis, public NotifyThat {
 public:
         virtual void handle(DataCarrier& data) { std::cout << "In MyObserver Handle data\n"; }
 };

 int main() {
         ObserverContainer container;
         container.addObserver(new NotifyThis());
         container.addObserver(new NotifyThat());
         container.addObserver(new MyObserver());

         DataCarrier d;
         d.m_TypeData.push_back(new NotifyThisData(10, 20));
         d.m_TypeData.push_back(new NotifyThatData("test"));

    container.notify(d);
    return 0;
 }

这样，如果您添加新结构，您只需修改枚举。
你也可以使用 boost::shared_ptr 来处理混乱的指针。

Answer 2

我无法正确理解语法，因此我将列出声明来说明结构。可以使通用观察者期望一个参数，该参数要么是所需参数的特定形式的子类，要么是包含观察者所需的所有原始参数的水平映射的结构。那么 ObserverContainer 就可以充当 AbstractFactory ，并且 ObserverContainer 的每个子类都可以是 DoThatObserverFactory 和 DoThisObserverFactory。工厂将构建一个观察者并向观察者分配一个配置，以告诉它需要哪个参数。

class AbstractObserverFactory {...};
class DoThatObserverFactory : AbstractObserverFactory {...};
class DoThisObserverFactory : AbstractObserverFactory {...};
class ObserverParam {...};
class DoThatObserverParam : ObserverParam {...};
class DoThisObserverParam : ObserverParam {...};
class Observer;
class DoThisObserver : public Observer
{
   public:
      void handlDoThis(DoThisObserverParam);
};

Answer 3

为什么不直接做：

class IObserver {
    // whatever is in common
};

class IDoThisObserver : public IObserver
{
   public:
      void handlDoThis(int arg1, int arg2) = 0;
};

class IDoThatObserver : public IObserver
{
   public:
      void handlDoThat(double arg1) = 0;
};

？

那么你有：

class ObserverContainer
{
   public:
      void addObserver (IObserver* t) {m_observers.push_back(t);}
   private:
      std::list<IObserver*> m_observers;
};

Answer 4

使用 struct 参数的设计肯定更好，因为它允许在 ObserverContainer 中编写通用代码。用封装参数的对象替换较长的参数列表通常是一种很好的设计实践，这是回报的一个很好的例子。通过为您的 notify 方法创建更通用的抽象（使用您将 notify 定义为需要大量“数据”的方法的结构，而使用 arg 列表，您可以定义一个需要两个数字的方法），您可以自己编写使用该方法的通用代码，而不必关心传入的数据块的确切组成。

Answer 5

您研究过 Boost.Signals 吗？比重新实现轮子更好。

至于参数：从概念上讲，调用观察者/槽应该与调用普通函数相同。大多数 SignalSlots 实现都允许多个参数，因此请使用它。并且请针对不同的观察者类型使用不同的信号，这样就不需要在 Variants 中传递数据。

我见过的观察者模式/信号槽的两个缺点：
1）仅看源码很难甚至不可能理解程序流程。
2）具有大量观察者/信号槽的高度动态程序可能会遇到“删除这个”

一切都放在一边，我更喜欢观察者/信号槽而不是子类化，因此高度耦合。