C++ Encapsulation des données

L'encapsulation des données est un concept fondamental de la programmation orientée objet (POO), qui est mise en œuvre en encapsulant les données et les fonctions qui opèrent sur ces données au sein d'une classe. Cette encapsulation garantit la confidentialité et l'intégrité des données, empêchant le code externe d'y accéder directement et de les modifier.

Tous les programmes C++ ont les deux éléments de base suivants :

  • Instructions du programme (code) :Ce sont les parties du programme qui exécutent des actions ; elles sont appelées fonctions.
  • Données du programme :Les données sont les informations du programme, qui sont affectées 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 opèrent sur les données, évitant ainsi les interférences et les utilisations abusives venant de l'extérieur, assurant ainsi la sécurité. L'encapsulation des données conduit à un autre concept important de la POO, à savoirMasquage des données。

Encapsulation des donnéesest un mécanisme qui relie les données et les fonctions qui opèrent sur les données,Abstraction des donnéesest un mécanisme qui n'expose que l'interface aux utilisateurs tout en masquant les détails d'implémentation spécifiques.

C++, en créantune classe,prend en charge l'encapsulation et le masquage des données (public, protected, private). Nous savons déjà que les classes contiennent des membres privés, des membres protégés et des membres publics. 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 double breadth; // Largeur double height; // Height };

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

Pour rendre publics les membres d'une classe (c'est-à-dire accessibles à d'autres parties du programme), le mot-clépublicdoit être utilisé avant ces membres. Toutes les variables ou fonctions définies après l'identifiant public peuvent être accessibles par toutes les autres fonctions du programme.

Définir une classe comme classe amie d'une autre classe exposera les détails d'implémentation, réduisant ainsi l'encapsulation. L'approche idéale consiste à masquer autant que possible les détails d'implémentation de chaque classe.

Modificateurs d'accès :

  • private: Les membres privés ne peuvent être accédés qu'à l'intérieur de la classe et ne peuvent pas être directement accédés par du code extérieur à la classe.
  • public: Les membres publics peuvent être directement accédés par du code extérieur à la classe.
  • protected: Les membres protégés peuvent être accédés par la classe et ses classes dérivées.

Exemple d'encapsulation des données

Dans un programme C++, toute classe avec des membres publics et privés peut constituer un exemple d'encapsulation des données et d'abstraction des données. Voir l'exemple ci-dessous :

Exemple

#include <iostream> using namespace std; class Adder{ public: // constructeur Adder(int i = 0) { total = i; } // Interface externe void addNum(int number) { total += number; } // Interface externe int getTotal() { return total; }; private: // Données masquées à l'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 les résultats suivants :

Total 60

La classe ci-dessus additionne des nombres et renvoie la somme. Les membres publicsaddNumetgetTotalconstituent l'interface externe ; les utilisateurs doivent les connaître afin d'utiliser la classe. Les membres privéstotalsont cachés de l'extérieur ; les utilisateurs n'ont pas besoin de les connaître, mais ils sont nécessaires pour que la classe fonctionne correctement.

L'encapsulation des données est mise en œuvre via les classes et les modificateurs d'accès (public, private, protected). Voici un exemple simple :

Exemple

#include <iostream>
using namespace std;

class Student {
private:
    string name;
    int age;

public:
    // constructeur
    Student(string studentName, int studentAge) {
        name = studentName;
        age = studentAge;
    }

    // Fonction d'accès (getter)
    string getName() {
        return name;
    }

    int getAge() {
        return age;
    }

    // Fonction de modification (setter)
    void setName(string studentName) {
        name = studentName;
    }

    void setAge(int studentAge) {
        if (studentAge > 0) {
            age = studentAge;
        } else {
            cout << "Âge invalide !" << endl;
        }
    }

    // Afficher les informations de l'étudiant
    void printInfo() {
        cout << "Nom : " << name << ", Âge : " << age << endl;
    }
};

int main() {
    // Créer un objet Student
    Student student1("Alice", 20);

    // Accéder aux données et les modifier
    student1.printInfo();

    student1.setName("Bob");
    student1.setAge(22);

    student1.printInfo();

    return 0;
}

Stratégie de conception

Normalement, nous définissons l'état des membres de classe comme privé, sauf si nous avons vraiment besoin de les exposer, afin d'assurer une bonneEncapsulation。

Cela s'applique généralement aux membres de données, mais cela s'applique également à tous les membres, y compris les fonctions virtuelles.

Avantages de l'encapsulation des données

  • Masquage des données: En déclarant les membres de données comme privés, le code externe est empêché d'accéder directement à ces données.
  • Améliorer la maintenabilité du code: Fournir des méthodes publiques pour accéder aux données et les modifier, ce qui permet de modifier l'implémentation interne de la classe sans affecter le code externe.
  • Renforcer la sécurité: Empêcher la saisie de données illégales et les opérations de modification inappropriées.
  • Mettre en œuvre l'abstraction: Fournir un mécanisme tel que les utilisateurs n'aient pas besoin de comprendre les détails d'implémentation internes de la classe ; ils ont seulement besoin de savoir comment utiliser l'interface publique de la classe.
autres extensions