Fonction virtuelle

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
image illustrant l’informatique
Cet article est une ébauche concernant l’informatique.

Vous pouvez partager vos connaissances en l’améliorant (comment ?) selon les recommandations des projets correspondants.

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]