Bonjour,

Je me pose des questions sur la qualité d'un code où une classe de base utilise un pointeur vers une fonction membre, pointant vers une méthode d'une classe dérivée.

Je vous décris un peu le programme. J'ai un ensemble d'objets dérivant d'une classe de base. Le programme doit faire évoluer ces objets en appelant une méthode progress() sur chacun d'eux. La façon d'évoluer de chaque objet n'est pas constante. Par exemple un objet peux commencer par se déplacer, puis change de comportement au bout d'une minute pour changer de taille.

Les différentes évolutions d'objet sont inconnues de la classe de base. Une solution serait de déclarer la méthode progress() comme virtuelle, et chaque classe fille ferait un switch pour appeler la bonne méthode d'évolution.

Un autre méthode serait d'utiliser un pointeur sur une fonction membre. J'ai écrit le code suivant pour tester, j'aimerais savoir ce que vous en pensez.

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
//------------------------------------------------------------------------------
class base
{
public:
  typedef void (base::*progress_method_type)();
 
  base();
  void progress();
 
protected:
  void hook(progress_method_type f) { m_progress_method = f; }
 
private:
  void idle() {}
 
private:
  progress_method_type m_progress_method;
 
}; // class base
 
base::base()
  : m_progress_method(&base::idle)
{
 
}
 
void base::progress()
{
  // on appelle la méthode définie par la classe de base
  (this->*m_progress_method)();
}
 
//------------------------------------------------------------------------------
class derived
  : public base
{
public:
  derived();
 
private:
  void first_part();
  void second_part();
 
private:
  int m_count;
 
}; // class derived
 
derived::derived()
  : m_count(0)
{
  // on met le progress sur une méthode de la classe dérivée
  hook((progress_method_type)&derived::first_part);
}
 
void derived::first_part()
{
  ++m_count;
 
 if (m_count == 24)
    hook((progress_method_type)&derived::second_part);
}
 
void derived::second_part()
{
  --m_count;
 
 if (m_count == 0)
    hook((progress_method_type)&derived::first_part);
}
 
//------------------------------------------------------------------------------
int main()
{
  derived d;
 
  while (true)
    d.progress();
 
  return 0;
}
Compilé avec g++ 4.2.3, ce code fonctionne très bien. Cependant, je ne sait pas si c'est exceptionnel ou parfaitement défini par la norme. Quand une méthode de "derived" est appelée par "base", est-ce que le pointeur "this" pointera toujours vers la bonne instance de "derived" ?