Maîtriser l'abstraction de données en C++ : Simplifier la conception par séparation interface-implémentation

L'abstraction de données fait référence à fournir uniquement les informations essentielles au monde extérieur et à cacher leurs détails d'arrière-plan, c'est-à-dire à représenter l'information nécessaire dans le programme sans présenter les détails.

L'abstraction de données est une technique de programmation (et de conception) qui repose sur la séparation de l'interface et de l'implémentation.

Prenons un exemple réel d'une télévision, que vous pouvez allumer et éteindre, changer de chaîne, régler le volume, et ajouter des composants externes tels que des haut-parleurs, des magnétoscopes et des lecteurs DVD, MAIS vous ne connaissez pas ses détails internes, c'est-à-dire que vous ne savez pas comment elle reçoit les signaux par les ondes ou par câble, comment elle les traduit, et les affiche finalement sur l'écran.

Ainsi, nous pouvons dire qu'une télévision sépare clairement son implémentation interne de son interface externe et vous pouvez jouer avec ses interfaces comme le bouton d'alimentation, le changeur de chaîne et le contrôle de volume sans avoir aucune connaissance de ses internes.

En C++, les classes fournissent un grand niveau d'abstraction de données. Elles fournissent des méthodes publiques suffisantes au monde extérieur pour jouer avec la fonctionnalité de l'objet et manipuler les données de l'objet, c'est-à-dire l'état, sans réellement savoir comment la classe a été implémentée en interne.

Par exemple, votre programme peut faire un appel à la fonction sort() sans savoir quel algorithme la fonction utilise réellement pour trier les valeurs données. En fait, l'implémentation sous-jacente de la fonctionnalité de tri pourrait changer entre les versions de la bibliothèque, et tant que l'interface reste la même, votre appel de fonction fonctionnera toujours.

En C++, nous utilisons les classes pour définir nos propres types de données abstraits (ADT). Vous pouvez utiliser l'objet cout de la classe ostream pour envoyer des données vers la sortie standard comme ceci :

#include <iostream>
using namespace std;

int main() {
    cout << "Hello C++" << endl;
    return 0;
}

Ici, vous n'avez pas besoin de comprendre comment cout affiche le texte sur l'écran de l'utilisateur. Vous devez seulement connaître l'interface publique et l'implémentation sous-jacente de 'cout' est libre de changer.

Les étiquettes d'accès imposent l'abstraction

En C++, nous utilisons les étiquettes d'accès pour définir l'interface abstraite de la classe. Une classe peut contenir zéro ou plusieurs étiquettes d'accès :

• Les membres définis avec une étiquette public sont accessibles à toutes les parties du programme. La vue d'abstraction de données d'un type est définie par ses membres publics.

• Les membres définis avec une étiquette private ne sont pas accessibles au code qui utilise la classe. Les sections privées cachent l'implémentation du code qui utilise le type.

Il n'y a pas de restrictions sur la fréquence d'apparition d'une étiquette d'accès. Chaque étiquette d'accès spécifie le niveau d'accès des définitions de membres qui suivent. Le niveau d'accès spécifié reste en vigueur jusqu'à ce que la prochaine étiquette d'accès soit rencontrée ou que l'accolade fermante droite du corps de la classe soit vue.

Avantages de l'abstraction de données

L'abstraction de données fournit deux avantages importants :

• Les internes de la classe sont protégés des erreurs au niveau utilisateur involontaires, qui pourraient corrompre l'état de l'objet.

• L'implémentation de la classe peut évoluer avec le temps en réponse à l'évolution des exigences ou aux rapports de bogues sans nécessiter de changement dans le code au niveau utilisateur.

En définissant les membres de données uniquement dans la section privée de la classe, l'auteur de la classe est libre de faire des changements dans les données. Si l'implémentation change, seul le code de la classe doit être examiné pour voir quel effet le changement peut avoir. Si les données sont publiques, alors toute fonction qui accède directement aux membres de données de l'ancienne représentation pourrait être cassée.

Exemple d'abstraction de données

Tout programme C++ où vous implémentez une classe avec des membres publics et privés est un exemple d'abstraction de données. Considérez l'exemple suivant :

#include <iostream>
using namespace std;

class Adder {
public:
    // constructeur
    Adder(int i = 0) {
        total = i;
    }
    // interface vers le monde extérieur
    void addNum(int number) {
        total += number;
    }
    // interface vers le monde extérieur
    int getTotal() {
        return total;
    };
private:
    // données cachées du monde extérieur
    int total;
};

int main() {
    Adder a;
    a.addNum(10);
    a.addNum(20);
    a.addNum(30);
    cout << "Total " << a.getTotal() << endl;
    return 0;
}

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

Total 60

La classe ci-dessus additionne des nombres ensemble et retourne la somme. Les membres publics - addNum et getTotal sont les interfaces vers le monde extérieur et un utilisateur a besoin de les connaître pour utiliser la classe. Le membre privé total est quelque chose que l'utilisateur n'a pas besoin de connaître, mais qui est nécessaire pour que la classe fonctionne correctement.

Stratégie de conception

L'abstraction sépare le code en interface et implémentation. Donc lors de la conception de votre composant, vous devez garder l'interface indépendante de l'implémentation afin que si vous changez l'implémentation sous-jacente, l'interface reste intacte.

Dans ce cas, quels que soient les programmes utilisant ces interfaces, ils ne seraient pas impactés et auraient juste besoin d'une recompilation avec la dernière implémentation.