Parfois, l’implémentation de toutes les fonctions ne peut pas être fournie dans une classe de base car nous ne connaissons pas l’implémentation. Une telle classe est appelée une classe abstraite .Par exemple, laissez Shape être une classe de base. Nous ne pouvons pas fournir l'implémentation de la fonction draw() dans Shape, mais nous savons que chaque classe dérivée doit avoir une implémentation de draw(). De même, une classe Animal n’a pas l’implémentation de move() (en supposant que tous les animaux bougent), mais tous les animaux doivent savoir comment se déplacer. Nous ne pouvons pas créer d'objets de classes abstraites.
UN fonction virtuelle pure (ou fonction abstraite) en C++ est une fonction virtuelle pour laquelle nous pouvons avoir une implémentation, mais nous devons remplacer cette fonction dans la classe dérivée, sinon la classe dérivée deviendra également une classe abstraite. Une fonction virtuelle pure est déclarée en attribuant 0 dans la déclaration.
Exemple de fonctions virtuelles pures
C++
// An abstract class> class> Test {> >// Data members of class> public>:> >// Pure Virtual Function> >virtual> void> show() = 0;> >/* Other members */> };> |
>
>
Exemple complet
Une fonction virtuelle pure est implémentée par des classes dérivées d'une classe abstraite.
C++
tableau trié en java
// C++ Program to illustrate the abstract class and virtual> // functions> #include> using> namespace> std;> class> Base {> >// private member variable> >int> x;> public>:> >// pure virtual function> >virtual> void> fun() = 0;> >// getter function to access x> >int> getX() {>return> x; }> };> // This class inherits from Base and implements fun()> class> Derived :>public> Base {> >// private member variable> >int> y;> public>:> >// implementation of the pure virtual function> >void> fun() { cout <<>'fun() called'>; }> };> int> main(>void>)> {> >// creating an object of Derived class> >Derived d;> >// calling the fun() function of Derived class> >d.fun();> >return> 0;> }> |
>
>Sortir
fun() called>
Quelques faits intéressants
1. Une classe est abstraite si elle possède au moins une fonction virtuelle pure.
Exemple
Dans le code C++ ci-dessous, Test est une classe abstraite car elle possède une fonction virtuelle pure show().
C++
// C++ program to illustrate the abstract class with pure> // virtual functions> #include> using> namespace> std;> class> Test {> >// private member variable> >int> x;> public>:> >// pure virtual function> >virtual> void> show() = 0;> >// getter function to access x> >int> getX() {>return> x; }> };> int> main(>void>)> {> >// Error: Cannot instantiate an abstract class> >Test t;> >return> 0;> }> |
>
>
Sortir
Compiler Error: cannot declare variable 't' to be of abstract type 'Test' because the following virtual functions are pure within 'Test': note: virtual void Test::show()>
2. Nous pouvons avoir des pointeurs et des références de type classe abstraite.
Par exemple, le programme suivant fonctionne correctement.
Shreya Ghoshal, premier mari
C++
// C++ program that demonstrate that> // we can have pointers and references> // of abstract class type.> #include> using> namespace> std;> class> Base {> public>:> >// pure virtual function> >virtual> void> show() = 0;> };> class> Derived :>public> Base {> public>:> >// implementation of the pure virtual function> >void> show() { cout <<>'In Derived
'>; }> };> int> main(>void>)> {> >// creating a pointer of type> >// Base pointing to an object> >// of type Derived> >Base* bp =>new> Derived();> >// calling the show() function using the> >// pointer> >bp->show();> >return> 0;> }> |
>
>Sortir
javascript si instruction
In Derived>
3. Si nous ne remplaçons pas la fonction virtuelle pure dans la classe dérivée, alors la classe dérivée devient également une classe abstraite.
L’exemple suivant démontre la même chose.
C++
// C++ program to demonstrate that if we do not override> // the pure virtual function in the derived class, then> // the derived class also becomes an abstract class> #include> using> namespace> std;> class> Base {> public>:> >// pure virtual function> >virtual> void> show() = 0;> };> class> Derived :>public> Base {> };> int> main(>void>)> {> >// creating an object of Derived class> >Derived d;> >return> 0;> }> |
>
>
Sortir
Compiler Error: cannot declare variable 'd' to be of abstract type 'Derived' because the following virtual functions are pure within 'Derived': virtual void Base::show()>
4. Une classe abstraite peut avoir des constructeurs.
Par exemple, le programme suivant se compile et s'exécute correctement.
C++
// C++ program to demonstrate that> // an abstract class can have constructors.> #include> using> namespace> std;> // An abstract class with constructor> class> Base {> protected>:> >// protected member variable> >int> x;> public>:> >// pure virtual function> >virtual> void> fun() = 0;> >// constructor of Base class> >Base(>int> i)> >{> >x = i;> >cout <<>'Constructor of base called
'>;> >}> };> class> Derived :>public> Base {> >// private member variable> >int> y;> public>:> >// calling the constructor of Base class> >Derived(>int> i,>int> j)> >: Base(i)> >{> >y = j;> >}> >// implementation of pure virtual function> >void> fun()> >{> >cout <<>'x = '> << x <<>', y = '> << y <<>'
'>;> >}> };> int> main(>void>)> {> >// creating an object of Derived class> >Derived d(4, 5);> >// calling the fun() function of Derived class> >d.fun();> >// creating an object of Derived class using> >// a pointer of the Base class> >Base* ptr =>new> Derived(6, 7);> >// calling the fun() function using the> >// pointer> >ptr->amusant();> >return> 0;> }> |
>
recherche contradictoire
>Sortir
Constructor of base called x = 4, y = 5 Constructor of base called x = 6, y = 7>
5. Une classe abstraite en C++ peut également être définie à l'aide du mot-clé struct.
Exemple
struct shapeClass { virtual void Draw()=0; }> Comparaison avec Java
En Java, une classe peut être rendue abstraite en utilisant un mot-clé abstrait. De même, une fonction peut être rendue purement virtuelle ou abstraite en utilisant un mot-clé abstrait. Voir Classes abstraites en Java pour plus de détails.
Interface vs classes abstraites
Une interface n’a d’implémentation d’aucune de ses méthodes, elle peut être considérée comme un ensemble de déclarations de méthodes. En C++, une interface peut être simulée en rendant toutes les méthodes purement virtuelles. En Java, il existe un mot-clé distinct pour l'interface.
Nous pouvons considérer Interface comme des fichiers d'en-tête en C++, comme dans les fichiers d'en-tête, nous fournissons uniquement le corps de la classe qui va l'implémenter. De même, en Java, dans Interface, nous fournissons uniquement le corps de la classe et nous écrivons le code réel dans la classe qui l'implémente.