Discussion :

[mister3957]

Bonjour à tous,

Voilà un problème courant lorsque l'on implémente le pattern Observer. L'observable détient une liste d'écouteurs, il la parcours pour notifier un événement et un écouteur en réception de cet événement n'a plus besoin d'écouter. Il se retire alors de la liste ce qui provoque l'invalidation de l'itérateur toujours en cours d'itération.

Un petit exemple pour être plus concret :

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
 
class IListener
{
friend class Observable;
protected:
   virtual void OnEvent() = 0;
}
 
class Observable
{
public:
   void AddListener(IListener* pListener) {
       m_vecListeners.push_back(pListener);
   }
   void RemoveListener(IListener* pListener) {
      m_vecListeners.erase(std::remove(m_vecListeners.begin(), m_vecListeners.end(), pListener), m_vecListeners.end());
   }
 
private:
   void NotifyEvent() {
     for(std::vector<IListener*>::iterator it = m_vecListeners.begin(); it != m_vecListeners.end(); ++it)
        (*it)->OnEvent();
   }
 
   std::vector<IListener*> m_vecListeners;
};
 
class Ecouteur : public IListener
{
public:
   Ecouteur() {
      m_observable.AddListener(this);
   }
 
protected:
   virtual void OnEvent() {
      m_observable.RemoveListener(this);      
   }
 
private:
   Observable m_observable;
};

Je ne sais pas si ce code compile, en tout cas il est pas propre mais c'est juste pour étayer le principe.

Du coup là quand l'observable émet un événement, ça crash. Il y a des solutions mais qui contraignent à ce que l'écouteur doive connaître la gestion des événements de l'écouté pour l'utiliser d'une manière particulière, et ça c'est pas normal.

Alors comment faire proprement ?

Merci

[Bousk]

J'ai corrigé plusieurs de ces bugs il y a peu, la solution est toujours la même et revient à faire une copie des callbacks à appeler
Eventuellement ne pas oublier les mutex si contexte multi-threaded

[Pyramidev]

On pourrait implémenter la classe Observable comme ceci :

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
class Observable
{
public:
    void AddListener(IListener& pListener) {
        assert(m_vecListeners.end() == std::find(m_vecListeners.begin(), m_vecListeners.end(), &pListener));
        for(IListener*& refPtr : m_vecListeners) {
            if(refPtr == nullptr) {
                refPtr = &pListener;
                return;
            }
        }
        m_vecListeners.push_back(&pListener);
    }
    void RemoveListener(const IListener& pListener) {
        for(IListener*& refPtr : m_vecListeners) {
            if(refPtr == &pListener) {
                refPtr = nullptr;
                return;
            }
        }
    }
 
private:
    void NotifyEvent() const {
        for(IListener* ptr : m_vecListeners) {
            if(ptr != nullptr) {
                ptr->OnEvent();
            }
        }
    }
 
   std::vector<IListener*> m_vecListeners;
};

Alors, pendant l'appel à Observable::NotifyEvent, l'observateur pourrait appeler Observable::RemoveListener.
Au passage, Observable::RemoveListener devient plus performant, même si c'est au détriment de Observable::AddListener.

Par contre, si, pendant l'appel à Observable::NotifyEvent, on veut pouvoir appeler Observable::AddListener, alors il faudra en amont que Observable::NotifyEvent fasse une copie du vecteur.

A part ça, ton code compile presque, à un caractère près :

Code :

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

1
2
3
4
5
6
class IListener
{
friend class Observable;
protected:
   virtual void OnEvent() = 0;
} // Il manque un point-virgule ici.

[camboui]

Comme disait je ne sais plus qui, ne pas avoir peur d'ajouter des niveaux d'indirection en cas de soucis

Voici une modification possible de la classe Observable.

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
class Observable
{
	struct entendu
	{
		IListener* m_listener;
		bool m_ok;
		entendu(IListener* l) : m_listener(l), m_ok(false) {}
	};
 
public:
	void AddListener(IListener* pListener) {
		m_vecListeners.push_back(entendu(pListener));
	}
	void RemoveListener(IListener* pListener) {
		std::vector<entendu>::iterator it =
			std::find_if(m_vecListeners.begin(), m_vecListeners.end(),
				[pListener](entendu const & e) { return e.m_listener == pListener; });
		if (it != m_vecListeners.end())
			it->m_ok = true;
	}
 
private:
	void NotifyEvent() {
		for (std::vector<entendu>::iterator it = m_vecListeners.begin(); it != m_vecListeners.end(); ++it)
			(*it).m_listener->OnEvent();
		m_vecListeners.erase(
			std::remove_if(m_vecListeners.begin(), m_vecListeners.end(),
				[](entendu const & e) { return e.m_ok == true; }),
			m_vecListeners.end());
	}
 
	std::vector<entendu> m_vecListeners;
};