Как передать данные «универсальному» наблюдателю? В качестве аргументов или в виде единой структуры?

Дизайн с аргументом struct определенно лучше, поскольку он позволяет писать общий код в ObserverContainer. Обычно рекомендуется заменять длинные списки аргументов объектами, которые инкапсулируют аргументы, и это хороший пример выгоды. Создавая более общую абстракцию для вашего notify метода (с помощью структуры, которую вы определяете notify как метод, который принимает фрагмент «данных», тогда как с помощью списка аргументов вы определяете метод, который принимает два числа), вы позволяете себе написать общий код, который использует метод и не должен заботиться о точном составе переданного блока данных.

Почему бы просто не сделать:

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;
};

Вы изучали Boost.Signals? Лучше, чем переделывать колесо.

Что касается параметров: вызов наблюдателя / слота по идее должен быть таким же, как если бы вы вызывали обычную функцию. Большинство реализаций SignalSlots допускают использование нескольких параметров, поэтому используйте их. И, пожалуйста, используйте разные сигналы для разных типов наблюдателей, тогда нет необходимости передавать данные в вариантах.

Два недостатка Observer-Pattern / SignalSlots, которые я видел:
1) Ход программы трудно или даже невозможно понять, глядя только на источник.
2) Сильно динамические программы с большим количеством Observer / SignalSlots могут столкнуться с а "удалить это"

Помимо всего прочего, мне нравятся Observers / SignalSlots больше, чем подклассы и, следовательно, высокая степень связи.

Я не думаю, что какой-либо из ваших подходов будет соответствовать вашим требованиям как есть. Однако небольшая модификация с использованием 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 для обработки беспорядка указателей.

Я бы не понял синтаксис правильно, поэтому просто перечислю объявления, чтобы проиллюстрировать структуры. Общий Observer может ожидать параметр, который либо подклассифицируется для определенных форм ваших требуемых параметров, либо является структурой, включающей горизонтальное сопоставление всех примитивных параметров, которые потребуются вашим Observers. Тогда 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);
};