FAQ C++Consultez toutes les FAQ

Le mot-cl� virtual permet de supplanter une fonction membre d'une classe parent depuis une classe d�riv�e, � condition qu'elle ait la m�me signature (� l'exception du retour covariant).

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
class A 
{ 
public: 
    void F1() { cout << "A::F1()\n"; }     
    virtual void F2() { cout << "A::F2()\n"; } 
}; 
  
class B : public A 
{ 
public: 
    void F1() { cout << "B::F1()\n"; }     
    void F2() { cout << "B::F2()\n"; } 
}; 
  
int main() 
{ 
    A a; 
    a.F1(); // affiche "A::F1()" 
    a.F2(); // affiche "A::F2()" 
  
    B b; 
    b.F1(); // affiche "B::F1()" 
    b.F2(); // affiche "B::F2()" 
  
    // copie non polymorphe 
    a = b; 
    a.F1(); // affiche "A::F1()" 
    a.F2(); // affiche "A::F2()" 
  
    // utilisation polymorphe de B (par pointeur) 
    A * pa = &b; 
    pa->F1(); // affiche "A::F1()" 
    pa->F2(); // affiche "B::F2()" <-- gr�ce � virtual 
  
    // utilisation polymorphe de B (par r�f�rence) 
    A & ra = b; 
    ra.F1(); // affiche "A::F1()" 
    ra.F2(); // affiche "B::F2()" <-- gr�ce � virtual 
}

	Attention : en l'absence de l'introduction du mot virtual, nous aurions affaire � un masquage de nom, et non � une red�finition. Il y aurait alors absence totale de comportement polymorphique.

L'appel dynamique permet d'augmenter la r�utilisabilit� en autorisant le ��vieux�� code � appeler du nouveau code.

Avant l'apparition de l'orientation objet, la r�utilisation du code se faisait en appelant du vieux code � partir du nouveau code. Par exemple, un programmeur peut �crire du code appelant du code r�utilisable comme printf().

Avec l'orientation objet, la r�utilisation peut aussi �tre accomplie via l'appel de nouveau code par de l'ancien. Par exemple, un programmeur peut �crire du code qui est appel� par un framework qui a �t� �crit par son arri�re grand-p�re. Il n'y a pas besoin de modifier le code �crit par l'arri�re grand-p�re. En fait, il n'a m�me pas besoin d'�tre recompil�. Et si jamais il ne restait que le fichier objet, et que le code �crit par l'arri�re grand-p�re ait �t� perdu depuis 25 ans, cet ancien fichier objet appellera le code avec les nouvelles fonctionnalit�s sans rien changer d'autre.

C'est cela l'extensibilit�, et c'est cela l'orientation objet.

OUI

Sans les fonctions virtuelles, le C++ ne serait pas un langage orient� objet. La surcharge d'op�rateur et les fonctions membres non virtuelles sont tr�s pratiques, mais ne sont, finalement qu'une variante syntaxique de la notion beaucoup plus classique de passage de pointeur sur une structure � une fonction. La biblioth�que standard contient de nombreux templates illustrant les techniques de � programmation g�n�rique �, qui sont aussi tr�s pratiques, mais les fonctions virtuelles sont le cour m�me de la programmation orient�e objet.

D'un point de vue 'business', il y a tr�s peu de raison de passer du C pur au C++ sans les fonctions virtuelles (pour le moment, nous ferons abstraction de la programmation g�n�rique et de la biblioth�que standard). Les sp�cialistes pensent souvent qu'il a une grande diff�rence entre le C et le C++ non orient� objet ; mais sans l'orientation objet, la diff�rence n'est pas suffisante pour justifier le co�t de formation des d�veloppeurs, des nouveaux outils.
En d'autres termes, si je devais conseiller un gestionnaire concernant le passage du C au C++ sans orientation objet (c'est-�-dire changer le langage sans changer de paradigme), je le d�couragerais probablement, � moins qu'il y ait des contraintes li�es aux outils utilis�s. D'un point de vue gestion, la programmation orient�e objet permet de concevoir des syst�mes extensibles et adaptables, mais la syntaxe seule sans l'orientation objet ne r�duira jamais le co�t de maintenance, mais augmentera probablement les co�ts de formation de fa�on significative.

