Bonjour,
voilà, je vois partout le pattern state implémenté ainsi:
Seulement, dans certains cas cette façon de faire ne me convient pas, à cause du fait que quand on change d'état (fonction ChangeState dans mon exemple), il faut allouer un nouvel état et désallouer l'ancien. C'est un cas que j'ai rencontré récemment qui m'a fait penser à cela: une classe qui change souvent d'état, et dont les états possèdent des données => beaucoup d'allocation/désallocations qui, de plus, sont coûteuses.
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 class AbstractState { public: virtual void DoSomething() = 0; }; class ConcreteState1 : public AbstractState { public: void DoSomething() { /* implémentation */ } }; class ConcreteState2 : public AbstractState { public: void DoSomething() { /* implémentation */ } }; class MyObject { private: AbstractState * m_state; public: void ChangeState( AbstractState * newState ) { delete m_state; m_state = newState; } void DoSomething() { m_state->DoSomething(); } };
Du coup, j'ai modifié le pattern comme ceci:
Seulement, je n'ai vu cette implémentation nulle part. Et pourtant je lis beaucoup de code ces derniers temps. Je me demande donc s'il n'y aurait pas un problème que je n'ai pas vu et qui fait ce ma méthode est très mauvaise.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14 // les classes AbstractState et ConcreteStateN ne changent pas class MyObject { private: AbstractState * m_state; ConcreteState1 m_state1; ConcreteState2 m_state2; public: void GoToState1() { m_state = &m_state1; } void GoToState2() { m_state = &m_state2; } void DoSomething() { m_state->DoSomething(); } };
Voilà, donc c'est pour savoir: qu'en pensez-vous?
Partager