Discussion :

[CedricMocquillon]

Bonjour à tous,

J'ai un problème avec l'implémentation du design pattern observer/observable:
http://come-david.developpez.com/tut...servateur#LVII.
Le programmeur doit mémoriser pour un observer donné, tous les objets qu'il observe pour qu'il se désenregistre auprès des observables avant sa destruction (avec la méthode DelObs). Dans ce cas, ne vaudrait-il pas mieux qu'il y ait également une liste d'observables dans la classe observer et le désenregistrement pourrait alors se faire automatiquement dans le destructeur de la classe Observer?

[Davidbrcz]

On peut aussi faire comme ca.
Ca impose un couplage un peu plus fort entre observable/observé mais en même temps, ca simplifie les cas où les observateurs/observable change souvent.
Voici le code correspondant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
#ifndef OBS_H
#define OBS_H
 
typedef int Info;
/*
Ici info est un typedef.
Mais dans un cas réel,on pourrai faire des classes du type:
InfoBase |<- InfoBarometre
		 |<- InfoThermometre 
avec un opérateur << appelant une fonction Afficher(ostream& flx)  polymorphique
*/
 
class Observable;
 
class Observateur
{
  std::vector<Observable*> m_list;
 protected:
    virtual ~Observateur() = 0;
 public:
    void Update(const Observable* observable) const ;
 
    void AddObs(Observable* obs);
    void DelObs(Observable* obs);
};
 
class Observable
{
    std::vector<Observateur*> m_list;
 
 public:
    void AddObs( Observateur* obs);
    void DelObs(Observateur* obs);
 
	virtual Info Statut(void) const =0;
    virtual ~Observable();
 protected:
    void Notify(void);
 
};
 
class Barometre : public Observable
{
    int pression;
public:
    void Change(int valeur);
 
    int Statut(void) const;
};
 
class Thermometre : public Observable
{
    int temperature;
public:
 
    void Change(int valeur);
 
    Info Statut(void) const;
};
 
class MeteoFrance : public Observateur
{
 
};
 
#endif
 
#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
 
#include "observerntpl2.h"
 
using namespace std;
 
void Observateur::Update(const Observable* observable) const
{
  cout<<observable->Statut()<<endl;
}
 
Observateur::~Observateur()
{
        vector<Observable*>::iterator itb=m_list.begin();
	vector<Observable*>::const_iterator ite=m_list.end();
 
	for(;itb!=ite;itb++)
	{
		 (*itb)->DelObs(this);
	}
}
 
void Observateur::AddObs( Observable* obs)
{
    m_list.push_back(obs);
}
 
void Observateur::DelObs(Observable* obs)
{
    remove(m_list.begin(),m_list.end(),obs);
}
 
void Observable::AddObs( Observateur* obs)
{
    m_list.push_back(obs);
}
 
void Observable::DelObs(Observateur* obs)
{
    remove(m_list.begin(),m_list.end(),obs);
}
 
 
Observable::~Observable()
{
        vector<Observateur*>::iterator itb=m_list.begin();
	vector<Observateur*>::const_iterator ite=m_list.end();
 
	for(;itb!=ite;itb++)
	{
		 (*itb)->DelObs(this);
	}
}
 
void Observable::Notify(void)
{
	 vector<Observateur* >::iterator itb=m_list.begin();
	 vector<Observateur*>::const_iterator ite=m_list.end();
 
	for(;itb!=ite;itb++)
	{
		 (*itb)->Update(this);
	}
}
 
void Barometre::Change(int valeur)
{
	pression=valeur;
	Notify();
}
 
int Barometre::Statut(void) const
{
	return pression;
}
 
 
void Thermometre::Change(int valeur)
{
    temperature=valeur;
	Notify();
}
 
Info Thermometre::Statut(void) const
{
	return temperature;
}
 
 
int main(void)
{
 
    Barometre barometre;
    Thermometre thermometre;
{
    MeteoFrance station;
 
    thermometre.AddObs(&station);
    barometre.AddObs(&station);
 
    thermometre.Change(31);
    barometre.Change(975);
}	
 
    thermometre.Change(45);
 
    return 0;
 
 
}

