dynamic_cast() sur pointeur de pointeur
Bonjour,
On me fournit 2 interfaces qui correspondent au design pattern Factory. Ces interfaces, je vais les appeler B1 pour la fabrique et B2 pour le produit. Ces 2 interfaces étant évidemment virtuelles, je crées des classes qui dérivent de celles-ci, D1 pour la fabrique concrète et D2 pour le produit concret.
Voici un exemple simplifié de ce que ça donne:
Code:
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
| #include <iostream>
#include <list>
using namespace std;
class B2
{
public:
virtual ~B2() = 0 {}
virtual void Display() const { cout << "Je suis B2" << endl; }
};
class B1
{
public:
virtual ~B1() {}
void CreateB2(B2 ** lplpB2) const { *lplpB2 = NewObject(); }
virtual B2 * NewObject() const = 0 {}
virtual void Display() const { cout << "Je suis B1" << endl; }
};
class D2 :
public B2
{
public:
D2() : m_iVal(0) {}
~D2() {}
void SetValue(int iVal) { m_iVal = iVal; }
void Display() const { cout << "Je suis D2 avec la valeur " << m_iVal << endl; }
private:
int m_iVal;
};
class D1 :
public B1
{
public:
~D1() {}
void CreateD2(D2 ** lplpD2, int iVal = 0) { CreateB2(reinterpret_cast<B2 **>(lplpD2)); if (*lplpD2) (*lplpD2)->SetValue(iVal); }
B2 * NewObject() const { return new D2; }
void Display() const { cout << "Je suis D1" << endl; }
};
void test1()
{
cout << "test1:" << endl;
D1 d1;
D2 * lpD2;
d1.CreateD2(&lpD2, 3);
if (lpD2)
{
lpD2->SetValue(3);
lpD2->Display();
delete lpD2;
lpD2 = NULL;
}
else
{
cerr << "Impossible de creer un objet d2" << endl;
}
}
void test2()
{
cout << "test2:" << endl;
D1 d1;
D2 * lpD2;
lpD2 = dynamic_cast<D2 *>(d1.NewObject());
if (lpD2)
{
lpD2->SetValue(3);
lpD2->Display();
delete lpD2;
lpD2 = NULL;
}
else
{
cerr << "Impossible de creer un objet d2" << endl;
}
}
int main()
{
test1();
test2();
return EXIT_SUCCESS;
} |
B1 fabrique des B2 à partir de la fonction CreateB2(). La méthode virtuelle NewObject() permet de créer l'objet concret (défini dans les classes dérivées).
Dans la classe D2, je crée la fonction CreateD2(), je fais appel à la fonction CreateB2() afin de fabriquer mes produits. Je dois donc faire un downcast de D2 ** vers B2 **. J'aimerais utiliser un dynamic_cast() que je pense plus propre vu qu'il s'agit d'un conversion d'un objet polymorphique, mais seul un reinterpret_cast() fonctionne.
Dans l'exemple, j'ai mis la méthode NewObject() en public au lieu de protected pour tester un dynamic_cast() directement sur le pointeur dans test2(), et là pas de souvis.
Donc pourquoi je ne peux pas faire de dynamic_cast() quand je passe mon produit D2 par pointeur de pointeur dans la fonction CreateD2()?
Merci d'avance.
