Interfaces en C++ (classes abstraites)

Une interface décrit le comportement ou les capacités d'une classe C++ sans s'engager sur une implémentation particulière de cette classe.

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

Une classe est rendue abstraite en déclarant au moins une de ses fonctions comme pure virtuelle fonction. Une fonction virtuelle pure est spécifiée en plaçant "=0" dans sa déclaration comme suit −

class Box {
   public:
      // pure virtual function
      virtual double getVolume() = 0;
      
   private:
      double length;      // Length of a box
      double breadth;     // Breadth of a box
      double height;      // Height of a box
};

Le but d'une classe abstraite (souvent appelé ABC) est de fournir une classe de base appropriée dont d'autres classes peuvent hériter. Les classes abstraites ne peuvent pas être utilisées pour instancier des objets et ne servent que d'interface . Tenter d'instancier un objet d'une classe abstraite provoque une erreur de compilation.

Ainsi, si une sous-classe d'un ABC doit être instanciée, elle doit implémenter chacune des fonctions virtuelles, ce qui signifie qu'elle supporte l'interface déclarée par l'ABC. Le fait de ne pas remplacer une fonction virtuelle pure dans une classe dérivée, puis de tenter d'instancier des objets de cette classe, est une erreur de compilation.

Les classes qui peuvent être utilisées pour instancier des objets sont appelées classes concrètes .

Exemple de classe abstraite

Considérez l'exemple suivant où la classe parent fournit une interface à la classe de base pour implémenter une fonction appelée getArea() −

Démo en direct

#include <iostream>
 
using namespace std;
 
// Base class
class Shape {
   public:
      // pure virtual function providing interface framework.
      virtual int getArea() = 0;
      void setWidth(int w) {
         width = w;
      }
   
      void setHeight(int h) {
         height = h;
      }
   
   protected:
      int width;
      int height;
};
 
// Derived classes
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);
   
   // Print the area of the object.
   cout << "Total Rectangle area: " << Rect.getArea() << endl;

   Tri.setWidth(5);
   Tri.setHeight(7);
   
   // Print the area of the object.
   cout << "Total Triangle area: " << Tri.getArea() << endl; 

   return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −

Total Rectangle area: 35
Total Triangle area: 17

Vous pouvez voir comment une classe abstraite a défini une interface en termes de getArea() et deux autres classes ont implémenté la même fonction mais avec un algorithme différent pour calculer la zone spécifique à la forme.

Concevoir une stratégie

Un système orienté objet peut utiliser une classe de base abstraite pour fournir une interface commune et normalisée appropriée pour toutes les applications externes. Ensuite, grâce à l'héritage de cette classe de base abstraite, des classes dérivées sont formées qui fonctionnent de manière similaire.

Les capacités (c'est-à-dire les fonctions publiques) offertes par les applications externes sont fournies en tant que fonctions virtuelles pures dans la classe de base abstraite. Les implémentations de ces fonctions virtuelles pures sont fournies dans les classes dérivées qui correspondent aux types spécifiques de l'application.

Cette architecture permet également d'ajouter facilement de nouvelles applications à un système, même après la définition du système.