Classes abstraites

De Appmethod Topics
Aller à : navigation, rechercher

Remonter à Classes polymorphes - Index

Une classe abstraite est une classe ayant au moins une fonction virtual pure. Une fonction virtual est spécifiée comme étant pure en lui attribuant la valeur zéro.

Une classe abstraite n'est utilisable que comme classe de base pour d'autres classes. Aucun objet de classe abstraite ne peut être créé. Une classe abstraite ne s'utilise pas comme type d'argument ni comme type de renvoi de fonction. Cependant, vous pouvez déclarer des pointeurs sur une classe abstraite. Des références à une classe abstraite sont également permises, à condition qu'un objet temporaire ne soit pas requis lors de l'initialisation. Par exemple,

class shape {       // abstract class
   point center;
.
.
.
public:
   where() { return center; }
   move(point p) { center = p; draw(); }
   virtual void rotate(int) = 0; // pure virtual function
   virtual void draw() = 0;      // pure virtual function
   virtual void hilite() = 0;    // pure virtual function
.
.
.
}
shape x;// ERROR: attempt to create an object of an abstract class
   shape* sptr;// pointer to abstract class is OK
   shape f();// ERROR: abstract class cannot be a return type
int g(shape s);// ERROR: abstract class cannot be a function argument type
shape& h(shape&);// reference to abstract class as return
 // value or function argument is OK

Supposons que D soit une classe dérivée avec la classe abstraite B comme classe de base immédiate. Pour chaque fonction virtuelle pure pvf dans B, D doit soit contenir une définition pour pvf, soit déclarer pvf comme étant pure.

Par exemple, l'utilisation de la classe shape déjà citée :

class circle : public shape {// circle derived from abstract class
   int radius;// private
public:
   void rotate(int) { }// virtual function defined: no action
            //  to rotate a circle
   void draw();      // circle::draw must be defined somewhere
}

Les fonctions membres peuvent être appelées depuis un constructeur de classe abstraite, mais l'appel d'une fonction virtuelle pure, directement ou indirectement, depuis ce constructeur entraîne une erreur au moment de l'exécution.


Voir aussi