Fonction virtuelle

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

En programmation orientée objet, une fonction virtuelle est une fonction définie dans une classe (méthode) qui est destinée à être redéfinie dans les classes qui en héritent. Dans la plupart des langages, on utilise le mot clé virtual pour indiquer que la méthode d'une classe est virtuelle (C++, delphi, free pascal, ...).

Une fonction ne possédant qu'une déclaration, sans code implémenté est dite abstraite ou virtuelle pure. En C++, on utilise une syntaxe spéciale [ = 0 ]. Les méthodes virtuelles pures sont destinées à être définies dans les classes dérivées.

Delphi

type
 
{ ----------------------------------- }
{  Classe TForme. }
{ ----------------------------------- }
TForme = class 
public
    function aire():integer; virtual;
end;
 
{ ----------------------------------- }
{ Classe TTriangle dérivée de TForme. }
{ ----------------------------------- }
TTriangle = class(TForme)
  public
    function aire():integer; virtual;
end;
 
{ ----------------------------------- }
{ Classe TCercle dérivée de TForme.   }
{ ----------------------------------- }
TCercle = class(TForme)
  public
    function aire():integer; virtual;
end;

C++

//---------------------------------------------------------------------------
// Classe Forme.
//---------------------------------------------------------------------------
class Forme
{
  public:
    // Méthode est virtuelle pure.
    virtual unsigned int aire() = 0; 
};
 
//---------------------------------------------------------------------------
// Classe Triangle dérivée de Forme.
//---------------------------------------------------------------------------
class Triangle : public Forme 
{
  public:
    virtual unsigned int aire();
};
 
//---------------------------------------------------------------------------
// Classe Cercle dérivée de Forme.
//---------------------------------------------------------------------------
class Cercle : public Forme 
{
  public:
    virtual unsigned int aire();
};

La méthode aire() est redéfinie par chaque classe dérivée. En effet, la manière de calculer l'aire d'une forme dépend du type de celle-ci.

Il suffit qu'une classe possède une méthode virtuelle pure pour qu'elle soit dite abstraite.

On ne peut pas instancier une classe abstraite car cela n'aurait aucun sens. Par exemple : on peut instancier un objet « triangle » qui hérite de la classe de base abstraite « forme géométrique » mais on ne peut pas créer un objet « forme géométrique », trop général.

Voir aussi[modifier | modifier le code]