C++ Interfaces: Abstracte Klassen & Pure Virtual Functions Beheersen

Een interface beschrijft het gedrag of de mogelijkheden van een C++ klasse zonder zich te binden aan een specifieke implementatie van die klasse.

De C++ interfaces worden geïmplementeerd met behulp van abstracte klassen en deze abstracte klassen mogen niet verward worden met data abstractie, wat een concept is van het scheiden van implementatiedetails van geassocieerde data.

Een klasse wordt abstract gemaakt door ten minste één van zijn functies te declareren als pure virtual functie. Een pure virtual functie wordt gespecificeerd door "= 0" in de declaratie te plaatsen als volgt:

 class Box {
public:
  // pure virtual function
  virtual double getVolume() = 0;
private:
  double length; // Lengte van een box
  double breadth; // Breedte van een box
  double height; // Hoogte van een box
}; 

Het doel van een abstracte klasse (vaak aangeduid als ABC) is om een geschikte base klasse te bieden waarvandaan andere klassen kunnen overerven. Abstracte klassen kunnen niet gebruikt worden om objecten te instantiëren en dienen slechts als interface. Het pogen om een object van een abstracte klasse te instantiëren veroorzaakt een compilatiefout.

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

Klassen die gebruikt kunnen worden om objecten te instantiëren heten concrete klassen (concrete classes).

Abstracte Klasse Voorbeeld

Overweeg het volgende voorbeeld waar de parent klasse een interface biedt aan de base klasse om een functie genaamd getArea() te implementeren:

 #include <iostream>
using namespace std;
// Base klasse
class Shape {
public:
  // pure virtual function die interface framework biedt.
  virtual int getArea() = 0;
  void setWidth(int w) {
    width = w;
  }
  void setHeight(int h) {
    height = h;
  }
protected:
  int width;
  int height;
};
// Afgeleide klassen
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 de oppervlakte van het object.
  cout << "Total Rectangle area: " << Rect.getArea() << endl;
  Tri.setWidth(5);
  Tri.setHeight(7);
  // Print de oppervlakte van het object.
  cout << "Total Triangle area: " << Tri.getArea() << endl;
  return 0;
} 

Wanneer de bovenstaande code gecompileerd en uitgevoerd wordt, produceert het het volgende resultaat:

 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 dezelfde functie implementeerden maar met een ander algoritme om de oppervlakte specifiek voor de vorm te berekenen.

Ontwerpstrategie

Een object-georiënteerd systeem kan een abstracte base klasse gebruiken om een gemeenschappelijke en gestandaardiseerde interface te bieden die geschikt is voor alle externe applicaties. Dan, door overerving van die abstracte base klasse, worden afgeleide klassen gevormd die op een vergelijkbare manier opereren.

De mogelijkheden (d.w.z., de publieke functies) die door de externe applicaties aangeboden worden, worden geleverd als pure virtual functies in de abstracte base klasse. De implementaties van deze pure virtual functies worden geleverd in de afgeleide klassen die corresponderen met de specifieke typen van de applicatie.

Deze architectuur stelt ook nieuwe applicaties in toe om eenvoudig aan een systeem toegevoegd te worden, zelfs nadat het systeem gedefinieerd is.