Interfaces in C++ (abstracte klassen)

Een interface beschrijft het gedrag of de mogelijkheden van een C++-klasse zonder vast te leggen aan een bepaalde implementatie van die klasse.

De C++-interfaces zijn geïmplementeerd met behulp van abstracte klassen en deze abstracte klassen moeten niet worden verward met gegevensabstractie, wat een concept is om implementatiedetails gescheiden te houden van bijbehorende gegevens.

Een klasse wordt abstract gemaakt door ten minste één van zijn functies als puur virtueel . te declareren functie. Een pure virtuele functie wordt gespecificeerd door "=0" als volgt in zijn declaratie te plaatsen −

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

Het doel van een abstracte les (vaak een ABC genoemd) is om een ​​geschikte basisklasse te bieden waarvan andere klassen kunnen erven. Abstracte klassen kunnen niet worden gebruikt om objecten te instantiëren en dienen alleen als een interface . Een poging om een ​​object van een abstracte klasse te instantiëren veroorzaakt een compilatiefout.

Dus als een subklasse van een ABC moet worden geïnstantieerd, moet het elk van de virtuele functies implementeren, wat betekent dat het de interface ondersteunt die door het ABC is gedeclareerd. Het niet negeren van een pure virtuele functie in een afgeleide klasse en vervolgens proberen om objecten van die klasse te instantiëren, is een compilatiefout.

Klassen die kunnen worden gebruikt om objecten te instantiëren, worden concrete klassen genoemd .

Abstract klasvoorbeeld

Overweeg het volgende voorbeeld waarin de bovenliggende klasse een interface biedt voor de basisklasse om een ​​functie genaamd getArea() te implementeren

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Total Rectangle area: 35
Total Triangle area: 17

U kunt zien hoe een abstracte klasse een interface definieerde in termen van getArea() en twee andere klassen implementeerden dezelfde functie, maar met een ander algoritme om het gebied te berekenen dat specifiek is voor de vorm.

Strategie ontwerpen

Een objectgeoriënteerd systeem kan een abstracte basisklasse gebruiken om een ​​gemeenschappelijke en gestandaardiseerde interface te bieden die geschikt is voor alle externe toepassingen. Vervolgens worden door overerving van die abstracte basisklasse afgeleide klassen gevormd die op dezelfde manier werken.

De mogelijkheden (d.w.z. de openbare functies) die door de externe toepassingen worden aangeboden, worden geleverd als pure virtuele functies in de abstracte basisklasse. De implementaties van deze pure virtuele functies worden geleverd in de afgeleide klassen die overeenkomen met de specifieke typen van de applicatie.

Deze architectuur maakt het ook mogelijk om eenvoudig nieuwe applicaties aan een systeem toe te voegen, zelfs nadat het systeem is gedefinieerd.