Introduzione ai modificatori di accesso in C ++
La protezione dei dati è in voga da molto tempo, in quanto è la parte più importante di ogni dominio. Se va nella mano sbagliata, soffrirai molto. Per gestire i dati in modo sistematico, la programmazione orientata agli oggetti offre una caratteristica saliente nota come nascondere i dati. Questo concetto può essere implementato in C ++ usando i modificatori di Access. Sono parole chiave utilizzate per impostare l'accessibilità di metodi, classi e altri membri. Pubblico, privato e protetto è noto come modificatore di accesso o specificatore di accesso in linguaggi di programmazione orientati agli oggetti. Per impedire alle funzioni di un programma di accedere direttamente alla rappresentazione interna di una classe, viene utilizzato il nascondimento dei dati.
Tipi di modificatori di accesso in C ++
Esistono 3 tipi di modificatori di accesso in C ++
- Pubblico
- Privato
- protetta
Diamo un'occhiata a questi modificatori con esempi:
1. Pubblico
Come suggerisce il nome, disponibile per tutti. Tutti i membri della classe saranno disponibili a tutti dopo averli dichiarati pubblici. È possibile accedere a un membro pubblico ovunque al di fuori della classe ma all'interno di un programma. I membri dei dati possono accedere anche ad altre classi se dichiarati pubblici. Poiché non ci sono restrizioni nel modificatore pubblico, possiamo usare l'operatore punto (.) Per accedere direttamente alle funzioni e ai dati dei membri.
Codice:
#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;
)
Produzione:
2. Privato
Un modificatore privato è uno dei migliori modificatori di accesso in C ++. L'ambito dei membri di dati privati rimane all'interno della classe, pertanto la funzione all'interno della classe può accedere ai membri della classe dichiarati come privati. Perché questo è ciò che significa privato solo tu decidi chi può usare le tue cose (come un amico) o no. Non è possibile accedere ai membri direttamente da qualsiasi oggetto o funzione che non rientri nella classe. La funzione di un amico (come ho detto può usare le tue cose) può essere utilizzata per accedere ai membri di dati privati della classe. Riceverai un errore di compilazione durante l'accesso ai membri di dati privati da qualsiasi parte al di fuori della classe.
Codice:
#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;
)
Produzione:
Usando il codice sopra possiamo accedere indirettamente ai membri di dati privati di una classe usando indirettamente le funzioni dei membri pubblici della classe.
3. Protetto
L'ultimo identificatore di accesso utilizzato soprattutto come modificatori di accesso in C ++ in quanto il suo comportamento è abbastanza simile a un modificatore di accesso privato. I membri o le funzioni di dati protetti non possono accedere direttamente da altre classi. È possibile utilizzare una funzione amico per accedere ai membri protetti in quanto consente questa funzionalità. Esistono alcune restrizioni sul modificatore protetto. I membri dichiarati in protetti possono essere protetti solo fino al livello successivo, quindi diventano privati.
Codice:
#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;
)
Produzione:
Dal codice sopra, puoi vedere che id_protect è dichiarato protetto e al quale puoi accedere usando la funzione membro della classe derivata. Ciò significa che è possibile accedere al membro di dati protetto della classe base utilizzando la funzione membro della classe derivata.
Vantaggi dei modificatori di accesso in C ++
Di seguito sono riportati i diversi vantaggi dei modificatori di accesso in C ++:
- Il modificatore di accesso ti fornisce l'autorità per controllare i tuoi dati a seconda degli scenari. Se lavori in un dominio bancario, devi utilizzare membri di dati privati per mantenere i tuoi dati nascosti ad altri utenti, l'autorità è nelle tue mani. Puoi renderli pubblici se vuoi, ma non sarà un ottimo approccio perché in tal caso, chiunque può modificare i tuoi dati in qualsiasi momento
- Tutti i membri pubblici della classe base diventano membri pubblici della classe derivata. Allo stesso modo, tutti i membri protetti della classe base diventano membri protetti della classe derivata che ti aiuterà a gestire facilmente i dati in ogni aspetto perché, come puoi vedere, non c'è alcun cambiamento nell'accesso a questi membri se usi l'eredità pubblica nel tuo linguaggio di programmazione .
- Nello scenario di eredità privata, tutti i membri pubblici della classe base diventano membri privati della classe derivata. Allo stesso modo, tutti i membri protetti della classe base diventano membri privati della classe derivata mentre, nello scenario di eredità protetta, tutti i membri pubblici della classe base diventano membri protetti della classe derivata e tutti i membri protetti della classe base diventano membri protetti della classe derivata. Si noti che in C ++ le specifiche di accesso funzionano su una base per classe, non su una base per oggetto.
Conclusione
Numerosi linguaggi di programmazione non hanno accesso privato e protetto, pertanto qualsiasi utente può utilizzarlo nel modo desiderato. I programmatori C ++ non si fideranno degli utenti, quindi non possono usarli. Poiché i membri di dati pubblici possono rappresentare un grave rischio potenziale per bug o hacker.
Articoli consigliati
Questa è una guida ai modificatori di accesso in C ++. Qui discutiamo i tipi di modificatori di accesso in C ++ con i suoi esempi e alcuni vantaggi. Puoi anche consultare i seguenti articoli per saperne di più-
- Modificatori di accesso in Java
- Incapsulamento in C ++
- Comandi C ++
- Miglior compilatore C ++
- Tipi di modificatori di accesso in C #
- Incapsulamento in JavaScript
- Principali 11 caratteristiche e vantaggi di C ++