Acesse membros privados de uma classe em C++

1. Use o especificador de acesso private para encapsular membros da classe em C++
2. Use funções public para recuperar membros privados de uma classe em C++

Este artigo explicará vários métodos de como acessar membros privados de uma classe em C++.

Use o especificador de acesso private para encapsular membros da classe em C++

Os especificadores de acesso são empregados para implementar um recurso central da programação orientada a objetos - chamado encapsulamento. Como resultado, restringimos o acesso direto a membros de dados específicos da classe e, essencialmente, construímos uma interface para operar nos dados da classe. O C++ fornece várias palavras-chave especificadoras de acesso como: public, private e protected, que geralmente precedem os membros da classe que precisam ser qualificados com a acessibilidade correspondente.

Os membros definidos após o especificador private são acessíveis apenas às funções de membro e não podem ser referenciados diretamente a partir do código que usa a classe. Uma classe é geralmente construída com dois lados em mente - o designer da classe e o usuário da classe. O último geralmente é aquele que é afetado pelo encapsulamento. Se o programador definir membros antes do primeiro especificador de acesso, sua acessibilidade é, por padrão, definida como private quando a palavra-chave class é usada, e public na palavra-chave struct.

No exemplo a seguir, implementamos uma classe chamada BaseClass com dois membros de dados de string declarados como private, portanto, para acessar os valores desses membros, o designer da classe deve incluir funções public que os recuperam. Observe que podemos remover a palavra-chave public do código abaixo e ainda ter as funções getUsername e getName como membros public.

Outra vantagem do encapsulamento é a flexibilidade de modificar a estrutura da classe interna sem se preocupar com os problemas de compatibilidade do lado do usuário. Enquanto a interface, portanto, as funções públicas não mudarem, o usuário da classe não precisa modificar seu código.

#include <iostream>
#include <string>
#include <utility>
#include <vector>

using std::cout;
using std::endl;
using std::string;
using std::vector;

class BaseClass {
 public:
  BaseClass() = default;
  explicit BaseClass(string user, string nm)
      : username(std::move(user)), name(std::move(nm)) {}

  ~BaseClass() = default;

  string& getUsername() { return username; };
  string& getName() { return name; };

 private:
  string username;
  string name;
};

int main() {
  BaseClass base("buddy", "Buddy Bean");

  cout << "base -> name: " << base.getName() << endl;
  cout << "base -> username: " << base.getUsername() << endl;

  exit(EXIT_SUCCESS);
}

Resultado:

base -> name: Buddy Bean
base -> username: buddy

Use funções public para recuperar membros privados de uma classe em C++

Os membros private podem modificados usando as funções de interface de classe, por exemplo, a função changeUsername pega o argumento string do usuário da classe e armazena seu valor no membro private - username. Observe que também existe uma palavra-chave friend que distingue outras classes e funções com permissão para acessar os membros private da classe. Essas funções podem ser externas, não fazendo parte da classe mencionada acima. Lembre-se, porém, de que o uso incorreto de especificadores de acesso provavelmente resulta em erros do compilador.

#include <iostream>
#include <string>
#include <utility>
#include <vector>

using std::cout;
using std::endl;
using std::string;
using std::vector;

class BaseClass {
 public:
  BaseClass() = default;
  explicit BaseClass(string user, string nm)
      : username(std::move(user)), name(std::move(nm)) {}

  ~BaseClass() = default;

  void changeUsername(const string& s) { username.assign(s); };

  string& getUsername() { return username; };
  string& getName() { return name; };

 private:
  string username;
  string name;
};

int main() {
  BaseClass base("buddy", "Buddy Bean");

  cout << "base -> name: " << base.getName() << endl;
  cout << "base -> username: " << base.getUsername() << endl;
  base.changeUsername("jolly");
  cout << "base -> username: " << base.getUsername() << endl;

  exit(EXIT_SUCCESS);
}

Resultado:

base -> name: Buddy Bean
base -> username: buddy
base -> username: jolly