Accéder à la variable privée en C++
- Accéder à la variable privée en C++
- Accéder à une variable privée en C++ à l’aide de fonctions membres
-
Accéder aux variables privées en C++ à l’aide des fonctions
friend - Accéder à une variable privée en C++ à l’aide de pointeurs
- Conclusion
Cet article traite des variables privées C++ et explique comment y accéder en C++.
Accéder à la variable privée en C++
L’encapsulation protège les données sensibles et essentielles des utilisateurs non autorisés. Le mot clé private est utilisé pour réaliser ce phénomène.
Parallèlement à l’encapsulation, le concept de masquage de données est également implémenté en C++. La variable déclarée avec le mot clé private en C++ signale qu’elle n’est accessible que par les fonctions membres de sa classe.
Aucun objet ou fonction ne peut y accéder directement.
#include <iostream>
using namespace std;
class shape {
private:
double r;
public:
void area(double rr) {
r = rr;
double ar = 3.14 * r * r;
cout << "Radius is: " << r << endl;
cout << "Area is: " << ar;
}
};
int main() {
shape obj;
obj.area(1.5);
return 0;
}
Production:
Radius is: 1.5
Area is: 7.065
Hormis une fonction friend ou fonction membre de la classe, aucune entité ne peut accéder aux données privées membre de la classe. Ici, la variable r est accessible par la fonction membre de la classe area().
La fonction area() calcule l’aire du cercle en accédant à la donnée membre privée de la classe. Et l’objet de la classe est créé dans la fonction principale de la classe.
Grâce à cet objet, la fonction membre de la classe est accessible et l’aire du cercle est calculée.
La fonction friend seule n’est pas le moyen d’accéder aux données privées des membres. En plus de cela, les variables privées sont également accessibles en dehors d’une classe à l’aide de pointeurs.
Cette méthode d’utilisation de pointeurs pour accéder aux données membres privées est une faille en C++. Lisez la suite pour en savoir plus à ce sujet.
Accéder à une variable privée en C++ à l’aide de fonctions membres
Une variable ou une fonction de membre privé en C++ ne peut pas être consultée ou vue en dehors de la classe. Le concept principal de C++ est sa caractéristique unique de sécurité des données.
Une donnée membre privée n’est accessible que par la classe dans laquelle elle est créée et la fonction friend de sa classe.
Concentrez-vous sur l’exemple ci-dessous pour savoir comment les fonctions membres de la classe accèdent aux données membres.
#include <iostream>
using namespace std;
class Emp {
private:
int sal;
public:
void setSal(int s) { sal = s; }
int getSal() { return sal; }
};
int main() {
Emp myObj;
myObj.setSal(50000);
cout << myObj.getSal();
return 0;
}
Production:
50000
Dans le programme ci-dessus, la classe emp a des membres privés et publics. sal est une variable privée à laquelle deux fonctions membres de la classe peuvent accéder : setSal() et getSal().
setSal() initialise la valeur du membre de données privé sal, et getSal() renvoie la valeur du membre de données privé sal. Enfin, dans la méthode main, l’objet de la classe est créé.
L’objet myObj accède à la fonction membre de la classe, setSal(), pour transmettre la valeur à la donnée membre privée sal. Enfin, l’objet de classe accède à getSal() pour renvoyer le membre de données sal.
Par défaut, tous les membres d’une classe sont privés ; par exemple, dans la classe suivante, w est un membre privé. Ainsi, il sera considéré comme un membre de données privées jusqu’à ce que vous étiquetiez un membre comme public ou protégé.
class B {
double w;
public:
double len;
void setW(double wid);
double get(void);
};
En temps réel, les données sont définies dans la zone privée et les membres fonctionnent dans la zone publique pour les appeler depuis l’extérieur de la classe, comme illustré dans le programme suivant.
#include <iostream>
using namespace std;
class B {
public:
double len;
void setW(double wid);
double getW(void);
private:
double w;
};
double B::getW(void) { return w; }
void B::setW(double wid) { w = wid; }
int main() {
B box;
box.len = 10.0;
cout << "Length: " << box.len << endl;
box.setW(10.0);
cout << "Width: " << box.getW() << endl;
return 0;
}
Dans le programme ci-dessus, la classe B comprend des membres privés et publics. Ici, w est une variable privée à laquelle la fonction membre à deux classes peut accéder : setW() et getW().
setW() initialise la valeur de la donnée membre privée w, et getW() renvoie la valeur de la donnée membre privée w. La boîte d’objet accède à la fonction membre de la classe.
La variable publique len est accessible via la boîte d’objet et est initialisée avec une valeur. setW() attribue la valeur donnée au membre de données privé w.
Enfin, la boîte d’objet de classe accède à getW() pour renvoyer le membre de données w.
Production:
Length: 10
Width: 10
Accéder aux variables privées en C++ à l’aide des fonctions friend
Une fonction friend se trouve dans la partie privée ou publique de la classe. Il peut être appelé une fonction membre normale sans utiliser l’objet.
L’objet de classe ne l’appelle pas car il n’est pas dans la portée de la classe. De plus, il ne peut pas accéder directement aux données membres privées et protégées de la classe.
La fonction friend utilise l’objet de la classe et accède aux membres à l’aide de l’opérateur point. Il peut s’agir d’une fonction globale ou d’un membre d’une autre classe.
#include <iostream>
using namespace std;
class Dist {
private:
int m;
friend int add(Dist);
public:
Dist() : m(0) {}
};
int add(Dist d) {
d.m += 5;
return d.m;
}
int main() {
Dist D;
cout << "Distance: " << add(D);
return 0;
}
Production:
Distance = 5
Dans le programme ci-dessus, on peut voir une classe Dist avec des membres privés m. Nous avons un constructeur public qui initialise les valeurs de m.
Ensuite, il y a une fonction friend add(), qui calcule la distance en utilisant m. Le add() est une fonction friend qui n’est pas dans la portée de la classe.
Dans la méthode main, un objet de la classe est créé et la fonction add() est passée. La fonction add() calcule la distance et affiche le résultat.
Classe ami en C++
Une classe friend est comme des fonctions friend qui peuvent être créées. La classe friend peut accéder aux membres secrets et protégés de la classe avec laquelle elle est amie.
Semblable aux fonctions friend, il existe une classe friend. Il peut accéder aux membres des classes privées et protégées dont il est un friend.
Syntaxe:
class X {
Data members;
Member Functions;
friend class Y;
};
class B {
……..
};
Comme indiqué dans la syntaxe, la classe X est un ami de la classe Y. Cela signifie que la classe Y peut accéder aux membres privés et protégés de la classe X.
Mais cette amitié n’est pas réciproque, et la classe X ne peut pas accéder aux membres privés et protégés de la classe Y. Il faut désigner la classe X comme friend de la classe Y.
De plus, l’amitié n’est pas héritée, donc la classe Y ne sera pas friend des classes filles de la classe X.
Exemple de classe friend en C++
#include <iostream>
#include <string>
using namespace std;
class Ar {
int len, br, arr;
public:
Ar(int l, int b) {
len = l;
br = b;
};
void computeArea() { arr = len * br; }
friend class prClass;
};
class prClass {
public:
void prAr(Ar &a) { cout << "Area = " << a.arr; }
};
int main() {
Ar a(20, 10);
a.computeArea();
prClass p;
p.prAr(a);
return 0;
}
Production:
Area = 200
Dans le programme ci-dessus, il y a deux classes. La classe Ar calcule l’aire à l’aide des variables len et br.
Cette classe a trois membres de données privées : arr, len et br. L’autre classe créée est prClass, qui imprime la surface finale calculée par la fonction membre computeArea de la classe Ar.
Comme toutes les données membres sont privées, nous devons faire de la prClass une friend de la classe Ar pour imprimer le résultat. L’objet de classe Ar est créé à l’intérieur de la fonction principale.
Le calcul de surface est fait, et l’objet de la classe Ar est passé à la fonction prClass. Cette fonction s’appelle prAr, qui affiche la zone.
Inconvénients de l’utilisation d’une fonction friend pour accéder aux variables privées en C++
La caractéristique la plus importante de C++ est l’encapsulation, c’est-à-dire un regroupement de données et de fonctions. Les membres de données et les fonctions membres travaillent ensemble sur les données afin qu’aucune fonction ou classe extérieure ne puisse accéder aux données.
La fonction d’encapsulation est compromise car les fonctions ou la classe “amie” sont autorisées à accéder aux membres privés d’une autre classe. La sécurité des données est en danger.
Accéder à une variable privée en C++ à l’aide de pointeurs
Les pointeurs accèdent aux données sans fonction friend ou membre de classe.
#include <bits/stdc++.h>
using namespace std;
class Hello {
private:
int c;
int d;
};
int main() {
Hello a;
int* q = (int*)&a;
*q = 4;
q++;
*q = 5;
q--;
cout << endl << "c = " << *q;
q++;
cout << endl << "d = " << *q;
return 0;
}
Production:
c = 4
d = 5
Dans le programme ci-dessus, a est un objet de la classe Hello. L’adresse de l’objet de classe a est affectée au pointeur d’entier q par transtypage.
Le pointeur q pointe alors sur le membre privé c. La valeur entière est affectée à *q, qui est c.
Puis l’adresse de l’objet a est augmentée et en accédant à l’emplacement mémoire la valeur 5 est affectée à d. L’instruction q-- définit l’emplacement mémoire de c.
En utilisant l’instruction cout, c s’affiche.
Conclusion
Dans cet article, nous avons discuté de l’accès à une variable privée en C++. Nous avons appris les différentes méthodes pour accéder aux membres privés en C++.
De plus, avec de nombreux exemples, nous avons abordé le concept de fonctions et de pointeurs amis en C++. Une chose importante à retenir est que les objets ne peuvent pas être créés dans une classe dont les fonctions membres sont également privées.
Dans cet esprit, nous espérons que vous avez apprécié la lecture de cet article. Restez à l’écoute pour des articles plus informatifs.