Interface C++ (classe abstraite)

Les interfaces décrivent le comportement et les fonctionnalités d'une classe sans nécessiter une implémentation spécifique de la classe.

L'interface C++ est implémentée à l'aide d'une classe abstraite. La classe abstraite et l'abstraction des données ne sont pas confondues. L'abstraction des données est un concept qui sépare les détails d'implémentation des données associées.

Si au moins une fonction d'une classe est déclarée comme fonction virtuelle pure, la classe est abstraite. Les fonctions virtuelles pures sont spécifiées en utilisant "= 0" dans la déclaration, comme indiqué ci-dessous :

class Box
{
   public:
      // 纯虚函数
      virtual double getVolume() = 0;
   private:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
};

Le but de la conception d'une Classe abstraite (souvent appelée ABC) est de fournir à d'autres classes un classe de base appropriée dont hériter. Une classe abstraite ne peut pas être utilisée pour instancier des objets, elle ne peut être utilisée que comme une interface. Si vous essayez d'instancier un objet d'une classe abstraite, cela provoquera une erreur de compilation.

Par conséquent, si une sous-classe d'ABC doit être instanciée, chaque fonction virtuelle doit être implémentée, ce qui signifie également que C++ prend en charge l'utilisation d'ABC pour déclarer des interfaces. Si une fonction virtuelle pure n'est pas surchargée dans une classe dérivée, tenter d'instancier un objet de cette classe entraînera une erreur de compilation.

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

Exemple de classe abstraite

Veuillez consulter l'exemple ci-dessous. La classe de base Shape fournit une interface getArea(), qui est implémentée dans les deux classes dérivées Rectangle et Triangle. respectivement. getArea() :

#include <iostream>
 
using namespace std;
 
// 基类
class Shape 
{
public:
   // 提供接口框架的纯虚函数
   virtual int getArea() = 0;
   void setWidth(int w)
   {
      width = w;
   }
   void setHeight(int h)
   {
      height = h;
   }
protected:
   int width;
   int height;
};
 
// 派生类
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);
   // 输出对象的面积
   cout << "Total Rectangle area: " << Rect.getArea() << endl;

   Tri.setWidth(5);
   Tri.setHeight(7);
   // 输出对象的面积
   cout << "Total Triangle area: " << Tri.getArea() << endl; 

   return 0;
}

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

Total Rectangle area: 35
Total Triangle area: 17

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

Stratégie de conception

Les systèmes orientés objet peuvent utiliser une classe de base abstraite pour fournir une interface appropriée, commune et standardisée à toutes les applications externes. Ensuite, la classe dérivée hérite de toutes les opérations similaires en héritant de la classe de base abstraite.

Les fonctions fournies par les applications externes (c'est-à-dire les fonctions publiques) existent sous la 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 permet également d'ajouter facilement de nouvelles applications au système, même après que le système ait été défini.