Mettre en œuvre un « modèle d'observation statique »

Question

J'ai une classe avec un modèle de méthode:

struct Subject 
{ 
    template <typename T> 
    void doSomething() 
    { 
    .. 
    } 
}; 

Maintenant, chaque fois que doSomething est appelé (avec un T) Je voudrais avoir un « observateur » soit informé:

template <typename T> 
    void onDoSomething() 
    { 
    .. 
    } 

Il est important que l'observateur est un modèle de méthode (modèle de classe avec méthode reprise fonctionnerait aussi bien). Si ce n'était pas le cas, je pourrais simplement mettre en œuvre le modèle d'observateur commun.

Il serait autorisé à modifier Subject::doSomething() afin qu'il appelle une méthode. Cependant, la classe Subject ne devrait pas "connaître" la méthode Observer/Observer concrète.

L'idée sous-jacente est: J'utilise Subject dans deux projets. J'ai besoin (et j'ai) de l'observateur seulement dans l'un d'entre eux.

Y a-t-il un moyen d'y parvenir?

Answer 1

difficile. Il semble faire bouillir jusqu'à

La notification doit être résoluble au moment de la compilation (c'est un modèle)

et, en même temps,

La notification ne doit pas être résoluble à compiler le temps (Subject ne devrait pas connaître l'observateur)

Je peux penser à deux façons de le faire:

---

1. Ajouter une surcharge de doSomething:

template <typename T, typename Observer> 
void doSomething() 
{ 
    doSomething<T>(); 
    Observer::onDoSomething<T>(); 
} 

appellent alors la version d'un paramètre dans le projet A, et la version à deux paramètres dans le projet B.

---

2. avoir le fichier définissant Subject comprennent un en-tête qui sera différent/différemment configuré dans chaque projet:

Subject.h

#include "observer_def.hpp" 

struct Subject 
{ 
    template <typename T> 
    void doSomething() 
    { 
    .. 
    notifyDoSomething<T>(); 
    } 
}; 

observer_def.hpp dans le projet A:

template <typename> 
inline void notifyDoSomething() {} 

observer_def.HPP dans le projet B:

template <typename T> 
inline void notifyDoSomething() 
{ 
    MyObserver::onDoSomething<T>(); 
} 

Answer 2

j'ai finalement trouvé une solution satisfaisante au moyen de spécialisation de modèle:

///signaling struct. Could be replaced with any other type. 
struct SpecializedObserver{}; 

///unspecialized: 
template <typename> 
struct Observer 
{ 
    template <typename T> 
    static void onDoSomething() 
    { 
     //default: do nothing. 
    } 
}; 

///optional. Specialize in project A or leave aside in project B: 
template<> 
struct Observer<SpecializedObserver> 
{ 
    template <typename T> 
    static void onDoSomething() 
    { 
     std::cout << "doing something with " << typeid(T).name() << std::endl; 
    } 
}; 

struct Subject 
{ 
    template <typename T> 
    void doSomething() 
    { 
     Observer<SpecializedObserver>::onDoSomething<T>(); 
     .. 
    } 
}; 

Cette solution ne nécessite aucune action si je ne veux pas d'observateur. Dans le cas où je veux en avoir un, je spécialise le modèle Observer comme indiqué ci-dessus.

EDIT: Cela a bien fonctionné dans mon test, mais la question est de savoir comment l'utiliser dans un scénario avec différentes unités de compilation - où devrais-je définir la spécialisation?