Modificateurs d'accès C ++

Dans ce didacticiel, nous allons découvrir les modificateurs d'accès pour les classes C ++ à l'aide d'exemples. Les modificateurs d'accès de C ++ sont publics, privés et protégés.

L'une des principales caractéristiques des langages de programmation orientés objet tels que C ++ est le masquage des données .

Le masquage des données fait référence à la restriction de l'accès aux données membres d'une classe. Cela permet d'éviter que d'autres fonctions et classes ne falsifient les données de classe.

Cependant, il est également important de rendre certaines fonctions membres et données membres accessibles afin que les données masquées puissent être manipulées indirectement.

Les modificateurs d'accès de C ++ nous permettent de déterminer quels membres de classe sont accessibles à d'autres classes et fonctions, et lesquels ne le sont pas.

Par exemple,

 class Patient ( private: int patientNumber; string diagnosis; public: void billing() ( // code ) void makeAppointment() ( // code ) );

Ici, les variables patientNumber et diagnostic de la Patientclasse sont masquées à l'aide du privatemot - clé, tandis que les fonctions membres sont rendues accessibles à l'aide du publicmot - clé.

Types de modificateurs d'accès C ++

En C ++, il existe 3 modificateurs d'accès:

  • public
  • private
  • protected

Modificateur d'accès public

  • Le publicmot-clé est utilisé pour créer des membres publics (données et fonctions).
  • Les membres du public sont accessibles à partir de n'importe quelle partie du programme.

Exemple 1: modificateur d'accès public C ++

 #include using namespace std; // define a class class Sample ( // public elements public: int age; void displayAge() ( cout << "Age = " << age << endl; ) ); int main() ( // declare a class object Sample obj1; cout <> obj1.age; // call class function obj1.displayAge(); return 0; )

Production:

 Entrez votre âge: 20 Âge = 20

Dans ce programme, nous avons créé une classe nommée Sample, qui contient une publicvariable age et une publicfonction displayAge().

Dans main(), nous avons créé un objet de la Sampleclasse nommé obj1. On accède alors directement aux éléments publics en utilisant les codes obj.ageet obj.displayAge().

Modificateur d'accès privé

  • Le privatemot-clé est utilisé pour créer des membres privés (données et fonctions).
  • Les membres privés sont accessibles uniquement à partir de la classe.
  • Cependant, les classes d'amis et les fonctions d'amis peuvent accéder aux membres privés.

Exemple 2: spécificateur d'accès privé C ++

 #include using namespace std; // define a class class Sample ( // private elements private: int age; // public elements public: void displayAge(int a) ( age = a; cout << "Age = " << age << endl; ) ); int main() ( int ageInput; // declare an object Sample obj1; cout <> ageInput; // call function and pass ageInput as argument obj1.displayAge(ageInput); return 0; )

Production:

 Entrez votre âge: 20 Âge = 20

Dans main(), l'objet obj1 ne peut pas accéder directement à la variable de classe age.

 // error cin>> obj1.age;

Nous ne pouvons manipuler qu'indirectement l'âge via la fonction publique displayAge(), puisque cette fonction affecte l'âge à l'argument qui lui est passé, c'est-à-dire le paramètre de fonction int a.

Modificateur d'accès protégé

Before we learn about the protected access specifier, make sure you know about inheritance in C++.

  • The protected keyword is used to create protected members (data and function).
  • The protected members can be accessed within the class and from the derived class.

Example 3: C++ protected Access Specifier

 #include using namespace std; // declare parent class class Sample ( // protected elements protected: int age; ); // declare child class class SampleChild : public Sample ( public: void displayAge(int a) ( age = a; cout << "Age = " << age << endl; ) ); int main() ( int ageInput; // declare object of child class SampleChild child; cout <> ageInput; // call child class function // pass ageInput as argument child.displayAge(ageInput); return 0; )

Output:

 Enter your age: 20 Age = 20

Here, ChildSample is an inherited class that is derived from Sample. The variable age is declared in Sample with the protected keyword.

This means that ChildSample can access age since Sample is its parent class.

We see this as we have assigned the value of age in ChildSample even though age is declared in the Sample class.

Summary: public, private, and protected

  • public elements can be accessed by all other classes and functions.
  • privateles éléments ne sont pas accessibles en dehors de la classe dans laquelle ils sont déclarés, sauf par les friendclasses et les fonctions.
  • protectedles éléments sont comme les private, sauf qu'ils sont accessibles par des classes dérivées.
Prescripteurs Même classe Classe dérivée Hors classe
public Oui Oui Oui
private Oui Non Non
protected Oui Oui Non

Remarque: Par défaut, les membres de classe en C ++ sont private, sauf indication contraire.

Articles intéressants...