Différence entre privé et protégé en C ++

Le concept d'encapsulation et de cachette de données est largement utilisé dans les langages de programmation orientés objet tels que C++. Connaître ces concepts garantit la sécurité et l'intégrité des données dans un programme. En C ++, deux spécificateurs d'accès - privés et protégés - sont utilisés pour appliquer ces concepts. Cet article couvre la différence entre privé et protégé en C ++ et comment ils affectent la visibilité et l'accessibilité des membres de la classe.

Table des matières

• Quels sont les spécificateurs d'accès en C++
• Qu'est-ce qui est privé en C++
• Ce qui est protégé en c++
• Différence entre privé et protégé en c++
• Exemples de spécificateurs d'accès privés et protégés
• Conclusion

Quels sont les spécificateurs d'accès en C++

En C ++, les spécificateurs d'accès sont des mots clés réservés qui servent à déterminer la visibilité et l'accessibilité des membres d'une classe. Ces mots clés sont utilisés pour restreindre ou permettre l'accès à différents membres de la classe dans un programme.

Les spécificateurs d'accès déterminent à partir de l'endroit où un membre de la classe est accessible. Ces spécificateurs permettent au code C ++ d'accéder à un membre de la classe à l'intérieur ou à l'extérieur d'une classe. Ils permettent également aux classes dérivées d'accéder aux membres principaux de la classe.

Dans C ++, les spécificateurs peuvent être classés en trois spécificateurs différents:

• privé
• protégé
• public

Ces spécificateurs contrôlent la visibilité des membres de la classe, qui détermine où et par qui ils peuvent être accessibles dans le programme.

Qu'est-ce qui est privé en C++

Privé est un spécificateur d'accès en C ++ qui limite la visibilité et l'accessibilité des membres de la classe uniquement classe elle-même. Les membres définis comme privés ne sont pas accessibles à l'extérieur de la classe ou de ses classes dérivées. Les membres privés sont cachés dans d'autres classes, ce qui les empêche de modifier ou d'accéder aux données.

Ce qui est protégé en c++

Protégé est un spécificateur d'accès en C ++ qui limite la visibilité et l'accessibilité des membres de la classe au classe elle-même et son classes dérivées. Les membres définis comme protégés peuvent être accessibles à l'intérieur d'une classe ou de ses classes dérivées, mais pas de l'extérieur de la classe. Les membres protégés sont également cachés d'autres classes, ce qui les empêche de modifier ou d'accéder aux données.

Différence entre privé et protégé en c++

La principale différence entre privé et protégé en C ++ est le niveau d'accessibilité des membres de la classe. L'accès aux membres privés est limité au sein de la classe, tandis que les membres protégés sont également accessibles des classes dérivées.

Une autre différence est que les membres privés sont complètement cachés dans d'autres classes, tandis que les membres protégés sont partiellement cachés. Cela signifie que les classes dérivées peuvent accéder aux membres protégés, mais ne pas les modifier directement. En revanche, les membres privés ne peuvent être accessibles ou modifiés par aucune autre classe.

Exemples de spécificateurs d'accès privés et protégés

Pour démontrer le concept de spécificateurs d'accès dans la programmation orientée objet, il est utile de fournir des exemples de spécificateurs d'accès privés et protégés. Examinons de plus près le fonctionnement des spécificateurs d'accès privés et protégés et quelques exemples de la façon dont ils peuvent être utilisés.

Exemple de classe privée en C++

Le spécificateur d'accès privé restreint la visibilité d'un membre de la classe au sein de la classe elle-même. Le code ci-dessous explique la classe privée dans un programme C ++:

#inclure
Utilisation de Namespace Std;
classe de classe
// membres privés
privé:
String fullName;
int Yearsold;
// membres publics
public:
void getPersonInfo ()

couter << "Enter full name: ";
getline (cin, fullname);
couter << "Enter age in years: ";
Cin >> Yeardold;

void DisplayPersonInfo ()

couter << "Name: " << fullName << endl;
couter << "Age: " << yearsOld << endl;

;
// fonction principale
int main()

// Créer un objet
Personne personne;
personne.getPersonInfo ();
personne.DisplayPersonInfo ();
retour 0;

Ce programme C ++ définit une personne de classe avec deux variables de membres privés nom et prénom et ans, et deux fonctions de membres publics getPersonInfo () et DisplayPersonInfo ().

La fonction getPersonInfo () invite l'utilisateur à saisir le nom et l'âge de la personne. Après cela, les stocke dans les variables des membres privés Fullname et des années, respectivement.

La fonction DisplayPersonInfo () imprime simplement le nom et l'âge de la personne à la console.

Dans la fonction Main (), nous créons une personne objet de la classe de personne, et appelons ses fonctions getPersonInfo () et DisplayPersonInfo () pour inciter l'utilisateur à saisir les informations d'une personne, puis à l'afficher sur la console.

Exemple de classe protégé en C++

Le spécificateur d'accès protégé limite la visibilité d'un membre de la classe au sein de la classe et de ses sous-classes. Prenons un exemple qui explique les classes protégées dans un programme C ++.

#inclure
Utilisation de Namespace Std;
// classe de base
classe de classe
// membres privés
privé:
String fullName;
en âge;
// membre protégé
protégé:
int idnumber;
// membres publics
public:
void getPersonInfo ()

couter << "Enter full name: ";
getline (cin, fullname);
couter << "Enter age: ";
Cin >> âge;

void DisplayPersonInfo ()

couter << "Name: " << fullName << endl;
couter << "Age: " << age << endl;

;
// Classe dérivée
Étudiant de classe: Personne publique
// membres privés
privé:
String City;
// membres publics
public:
void setid (int id)

// Ici idnumber est le membre protégé de la personne
// classe, il est accessible ici
idnumber = id;

void getStudentinfo ()

// Appeler getPersonInfo () pour lire les détails de base
getPersonInfo ();
// Ville d'entrée
couter << "Enter city: ";
Cin >> Ville;

void DisplayStudenInfo ()

// Affichage du numéro d'identification
couter << "ID Number: " << idNumber << endl;
// Appel DisplayPersonInfo () pour imprimer les détails de base
DisplayPersonInfo ();
// Affichage de la ville aussi
couter << "City: " << city << endl;

;
// fonction principale
int main()

// Créer un objet
Étudiant étudiant;
// Définition du numéro d'identification
étudiant.setid (12345);
// Obtenir tous les détails
étudiant.getStudenInfo ();
// Impression de tous les détails
étudiant.DisplayStudenInfo ();
retour 0;

Ici dans ce code, la classe de base est une personne avec des membres privés nom et prénom et l'âge, et un membre protégé imbrimer. La classe dérivée est étudiante avec une ville de membres privés et des fonctions des membres publics setID (), getStudenInfo () et displaystudenInfo ().

La fonction setID () définit le numéro d'identification, qui définit un membre protégé de la classe de base. La fonction getStudentinfo () lit les détails de base de l'élève comme le nom complet, l'âge et la ville dans laquelle il vit.

Le DisplayStudenInfo () La fonction imprime tous les détails de l'étudiant qui comprend leur numéro d'identification, son nom complet, son âge et leur ville.

Conclusion

Spécificateurs d'accès privés et protégés dans la programmation orientée objet Assurez l'encapsulation et la cachette des données. Les membres privés sont complètement cachés dans d'autres classes, tandis que les membres protégés sont partiellement cachés et peuvent être accessibles par des classes dérivées. Le choix entre l'utilisation de spécificateurs d'accès privés et protégés dépend de la conception et de la mise en œuvre de la classe. Lisez l'article pour comprendre les détails des spécificateurs d'accès privés et protégés.