Interfaces C++ : Maîtriser les classes abstraites et fonctions virtuelles pures

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 en utilisant des 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 fonction virtuelle pure. Une fonction virtuelle pure est spécifiée en plaçant « = 0 » dans sa déclaration comme suit :

class Box {
public:
    // fonction virtuelle pure
    virtual double getVolume() = 0;
private:
    double length; // Longueur d'une boîte
    double breadth; // Largeur d'une boîte
    double height; // Hauteur d'une boîte
};

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

Ainsi, si une sous-classe d'une ABC a besoin d'ê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. L'échec à surcharger une fonction virtuelle pure dans une classe dérivée, puis la tentative 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 parente fournit une interface à la classe de base pour implémenter une fonction appelée getArea() :

#include <iostream>
using namespace std;

// Classe de base
class Shape {
public:
    // fonction virtuelle pure fournissant le cadre d'interface.
    virtual int getArea() = 0;
    void setWidth(int w) { width = w; }
    void setHeight(int h) { height = h; }
protected:
    int width;
    int height;
};

// Classes dérivées
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);
    // Afficher l'aire de l'objet.
    cout << "Aire totale Rectangle : " << Rect.getArea() << endl;
    Tri.setWidth(5);
    Tri.setHeight(7);
    // Afficher l'aire de l'objet.
    cout << "Aire totale Triangle : " << Tri.getArea() << endl;
    return 0;
}

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

Aire totale Rectangle : 35
Aire totale Triangle : 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 l'aire spécifique à la forme.

Stratégie de conception

Un système orienté objet pourrait utiliser une classe de base abstraite pour fournir une interface commune et standardisée appropriée pour toutes les applications externes. Ensuite, par héritage à partir 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 comme 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 aussi d'ajouter facilement de nouvelles applications à un système, même après que le système a été défini.