C++ Interface (classe abstraite)

Une interface décrit le comportement et les fonctionnalités d'une classe, sans exiger l'implémentation spécifique de la classe.

Les interfaces C++ sont implémentées à l'aide declasse abstraiteclasses abstraites. Les classes abstraites et l'abstraction de données ne doivent pas être confondues ; l'abstraction de données est un concept qui sépare les détails d'implémentation des données associées.

Si au moins une fonction dans une classe est déclarée comme une fonction virtuelle pure, alors la classe est une classe abstraite. Une fonction virtuelle pure est spécifiée en utilisant "= 0" dans sa déclaration, comme indiqué ci-dessous :

class Box { public: // Fonction virtuelle pure virtual double getVolume() = 0; private: double length; // Longueur double breadth; // Largeur double height; // Height };

ConceptionClasse abstraiteLe but d'une classe abstraite (souvent appelée ABC) est de fournir une classe de base appropriée à partir de laquelle d'autres classes peuvent hériter. Les classes abstraites ne peuvent pas être utilisées pour instancier des objets ; elles ne peuvent être utilisées que commeinterfaceinterfaces. Tenter d'instancier un objet d'une classe abstraite entraînera une erreur de compilation.

Par conséquent, si une sous-classe d'une ABC doit être instanciée, elle doit implémenter chaque fonction virtuelle pure. Cela signifie également que C++ prend en charge l'utilisation des ABC pour déclarer des interfaces. Si vous tentez d'instancier un objet d'une telle classe sans redéfinir les fonctions virtuelles pures dans la classe dérivée, une erreur de compilation se produira.

Une classe qui peut être utilisée pour instancier des objets est appeléeClasse concrète。

Une instance d'une classe abstraite

Voir l'exemple ci-dessous. La classe de base Shape fournit une interfacegetArea(), implémentée respectivement dans les deux classes dérivées Rectangle et TrianglegetArea()：

Exemple

#include <iostream> using namespace std; // Classe de base class Shape { public: // Fonctions virtuelles pures fournissant le cadre de l'interface virtual int getArea() = 0; void setWidth(int w) { width = w; } void setHeight(int h) { height = h; } protected: int width; int height; }; // Classe dérivée class Rectangle: public Shape { public: int getArea() { return (width * height); } }; class Triangle: public Shape { public: int getArea() { return (width * height)/2; } }; int main(void) { Rectangle Rect; Triangle Tri; Rect.setWidth(5); Rect.setHeight(7); // Affiche l'aire de l'objet cout << "Aire totale du rectangle : " << Rect.getArea() << endl; Tri.setWidth(5); Tri.setHeight(7); // Afficher l'aire de l'objet cout << "Aire totale du triangle : " << Tri.getArea() << endl; return 0; }

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Total Rectangle area: 35
Total Triangle area: 17

À partir de l'exemple ci-dessus, nous pouvons voir comment une classe abstraite définit une interface getArea(), et comment deux classes dérivées implémentent cette même fonction au moyen d'algorithmes de calcul d'aire différents.

Stratégie de conception

Un système orienté objet peut utiliser une classe de base abstraite pour fournir une interface appropriée, commune et standardisée à toutes les applications externes. Ensuite, en héritant de la classe de base abstraite, les classes dérivées héritent de toutes les opérations similaires.

Les fonctions fournies par les applications externes (c'est-à-dire les fonctions publiques) existent sous forme de fonctions virtuelles pures dans la classe de base abstraite. Ces fonctions virtuelles pures sont implémentées dans les classes dérivées correspondantes.

Cette architecture facilite également l'ajout de nouvelles applications au système, même après que le système a été défini.

autres extensions