Le programme C++ accède aux membres privés de la classe

Les membres privés d'une classe ne sont accessibles qu'aux membres de la classe. Ceci est fait pour maintenir les principes d'encapsulation orientée objet, garantissant que les données et leurs fonctions associées sont conservées dans une unité et ne sont accessibles qu'aux membres de la classe. C++ dispose de trois contrôles d'accès différents pour spécifier la visibilité des membres d'une classe. Ces trois caractères de contrôle d'accès sont −

• Public − Si les membres d'une classe ont une visibilité publique, alors ces membres sont accessibles depuis n'importe quelle autre classe.

• Privé − Les membres de la classe ayant une visibilité privée ne sont accessibles que depuis l'intérieur de la classe.

• Protégé − les membres de la classe protégés sont accessibles depuis with9in la classe ou depuis ses sous-classes uniquement.

Pour cet article, nous nous concentrerons uniquement sur l'accès aux membres privés d'une classe.

Utilisez les méthodes getter et setter pour accéder aux membres des données

Les fonctions Getter et setter sont utilisées pour accéder et modifier les membres privés d'une classe. Comme son nom l'indique, la fonction getter renvoie le membre de données, tandis que la fonction setter est utilisée pour "set" ou modifier le membre de données. Nous utilisons deux exemples pour mieux comprendre ce concept, mais avant cela, la syntaxe de base est donnée ci-dessous.

Grammaire

Fonctions Getter/Accesseur −

private:
   <datatype> value;
public:
   <datatype> getterFunction() {
     return <datatype> this->value;
   }

Fonction Setter/Mutator−

private:
   <datatype> value;
public:
   void setterFunction(<datatype> _value) {
     this->value = _value;
   }

Exemple

Exemple

#include <iostream>

using namespace std;

class Test{
   private:
      int value;
   public:
      //the getter function
      int getValue() {
         return this->value;
      }
      //the setter function
      void setValue(int _value) {
         this->value = _value;
      }
};

int main(){
   Test test;
   test.setValue(15);
   cout << "The value we set is: " << test.getValue() << endl;
   return 0;
}

Sortie

The value we set is: 15

Accéder à la fonction membre depuis une autre fonction

La situation est la même lorsque l'on accède à une fonction de membre privé. Nous devons y accéder depuis la méthode membre de classe de la même manière que nous accédons aux données membres. Nous pouvons utiliser le pointeur "this" pour éviter les conflits de noms.

Grammaire

private:
   <returntype> function_name(params) {};
public:
   <returntype> another_function(params) {
     <datatype> var = this->function_name(arguments);
   }

Les fonctions qui appellent des fonctions membres privées doivent être déclarées publiques. La fonction publique ne sera exécutée que lorsqu'elle sera appelée depuis un objet de cette classe.

Exemple

Exemple

#include <iostream>

using namespace std;

class Test{
   private:
      int value;
      //multiplies the member value by 10
      void multiplyValue() {
         this->value = this->value * 10;
      }
   public:
      //the getvalue function calls the multiply value function
      int multiplyAndGetValue() {
         this->multiplyValue();
         return this->value;
      }
      //the setter function
      void setValue(int _value) {
         this->value = _value;
      }
};

int main(){
   Test test;
   test.setValue(15);
   cout << "The value after setting and multiplying is: " << test.multiplyAndGetValue() << endl;
   return 0;
}

Sortie

The value after setting and multiplying is: 150

Utilisez les cours d'amis

En C++, une classe amie est une classe qui peut accéder aux membres privés et protégés d'autres classes qui ne sont pas visibles par les autres classes. Pour déclarer une classe comme amie d’une autre classe, utilisez le mot-clé « friend ». Voyons comment cela fonctionne.

Grammaire

class A{
   private:
     .....
   friend class B;
};

class B{
   //class body
};

Exemple

Exemple

#include <iostream>

using namespace std;

class Test1{
   private:
      int value;
   public:
      Test1(int _value) {
         this->value = _value;
      }
      //we declare another class as a friend
      friend class Test2;
};

class Test2{
  public:
   //displays the value of the other class object
   void display(Test1 &t) {
      cout << "The value of Test1 object is: " << t.value;
   }
};

int main(){
   //creating two class objects of the two classes
   Test1 test1(15);
   Test2 test2;

   //calling the friend class function
   test2.display(test1);
   return 0;
}

Sortie

The value of Test1 object is: 15

Utilisez les fonctions d'ami

En C++, les fonctions d'amis sont similaires aux classes d'amis. Ici, nous pouvons déclarer une fonction spécifique qui n'est pas membre de la classe comme « ami » et elle aura accès aux membres privés de la classe. Examinons la syntaxe permettant de définir une fonction comme « friend ».

Grammaire

class A{
   private:
     .....
   friend <return_type> function_name(params);
};

<return_type> function_name(params) {
   //function body
}

Exemple

Exemple

#include <iostream>

using namespace std;

class Test1{
   private:
      int value;
   public:
      Test1(int _value) {
         this->value = _value;
      }
      //we declare a friend function
      friend void display(Test1);
};

void display(Test1 t) {
   cout << "The value of Test1 object is: " << t.value;
}

int main(){
   //creating two class objects of the two classes
   Test1 test1(55);
   //calling the friend class function
   display(test1);
   return 0;
}

Sortie

The value of Test1 object is: 55

Conclusion

Lorsque nous accédons aux données privées membres d'une classe, il est préférable d'utiliser les fonctions accesseur/getter et modificateur/setter. Il s’agit du moyen le plus sûr d’accéder aux données membres d’une classe. Une chose à retenir est que les fonctions qui accèdent aux membres privés doivent être déclarées publiques. Les fonctions Friend ne sont pas disponibles dans d'autres langages orientés objet car cela ne préserve pas toujours les propriétés de l'encapsulation orientée objet. La relation amie est asymétrique. Si la classe A déclare la classe B comme amie, alors la classe B aura accès à tous les membres de A, mais A ne pourra pas accéder à tous les membres privés de B.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!