Nota : le C++ sans virtualit� n'est pas orient� objet. Programmer avec des classes mais sans liaison dynamique est une programmation bas�e sur des objets, mais n'est pas de la programmation objet. Ignorer la virtualit� est �quivalent � ignorer l'orientation objet. Tout ce qui reste est une programmation bas�e sur des objets, tout comme la version originale d'ADA. (Soit dit en passant, le nouvel ADA supporte la v�ritable orientation objet, et non plus simplement la programmation bas�e sur les objets).

Syntaxiquement, une fonction virtuelle pure est une fonction virtuelle suivie de � = 0 � dans sa d�claration :

1
2
3
4
5
class Test 
{ 
public: 
    virtual void F() = 0;  // = 0 signifie "virtuelle pure" 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class A 
{ 
public: 
    virtual void f() = 0; // virtuelle pure 
}; 
  
void A::f() 
{ 
    // impl�mentation par d�faut 
} 
  
// B se contente de l'impl�mentation par d�faut de f() 
class B : public A 
{ 
public: 
    void f() 
    { 
        A::f(); 
    } 
};

Lors de la r�impl�mentation d'une fonction membre virtuelle dans une classe d�riv�e, il est possible de ne pas tout � fait respecter le prototype de la fonction virtuelle en renvoyant un type d�riv� du type originel :

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
class A {}; 
class B : public A {}; 
  
class Base 
{ 
public: 
    virtual A* Test() 
    { 
        cout << "Base::Test\n"; 
        return new A; 
    } 
}; 
  
class Derived : public Base 
{ 
public: 
    virtual B* Test() // le type de retour est diff�rent de Base::Test 
    { 
        cout << "Derived::Test\n"; 
        return new B; 
    } 
}; 
  
int main() 
{    
    Base *b = new Derived; 
    A *a = b->Test(); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Clonable 
{ 
public: 
    virtual Clonable* Clone() const = 0; 
}; 
  
class A : public Clonable 
{ 
public: 
    virtual Clonable* Clone() const 
    { 
        return new A( *this ); 
    } 
}; 
  
int main() 
{ 
    A *a1 = new A; 
    // faire une copie 
    A *a2 = static_cast<A*>( a1->Clone() ); // cast obligatoire ! 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Clonable 
{ 
public: 
    virtual Clonable* Clone() const = 0; 
}; 
  
class A : public Clonable 
{ 
public: 
    virtual A* Clone() const // retour covariant 
    { 
        return new A( *this ); 
    } 
}; 
  
int main() 
{ 
    A *a1 = new A; 
    // faire une copie 
    A *a2 = a1->Clone(); // plus de cast 
}

Oui, c'est possible, mais attention, �a ne fait pas toujours ce qu'on pense. La premi�re approche consiste � comprendre que lors de l'appel du constructeur d'une classe de base, la classe d�riv�e n'a pas encore �t� construite. Donc, c'est la m�thode sp�cialis�e � ce niveau qui est appel�e.
Voyons en d�tail :
La r�gle est que le type dynamique d'une variable en cours de construction est celui du constructeur qui est en train d'�tre ex�cut�. Pour bien comprendre ce qui se passe, il faut donc revenir sur la diff�rence entre le type statique d'une variable, et son type dynamique.

Prenons par exemple trois classes, C qui d�rive de B qui d�rive de A. Par exemple, dans :

A* a = new B();

• On alloue assez de m�moire pour un objet de la taille de C.
• On initialise la sous partie correspondant � A de l'objet.
• On appelle le corps du constructeur de A. Pendant cet appel, l'objet cr�e a pour type dynamique A.
• On initialise la sous partie correspondant � B de l'objet.
• On appelle le corps du constructeur de B. Pendant cet appel, l'objet cr�e a pour type dynamique B.
• On initialise la sous partie correspondant � C de l'objet.
• On appelle le corps du constructeur de C. Pendant cet appel, l'objet cr�e a pour type dynamique C.