[koala01]

Salut,

Il ne faut pas confondre le modèle observateur et le modèle médiateur.

Pour le modèle observateur, il y peut y avoir un seul élément observé par plusieurs observateurs, et l'élément observé doit subsister si un observateur est détruit (car il y en a peut être d'autres qui continuent à observer )

Pour le modèle médiateur, il y a un seul élément "médiateur" qui discute avec plusieurs éléments "observés", et les éléments "observés" sont tous détruits lorsque le médiateur l'est (mais la destruction d'un élément observé ne provoque pas la destruction du médiateur pour autant)

Il n'y a donc, a priori, aucune raison que l'observateur ne s'occupe de détruire l'objet observé, alors qu'il y en a une à ce que le médiateur s'occupe de détruire les objets qui ne dépendent

[CedricMocquillon]

Bonjour et merci de vos réponses,

@Davidbrcz, je ne suis pas d'accord avec ton code, ce n'est pas à la classe Observateur de définir la méthode Update, ça dépend de la classe Observateur. Il faudrait donc mettre la méthode Update en virtuelle dans la classe Observateur. De plus, ce qui est assez étrange, c'est que ton code fonctionne puisque tu détruit l'observateur (station) et que malgré tout, la notification du changement de thermometre produit une réaction ce qui est contraire de ce que l'on attend (du fait qu'il n'y a plus personne pour l'observer, la notification ne devrait pas produire d'effet). Dernier commentaire, je pense que dans la méthode AddObs de la classe Observable, il faut ajouter la dépendance entre l'observeur et l'observable (avec un truc du genre obs->AddObs(this)).

@koala01, en fait, le but n'est pas de détruire les objets, il faut juste retirer les dépendances entre objets: si un observer est détruit, il faut que les observables qu'il observait ne puissent plus le notifier (sinon il y aura une erreur, ce qui n'est pas géré dans l'exemple http://come-david.developpez.com/tut...servateur#LVII)

[Davidbrcz]

Bonjour et merci de vos réponses,

je ne suis pas d'accord avec ton code, ce n'est pas à la classe Observateur de définir la méthode Update, ça dépend de la classe Observateur.

Ici, je fournis une version par défaut de la fonction.C'est un choix que j'assume.

Il faudrait donc mettre la méthode Update en virtuelle dans la classe Observateur.

Elle peut comme elle peut ne pas. Si le besoin s'en fait sentir on peut la rendre virtuelle. Mais là, comme elle fait la même chose pour tous les objets obersvés, aucun besoin de virtualité.

De plus, ce qui est assez étrange, c'est que ton code fonctionne puisque tu détruit l'observateur (station) et que malgré tout, la notification du changement de thermometre produit une réaction ce qui est contraire de ce que l'on attend (du fait qu'il n'y a plus personne pour l'observer, la notification ne devrait pas produire d'effet).

J'avoue, je n'ai pas testé ce code, j'ai juste vérifier qu'il compilait.
S'il marche, c'est car remove n'enlève pas les pointeurs du conteneurs.
Une chose que j'avais mal compris à l'époque

Dernier commentaire, je pense que dans la méthode AddObs de la classe Observable, il faut ajouter la dépendance entre l'observeur et l'observable (avec un truc du genre obs->AddObs(this)).

Un oubli que tu as très bien remarqué.

Je m'en vait changer mon code de ce pas pour tenir compte de tes remarques.

Edit: code mit à jour.

[meftahie]

Bonjour,
est-ce qu'il y a un moyen pour limiter une cascade d' update quand on utilise le pattern Observer ?

[koala01]

(pas mal, le déterrage de discussion )

Que veux tu dire par là en toute logique, le but même du pattern observateur est de s'assurer que tous les objets observés et observant soient tenus au courent de l'évolution de ce qui les observent ou de ce qu'ils observent