Introducere în modificatorii de acces în C ++
Protejarea datelor a fost în tendință de mult timp, deoarece este cea mai importantă parte a fiecărui domeniu. Dacă merge în mâna greșită, atunci vei suferi mult. Pentru a vă gestiona datele într-o manieră sistematică, programarea orientată pe obiect oferă o caracteristică importantă cunoscută sub numele de Date de ascundere. Acest concept poate fi implementat în C ++ folosind modificatori de acces. Sunt cuvinte cheie care sunt utilizate pentru a seta accesibilitatea metodelor, claselor și a altor membri. Public, privat și protejat este cunoscut sub numele de modificatori de acces sau de specificații de acces în limbaje de programare orientate pe obiecte. Pentru a împiedica funcțiile unui program să acceseze direct reprezentarea internă a unei clase, se folosește ascunderea datelor.
Tipuri de modificatori de acces în C ++
Există 3 tipuri de modificatori de acces în C ++
- Public
- Privat
- Protejat
Haideți să aruncăm o privire la aceste modificatoare cu exemple:
1. Public
După cum sugerează și numele, disponibil tuturor. Toți membrii clasei vor fi disponibili pentru toată lumea după ce i-au declarat publici. Un membru public poate fi accesat oriunde în afara clasei, dar în cadrul unui program. Membrii datelor pot fi accesați și de alte clase, dacă sunt declarați publici. Deoarece nu există restricții în modificatorul public, putem utiliza operatorul de puncte (.) Pentru a accesa direct funcțiile și datele membrilor.
Cod:
#include
using namespace std;
class parent
(
private:
int p;
protected:
int q;
public:
int r;
parent() //constructor to initialize data members
(
p = 100;
q = 200;
r = 300;
)
);
//Inheritance concept
class child: public parent
(
//q becomes protected and r becomes public members of class child
public:
void showdata()
(
cout << "p is not accessible" << endl;
cout << "value of q is " << q << endl;
cout << "value of r is " << r << endl;
)
);
int main()
(
child c; //object of derived class(child)
c.showdata();
//cp = 100; invalid : private member, no access
//cq = 200; invalid : q is now private member of child class
//cr = 300; invalid : r is also now a private member of child class
return 0;
)
ieşire:
2. Privat
Un modificator privat este unul dintre cei mai buni modificatori de acces din C ++. Domeniul de aplicare al membrilor de date private rămâne în interiorul clasei, de aceea funcția din interiorul clasei poate accesa membrii clasei declarate private. Pentru că asta înseamnă privat este doar tu să decizi cine îți poate folosi lucrurile (ca un prieten) sau nu. Nu puteți accesa membrii direct prin orice obiect sau funcție care se află în afara clasei. Funcția unui prieten (așa cum am spus vă poate folosi lucrurile) poate fi utilizată pentru a accesa datele private ale clasei. Veți primi o eroare de compilare în timp ce accesați membrii de date private din orice parte din afara clasei.
Cod:
#include
using namespace std;
// Defining class
class Circle
( // private data member
private:
double radius;
// public member function
public:
void areaOfCircle(double r)
( // member function can access private
// data member radius
radius = r;
double area = 3.14*radius*radius;
cout << "Radius is: " << radius << endl;
cout << "Area is: " << area;
) );
// Main function
int main()
( // creating class object
Circle c;
/* trying to access private data member
directly outside the class */
c.areaOfCircle(4.5);
return 0;
)
ieşire:
Folosind codul de mai sus putem accesa membrii de date private ale unei clase folosind indirect funcțiile de membru public ale clasei.
3. Protejat
Ultimul specificator de acces cel mai important este folosit ca modificatori de acces în C ++, deoarece comportamentul său este destul de similar cu un modificator de acces privat. Membrii sau funcțiile protejate nu pot fi accesate direct din alte clase. Puteți utiliza funcția de prieten pentru a accesa membrii protejați, deoarece permite această funcționalitate. Există câteva restricții asupra modificatorului protejat. Membrii declarați protejați pot fi protejați până la nivelul următor, apoi devin privați.
Cod:
#include
using namespace std;
// Base class
class Parent
( // Protected data members
protected:
int id_protect;
);
// Derived class
class Child : public Parent
( public:
void set(int id)
( /* Child class to access the inherited protected data
members of the Base class */
id_protect = id;
)
void display() (
cout << "id_protect is: " << id_protect << endl;
)
);
// Main function
int main() (
Child p;
/* member function(derived class) can easily
access the data members(protected) of the base class */
p.set(07);
p.display();
return 0;
)
ieşire:
Din codul de mai sus, puteți vedea că id_protect este declarat protejat și poate fi accesat folosind funcția de membru a clasei derivate. Acest lucru înseamnă că puteți accesa datele de date protejate ale clasei de bază utilizând funcția de membru a clasei derivate.
Avantajele modificatorilor de acces în C ++
Mai jos sunt diferitele avantaje ale modificatorilor de acces în C ++:
- Modificatorul de acces vă oferă autoritatea de a vă controla datele în funcție de scenarii. Dacă lucrați într-un domeniu bancar, atunci trebuie să utilizați membri de date private pentru a vă păstra datele ascunse de alți utilizatori, autoritatea este în mâna dvs. Le puteți face publice dacă doriți, dar nu va fi o abordare grozavă, deoarece, în acest caz, oricine vă poate schimba datele în orice moment
- Toți membrii publici ai clasei de bază devin membri publici ai clasei derivate. În același mod, toți membrii protejați ai clasei de bază devin membri protejați ai clasei derivate, ceea ce vă va ajuta în gestionarea cu ușurință a datelor în fiecare aspect, deoarece, după cum vedeți, nu este schimbată accesarea acestor membri dacă utilizați moștenirea publică în limbajul dvs. de programare .
- În scenariul moștenirii private, toți membrii publici ai clasei de bază devin membri privați ai clasei derivate. În același mod, toți membrii protejați ai clasei de bază devin membri privați ai clasei derivate, în timp ce, în scenariul moștenirii protejate, toți membrii publici ai clasei de bază devin membri protejați ai clasei derivate, iar toți membrii protejați ai clasei de bază devin membri protejați ai clasei derivate. Rețineți că în specificația de acces C ++ funcționează pe clasă, nu pe bază de obiect.
Concluzie
Mai multe limbaje de programare nu au acces privat și protejat, prin urmare, orice utilizator îl poate folosi în modul dorit. Codificatorii C ++ nu vor avea încredere în utilizatori, astfel încât nu li se permite acest lucru. Deoarece membrii datelor publice pot reprezenta un risc potențial grav pentru bug-uri sau hackeri.
Articole recomandate
Acesta este un ghid pentru modificatorii de acces în C ++. Aici discutăm tipurile de modificatori de acces în C ++ împreună cu exemplele sale și câteva avantaje. De asemenea, puteți consulta următoarele articole pentru a afla mai multe-
- Accesați modificatorii în Java
- Încapsulare în C ++
- Comenzi C ++
- Cel mai bun compilator C ++
- Tipuri de modificatori de acces în C #
- Încapsulare în JavaScript
- Top 11 caracteristici și avantaje ale C ++