Modificatori di accesso alle classi C ++

L'occultamento dei dati è una delle caratteristiche importanti della programmazione orientata agli oggetti che consente di impedire alle funzioni di un programma di accedere direttamente alla rappresentazione interna di un tipo di classe. La restrizione di accesso ai membri della classe è specificata dall'etichettapublic, private, e protectedsezioni all'interno del corpo della classe. Le parole chiave public, private e protected sono chiamate specificatori di accesso.

Una classe può avere più sezioni con etichetta pubblica, protetta o privata. Ogni sezione rimane attiva fino a quando non viene visualizzata un'altra etichetta di sezione o la parentesi graffa destra di chiusura del corpo della classe. L'accesso predefinito per membri e classi è privato.

class Base { 
   public:
      // public members go here
      protected:
 
   // protected members go here
   private:
   // private members go here
 
};

I membri pubblici

UN publicmembro è accessibile da qualsiasi luogo all'esterno della classe ma all'interno di un programma. È possibile impostare e ottenere il valore delle variabili pubbliche senza alcuna funzione membro come mostrato nell'esempio seguente:

#include <iostream>
 
using namespace std;
 
class Line {
   public:
      double length;
      void setLength( double len );
      double getLength( void );
};
 
// Member functions definitions
double Line::getLength(void) {
   return length ;
}
 
void Line::setLength( double len) {
   length = len;
}
 
// Main function for the program
int main() {
   Line line;
 
   // set line length
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   // set line length without member function
   line.length = 10.0; // OK: because length is public
   cout << "Length of line : " << line.length <<endl;
   
   return 0;
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Length of line : 6
Length of line : 10

I membri privati

UN privatenon è possibile accedere alla variabile membro o alla funzione, o anche visualizzarla dall'esterno della classe. Solo le funzioni di classe e di amicizia possono accedere ai membri privati.

Per impostazione predefinita, tutti i membri di una classe sarebbero privati, ad esempio nella classe seguente width è un membro privato, il che significa che finché non etichetti un membro, verrà considerato un membro privato -

class Box {
   double width;
   
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );
};

In pratica, definiamo i dati nella sezione privata e le relative funzioni nella sezione pubblica in modo che possano essere richiamati dall'esterno della classe come mostrato nel programma seguente.

#include <iostream>
 
using namespace std;
 
class Box {
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );
 
   private:
      double width;
};
 
// Member functions definitions
double Box::getWidth(void) {
   return width ;
}
 
void Box::setWidth( double wid ) {
   width = wid;
}
 
// Main function for the program
int main() {
   Box box;
 
   // set box length without member function
   box.length = 10.0; // OK: because length is public
   cout << "Length of box : " << box.length <<endl;
 
   // set box width without member function
   // box.width = 10.0; // Error: because width is private
   box.setWidth(10.0);  // Use member function to set it.
   cout << "Width of box : " << box.getWidth() <<endl;
 
   return 0;
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Length of box : 10
Width of box : 10

I membri protetti

UN protected La variabile o la funzione membro è molto simile a un membro privato, ma ha fornito un ulteriore vantaggio che è possibile accedervi nelle classi figlie chiamate classi derivate.

Imparerai le classi derivate e l'ereditarietà nel prossimo capitolo. Per ora puoi controllare il seguente esempio in cui ho derivato una classe figlioSmallBox da una classe genitore Box.

L'esempio seguente è simile all'esempio precedente e qui width membro sarà accessibile da qualsiasi funzione membro della sua classe derivata SmallBox.

#include <iostream>
using namespace std;
 
class Box {
   protected:
      double width;
};
 
class SmallBox:Box { // SmallBox is the derived class.
   public:
      void setSmallWidth( double wid );
      double getSmallWidth( void );
};
 
// Member functions of child class
double SmallBox::getSmallWidth(void) {
   return width ;
}
 
void SmallBox::setSmallWidth( double wid ) {
   width = wid;
}
 
// Main function for the program
int main() {
   SmallBox box;
 
   // set box width using member function
   box.setSmallWidth(5.0);
   cout << "Width of box : "<< box.getSmallWidth() << endl;
 
   return 0;
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Width of box : 5