Modificadores de acesso de classe C ++

A ocultação de dados é uma das características importantes da Programação Orientada a Objetos que permite evitar que as funções de um programa acessem diretamente a representação interna de um tipo de classe. A restrição de acesso aos membros da classe é especificada pelo rotuladopublic, private, e protectedseções dentro do corpo da classe. As palavras-chave public, private e protected são chamadas de especificadores de acesso.

Uma classe pode ter várias seções rotuladas públicas, protegidas ou privadas. Cada seção permanece em vigor até que outro rótulo de seção ou a chave direita de fechamento do corpo da classe seja vista. O acesso padrão para membros e classes é privado.

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

Os membros públicos

UMA publicmembro pode ser acessado de qualquer lugar fora da classe, mas dentro de um programa. Você pode definir e obter o valor de variáveis públicas sem qualquer função de membro, conforme mostrado no exemplo a seguir -

#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 o código acima é compilado e executado, ele produz o seguinte resultado -

Length of line : 6
Length of line : 10

Os membros privados

UMA privatea variável ou função de membro não pode ser acessada ou mesmo visualizada de fora da classe. Apenas as funções de classe e amigo podem acessar membros privados.

Por padrão, todos os membros de uma classe seriam privados, por exemplo, na seguinte classe width é um membro privado, o que significa que até você rotular um membro, ele será considerado um membro privado -

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

Na prática, definimos dados na seção privada e funções relacionadas na seção pública para que possam ser chamados de fora da classe, conforme mostrado no programa a seguir.

#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 o código acima é compilado e executado, ele produz o seguinte resultado -

Length of box : 10
Width of box : 10

Os membros protegidos

UMA protected a variável de membro ou função é muito semelhante a um membro privado, mas forneceu um benefício adicional que eles podem ser acessados em classes filhas que são chamadas de classes derivadas.

Você aprenderá classes derivadas e herança no próximo capítulo. Por enquanto, você pode verificar o exemplo a seguir, onde deduzi uma classe filhaSmallBox de uma classe de pais Box.

O exemplo a seguir é semelhante ao exemplo acima e aqui width membro estará acessível por qualquer função de membro de sua classe 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;
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Width of box : 5

↰ Previous page