Encapsulation des données en C++ : Protégez votre code

Tous les programmes C++ sont composés des deux éléments fondamentaux suivants :

• Instructions de programme (code) : C'est la partie d'un programme qui effectue des actions et elles sont appelées fonctions.

• Données du programme : Les données sont l'information du programme qui est affectée par les fonctions du programme.

L'encapsulation est un concept de la programmation orientée objet qui lie ensemble les données et les fonctions qui manipulent ces données, et qui garde les deux à l'abri des interférences et mauvais usages extérieurs. L'encapsulation des données a conduit au concept important de la POO qu'est le masquage des données.

L'encapsulation des données est un mécanisme de regroupement des données et des fonctions qui les utilisent, et l'abstraction de données est un mécanisme d'exposition seulement des interfaces et de masquage des détails d'implémentation de l'utilisateur.

C++ prend en charge les propriétés d'encapsulation et de masquage des données grâce à la création de types définis par l'utilisateur, appelés classes. Nous avons déjà étudié qu'une classe peut contenir des membres private, protected et public. Par défaut, tous les éléments définis dans une classe sont privés. Par exemple :

class Box {
public:
    double getVolume(void) {
        return length * breadth * height;
    }
private:
    double length; // Longueur d'une boîte
    double breadth; // Largeur d'une boîte
    double height; // Hauteur d'une boîte
};

Les variables length, breadth et height sont privées. Cela signifie qu'elles ne peuvent être accessibles que par d'autres membres de la classe Box, et non par une autre partie de votre programme. C'est une façon dont l'encapsulation est réalisée.

Pour rendre des parties d'une classe publiques (c'est-à-dire accessibles aux autres parties de votre programme), vous devez les déclarer après le mot-clé public. Toutes les variables ou fonctions définies après le spécificateur public sont accessibles par toutes les autres fonctions de votre programme.

Rendre une classe amie d'une autre expose les détails d'implémentation et réduit l'encapsulation. L'idéal est de garder autant de détails de chaque classe cachés de toutes les autres classes que possible.

Exemple d'encapsulation de données

Tout programme C++ où vous implémentez une classe avec des membres publics et privés est un exemple d'encapsulation de données et 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 qui est caché du monde extérieur, mais est nécessaire pour que la classe fonctionne correctement.

Stratégie de conception

La plupart d'entre nous ont appris à rendre les membres de classe privés par défaut, sauf si nous avons vraiment besoin de les exposer. C'est juste une bonne encapsulation.

Cela s'applique le plus fréquemment aux membres de données, mais cela s'applique équitablement à tous les membres, y compris les fonctions virtuelles.