Avant de lire ce sujet, veillez à lire et relire la FAQ :
Puis-je appeler des fonctions virtuelles dans le constructeur (ou le destructeur) ?
Puis la Doc Embarcadero (qui dit le contraire pour la VCL) :
Appels de méthodes virtuelles dans les constructeurs des classes de base

Il faudrait notifer dans la FAQ d'une telle différence de comportement, je suis développeur Delphi, je m'attendais au comportement des objets VCL alors que partout sur les sites C++, c'est évidemment le comportement C++ que les développeurs s'attendent !
J'ai donc ou des sérieux doutes sur certains de mes codes que je n'aurais pas du avoir !

Si l'on trouve rapidement cet article dans l'aide C++ Builder 6, c'est un défi de la trouver en BSD2007 !

Un petit code pour illustrer :
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
//---------------------------------------------------------------------------
#include <typeinfo>
//---------------------------------------------------------------------------
class CClassOne
{
  protected:
    // Methodes Protégées
    virtual void VirtualMethodInConstructor() {OutputDebugString(typeid(this).name()); OutputDebugString("One");}
 
  public:
    /*constructor*/ CClassOne() {VirtualMethodInConstructor();}
};
//---------------------------------------------------------------------------
class CClassTwo : public CClassOne
{
  protected:
    // Methodes Protégées
    virtual void VirtualMethodInConstructor() {CClassOne::VirtualMethodInConstructor(); OutputDebugString("Two");}
 
  public:
    /*constructor*/ CClassTwo() {}
};
//---------------------------------------------------------------------------
class CClassThree : public CClassTwo
{
  protected:
    // Methodes Protégées
    virtual void VirtualMethodInConstructor() {CClassTwo::VirtualMethodInConstructor(); OutputDebugString("Three");}
 
  public:
    /*constructor*/ CClassThree() {}
};
 
//---------------------------------------------------------------------------
class TClassOne : public TObject
{
  protected:
    // Methodes Protégées
    virtual void VirtualMethodInConstructor() {OutputDebugString(typeid(this).name()); OutputDebugString(String(this->ClassName()).c_str()); OutputDebugString("VCL One");}
 
  public:
    /*constructor*/ TClassOne() {VirtualMethodInConstructor();}
};
//---------------------------------------------------------------------------
class TClassTwo : public TClassOne
{
  protected:
    // Methodes Protégées
    virtual void VirtualMethodInConstructor() {TClassOne::VirtualMethodInConstructor(); OutputDebugString("VCL Two");}
 
  public:
    /*constructor*/ TClassTwo() {}
};
//---------------------------------------------------------------------------
class TClassThree : public TClassTwo
{
  protected:
    // Methodes Protégées
    virtual void VirtualMethodInConstructor() {TClassTwo::VirtualMethodInConstructor(); OutputDebugString("VCL Three");}
 
  public:
    /*constructor*/ TClassThree() {}
};
 
 
void __fastcall TLanguageBasicsForm::BtnConstructorAndVirtualMethodClick(
      TObject *Sender)
{
  OutputDebugString("! - new CClassOne : ");
  CClassOne *OneC = new CClassOne(); // Affiche CClassOne One
 
  OutputDebugString("! - new CClassTwo : ");
  CClassOne *TwoC = new CClassTwo(); // Affiche CClassOne One
 
  OutputDebugString("! - new CClassThree : ");
  CClassOne *ThreeC = new CClassThree(); // Affiche CClassOne One
 
  OutputDebugString("! - new CClassTwo : ");
  CClassTwo *TwoC2 = new CClassTwo(); // Affiche CClassOne One
 
  OutputDebugString("! - new CClassThree : ");
  CClassTwo *ThreeC2 = new CClassThree(); // Affiche CClassOne One
 
  OutputDebugString("! - new CClassThree : ");
  CClassThree *ThreeC3 = new CClassThree(); // Affiche CClassOne One
 
 
  delete OneC;
  delete TwoC;
  delete ThreeC;
  delete TwoC2;
  delete ThreeC2;
  delete ThreeC3;
 
  OutputDebugString("! - VCL new CClassOne : ");
  TClassOne *OneVCL = new TClassOne(); // Affiche TClassOne TClassOne VCL One
 
  OutputDebugString("! - VCL new TClassTwo : ");
  TClassOne *TwoVCL = new TClassTwo(); // Affiche TClassOne TClassTwo VCL One VCL Two
 
  OutputDebugString("! - VCL new TClassThree : ");
  TClassOne *ThreeVCL = new TClassThree(); // Affiche TClassOne TClassThree VCL One VCL Two VCL Three
 
  OutputDebugString("! - VCL new TClassTwo : ");
  TClassTwo *TwoVCL2 = new TClassTwo(); // Affiche TClassOne TClassTwo VCL One VCL Two
 
  OutputDebugString("! - VCL new TClassThree : ");
  TClassTwo *ThreeVCL2 = new TClassThree(); // Affiche TClassOne TClassThree VCL One VCL Two VCL Three
 
  OutputDebugString("! - VCL new TClassThree : ");
  TClassThree *ThreeVCL3 = new TClassThree(); // Affiche TClassOne TClassThree VCL One VCL Two VCL Three
 
  delete OneVCL;
  delete TwoVCL;
  delete ThreeVCL;
  delete TwoVCL2;
  delete ThreeVCL2;
  delete ThreeVCL3;
}
//---------------------------------------------------------------------------