Schnittstellen in C++ (Abstrakte Klassen)

Eine Schnittstelle beschreibt das Verhalten oder die Fähigkeiten einer C++-Klasse, ohne sich auf eine bestimmte Implementierung dieser Klasse festzulegen.

Die C++-Schnittstellen werden mithilfe von abstrakten Klassen implementiert und diese abstrakten Klassen sollten nicht mit der Datenabstraktion verwechselt werden, bei der es sich um ein Konzept handelt, bei dem Implementierungsdetails von zugehörigen Daten getrennt gehalten werden.

Eine Klasse wird abstrakt gemacht, indem mindestens eine ihrer Funktionen als rein virtuell deklariert wird Funktion. Eine rein virtuelle Funktion wird durch Platzieren von "=0" in ihrer Deklaration wie folgt spezifiziert:−

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
};

Der Zweck einer abstrakten Klasse (oft als ABC bezeichnet) besteht darin, eine geeignete Basisklasse bereitzustellen, von der andere Klassen erben können. Abstrakte Klassen können nicht zum Instanziieren von Objekten verwendet werden und dienen nur als Schnittstelle . Der Versuch, ein Objekt einer abstrakten Klasse zu instanziieren, verursacht einen Kompilierungsfehler.

Wenn also eine Unterklasse eines ABC instanziiert werden muss, muss sie jede der virtuellen Funktionen implementieren, was bedeutet, dass sie die von ABC deklarierte Schnittstelle unterstützt. Das Versäumnis, eine rein virtuelle Funktion in einer abgeleiteten Klasse zu überschreiben und dann zu versuchen, Objekte dieser Klasse zu instanziieren, ist ein Kompilierungsfehler.

Klassen, die zum Instanziieren von Objekten verwendet werden können, werden konkrete Klassen genannt .

Beispiel einer abstrakten Klasse

Betrachten Sie das folgende Beispiel, in dem die übergeordnete Klasse eine Schnittstelle zur Basisklasse bereitstellt, um eine Funktion namens getArea() zu implementieren −

#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;
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Total Rectangle area: 35
Total Triangle area: 17

Sie können sehen, wie eine abstrakte Klasse eine Schnittstelle in Bezug auf getArea() definiert hat und zwei andere Klassen dieselbe Funktion implementiert haben, aber mit einem anderen Algorithmus, um die für die Form spezifische Fläche zu berechnen.

Strategie entwerfen

Ein objektorientiertes System könnte eine abstrakte Basisklasse verwenden, um eine gemeinsame und standardisierte Schnittstelle bereitzustellen, die für alle externen Anwendungen geeignet ist. Dann werden durch Vererbung von dieser abstrakten Basisklasse abgeleitete Klassen gebildet, die ähnlich funktionieren.

Die von den externen Anwendungen angebotenen Fähigkeiten (d. h. die öffentlichen Funktionen) werden als rein virtuelle Funktionen in der abstrakten Basisklasse bereitgestellt. Die Implementierungen dieser rein virtuellen Funktionen werden in den abgeleiteten Klassen bereitgestellt, die den spezifischen Typen der Anwendung entsprechen.

Diese Architektur ermöglicht auch das einfache Hinzufügen neuer Anwendungen zu einem System, selbst nachdem das System definiert wurde.