Encapsulation C ++ (avec exemples)

Dans ce didacticiel, nous allons découvrir l'encapsulation en C ++ à l'aide d'exemples.

L'encapsulation est l'une des principales caractéristiques de la programmation orientée objet. Cela implique le regroupement des données membres et des fonctions dans une seule classe.

Le regroupement de membres de données et de fonctions similaires au sein d'une classe contribue également au masquage des données.

Encapsulation C ++

En général, l'encapsulation est un processus d'encapsulation de code similaire en un seul endroit.

En C ++, nous pouvons regrouper les membres de données et les fonctions qui fonctionnent ensemble dans une seule classe. Par exemple,

 class Rectangle ( public: int length; int breadth; int getArea() ( return length * breadth; ) );

Dans le programme ci-dessus, la fonction getArea()calcule l'aire d'un rectangle. Pour calculer la superficie, il faut de la longueur et de la largeur.

Par conséquent, les membres de données (longueur et largeur) et la fonction getArea()sont conservés ensemble dans la Rectangleclasse.

Encapsulation en C ++

Exemple 1: Encapsulation C ++

 // Program to calculate the area of a rectangle #include using namespace std; class Rectangle ( public: // Variables required for area calculation int length; int breadth; // Constructor to initialize variables Rectangle(int len, int brth) : length(len), breadth(brth) () // Function to calculate area int getArea() ( return length * breadth; ) ); int main() ( // Create object of Rectangle class Rectangle rect(8, 6); // Call getArea() function cout << "Area = " << rect.getArea(); return 0; )

Production

 Aire = 48

Dans l'exemple ci-dessus, nous calculons l'aire d'un rectangle.

Pour calculer une zone, nous avons besoin de deux variables: la longueur et la largeur et une fonction: getArea(). Par conséquent, nous avons regroupé ces variables et ces fonctions dans une seule classe nommée Rectangle.

Ici, les variables et fonctions sont également accessibles à partir d'autres classes. Par conséquent, il ne s'agit pas de masquer des données .

Ce n'est que de l' encapsulation . Nous conservons simplement des codes similaires ensemble.

Remarque: les gens considèrent souvent l'encapsulation comme un masquage de données, mais ce n'est pas tout à fait vrai.

L'encapsulation fait référence au regroupement de champs et de méthodes connexes. Cela peut être utilisé pour masquer les données. L'encapsulation en soi ne cache pas les données.

Pourquoi l'encapsulation?

• En C ++, l'encapsulation nous aide à garder ensemble les données et les fonctions associées, ce qui rend notre code plus propre et facile à lire.
• Il permet de contrôler la modification de nos données membres.
  Prenons une situation où nous voulons que le champ de longueur d'une classe soit non négatif. Ici, nous pouvons rendre la variable de longueur privée et appliquer la logique à l'intérieur de la méthode setAge(). Par exemple,
  

   class Rectangle ( private: int age; public: void setLength(int len) ( if (len>= 0) length = len; ) );

• Les fonctions getter et setter fournissent un accès en lecture seule ou en écriture seule à nos membres de classe. Par exemple,
  

   getLength() // provides read-only access setLength() // provides write-only access

• Il aide à découpler les composants d'un système. Par exemple, nous pouvons encapsuler du code dans plusieurs bundles.
  Ces composants découplés (bundles) peuvent être développés, testés et débogués indépendamment et simultanément. Et tout changement dans un composant particulier n'a aucun effet sur les autres composants.
• Nous pouvons également réaliser le masquage des données en utilisant l'encapsulation. Dans l' exemple 1 , si nous changeons les variables de longueur et de largeur en privateou protected, l'accès à ces champs est restreint.
  Et, ils sont tenus cachés des classes extérieures. C'est ce qu'on appelle le masquage des données .

Masquage des données

Le masquage des données est un moyen de restreindre l'accès de nos données membres en masquant les détails de mise en œuvre. L'encapsulation fournit également un moyen de masquer les données.

Nous pouvons utiliser des modificateurs d'accès pour masquer les données en C ++. Par exemple,

Exemple 2: masquage de données C ++ à l'aide du spécificateur privé

 #include using namespace std; class Rectangle ( private: // Variables required for area calculation int length; int breadth; public: // Setter function for length void setLength(int len) ( length = len; ) // Setter function for breadth void setBreadth(int brth) ( breadth = brth; ) // Getter function for length int getLength() ( return length; ) // Getter function for breadth int getBreadth() ( return breadth; ) // Function to calculate area int getArea() ( return length * breadth; ) ); int main() ( // Create object of Rectangle class Rectangle rectangle1; // Initialize length using Setter function rectangle1.setLength(8); // Initialize breadth using Setter function rectangle1.setBreadth(6); // Access length using Getter function cout << "Length = " << rectangle1.getLength() << endl; // Access breadth using Getter function cout << "Breadth = " << rectangle1.getBreadth() << endl; // Call getArea() function cout << "Area = " << rectangle1.getArea(); return 0; )

Production

 Longueur = 8 Largeur = 6 Zone = 48

Ici, nous avons fait les variables de longueur et de largeur private.

Cela signifie que ces variables ne sont pas accessibles directement en dehors de la Rectangleclasse.

Pour accéder à ces variables privées, nous avons utilisé les publicfonctions setLength(), getLength(), setBreadth()et getBreadth(). Celles-ci sont appelées fonctions getter et setter.

Rendre les variables privées nous a permis de restreindre l'accès non autorisé depuis l'extérieur de la classe. C'est du masquage des données .

Si nous essayons d'accéder aux variables de la main()classe, nous obtiendrons une erreur.

 // error: rectangle1.length is inaccessible rectangle1.length = 8; // error: rectangle1.breadth is inaccessible rectangle1.length = 6;