Modificateurs d'accès aux classes C ++

Le masquage des données est l'une des caractéristiques importantes de la programmation orientée objet qui permet d'empêcher les fonctions d'un programme d'accéder directement à la représentation interne d'un type de classe. La restriction d'accès aux membres de la classe est spécifiée par le libellépublic, private, et protectedsections dans le corps de la classe. Les mots-clés public, private et protected sont appelés spécificateurs d'accès.

Une classe peut avoir plusieurs sections étiquetées publiques, protégées ou privées. Chaque section reste en vigueur jusqu'à ce qu'une autre étiquette de section ou l'accolade droite de fermeture du corps de classe soit vue. L'accès par défaut pour les membres et les classes est privé.

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

Les membres du public

UNE publicLe membre est accessible de n'importe où en dehors de la classe mais dans un programme. Vous pouvez définir et obtenir la valeur des variables publiques sans aucune fonction membre, comme indiqué dans l'exemple suivant -

#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;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Length of line : 6
Length of line : 10

Les membres privés

UNE privateLa variable membre ou la fonction ne sont pas accessibles, ni même vues de l'extérieur de la classe. Seules les fonctions de classe et d'amis peuvent accéder aux membres privés.

Par défaut, tous les membres d'une classe seraient privés, par exemple dans la classe suivante width est un membre privé, ce qui signifie que jusqu'à ce que vous étiquetiez un membre, il sera considéré comme un membre privé -

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

En pratique, nous définissons les données dans la section privée et les fonctions associées dans la section publique afin qu'elles puissent être appelées de l'extérieur de la classe comme indiqué dans le programme suivant.

#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;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Length of box : 10
Width of box : 10

Les membres protégés

UNE protected La variable ou la fonction membre est très similaire à un membre privé, mais elle a fourni un avantage supplémentaire en ce qu'elle peut être accédée dans les classes enfants appelées classes dérivées.

Vous apprendrez les classes dérivées et l'héritage dans le chapitre suivant. Pour l'instant, vous pouvez vérifier l'exemple suivant où j'ai dérivé une classe enfantSmallBox d'une classe parent Box.

L'exemple suivant est similaire à l'exemple ci-dessus et ici width member sera accessible par n'importe quelle fonction membre de sa classe dérivée 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;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Width of box : 5