Modificadores de acceso a clases C ++

La ocultación de datos es una de las características importantes de la Programación Orientada a Objetos que permite evitar que las funciones de un programa accedan directamente a la representación interna de un tipo de clase. La restricción de acceso a los miembros de la clase está especificada por la etiquetapublic, private, y protectedsecciones dentro del cuerpo de la clase. Las palabras clave público, privado y protegido se denominan especificadores de acceso.

Una clase puede tener varias secciones etiquetadas públicas, protegidas o privadas. Cada sección permanece en efecto hasta que se ve otra etiqueta de sección o la llave de cierre derecha del cuerpo de la clase. El acceso predeterminado para miembros y clases es privado.

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

Los miembros públicos

UNA publicmiembro es accesible desde cualquier lugar fuera de la clase pero dentro de un programa. Puede establecer y obtener el valor de las variables públicas sin ninguna función miembro, como se muestra en el siguiente ejemplo:

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

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Length of line : 6
Length of line : 10

Los miembros privados

UNA privateno se puede acceder a la variable miembro o función, ni siquiera se puede ver desde fuera de la clase. Solo las funciones de clase y amigo pueden acceder a miembros privados.

Por defecto, todos los miembros de una clase serían privados, por ejemplo en la siguiente clase width es un miembro privado, lo que significa que hasta que etiquete un miembro, se asumirá que es un miembro privado -

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

Prácticamente, definimos datos en la sección privada y funciones relacionadas en la sección pública para que puedan ser llamados desde fuera de la clase como se muestra en el siguiente programa.

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

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Length of box : 10
Width of box : 10

Los miembros protegidos

UNA protected La variable o función miembro es muy similar a un miembro privado, pero proporcionó un beneficio adicional de que se puede acceder a ellas en clases secundarias que se denominan clases derivadas.

Aprenderá las clases derivadas y la herencia en el próximo capítulo. Por ahora, puede consultar el siguiente ejemplo donde he derivado una clase secundariaSmallBox de una clase para padres Box.

El siguiente ejemplo es similar al ejemplo anterior y aquí width miembro será accesible por cualquier función miembro de su clase derivada 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;
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Width of box : 5

↰ Previous page