Usar Membros da Classe Privada vs Classe Protegida em C++
-
Utilizar a propriedade
private
para designar os membros da classe inacessível aos utilizadores da classe em C++ -
Utilize a propriedade
protected
para designar os membros da classe Acessível às funções de membro de classe derivada ou classe amiga
Este artigo irá demonstrar múltiplos métodos sobre como utilizar correctamente os membros da classe private
versus protected
em C++.
Utilizar a propriedade private
para designar os membros da classe inacessível aos utilizadores da classe em C++
A palavra-chave private
é uma das partes fundamentais da linguagem C++ para implementar características de encapsulamento. O principal objectivo do encapsulamento é criar uma interface reforçada para os utilizadores da classe e restringir o acesso directo apenas a membros específicos. Note-se que a definição da interface de classe implica que o utilizador da classe não precisa de modificar ou aceder directamente aos membros dos dados, mas sim de chamar métodos públicos que são concebidos para fazer estas operações sobre os objectos em questão.
Existem geralmente três palavras-chave para controlo de acesso: public
, private
, e protected
. Os membros definidos após a propriedade public
são acessíveis a todos os utilizadores da classe. Por outro lado, o especificador private
define os membros que só podem ser acedidos pelas funções de membro da classe. No exemplo seguinte, o código da função main
pode declarar uma variável do tipo CustomString
, mas para aceder ao seu membro str
o código precisa de chamar o método getString
, definido como propriedade public
.
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using std::cout;
using std::endl;
using std::string;
using std::vector;
class CustomString {
public:
CustomString() = default;
explicit CustomString(const string& s) : str(s) { num = s.size(); }
virtual ~CustomString() = default;
string& getString() { return str; };
private:
string str;
protected:
int num{};
};
int main() {
CustomString str1("Hello There 1");
cout << "str1: " << str1.getString() << endl;
exit(EXIT_SUCCESS);
}
Resultado:
str1: Hello There 1
Utilize a propriedade protected
para designar os membros da classe Acessível às funções de membro de classe derivada ou classe amiga
Outra palavra-chave disponível para o controlo de acesso é uma propriedade protected
que torna os membros declarados depois de acessíveis às funções de membro de classe, membros de classe derivados, e mesmo classes amigas. Note-se que os dois últimos não podem aceder aos membros protected
directamente a partir do objecto da classe base, mas sim a partir do objecto da classe derivada. O exemplo seguinte demonstra a classe CustomSentence
que deriva do objecto CustomString
, mas o membro num
desta última classe é um membro protected
. Assim, não pode ser acedido a partir do objecto CustomString
. Nomeadamente, a função getSize
não faz parte da classe CustomString
, e apenas os objectos CustomSentence
podem recuperar o valor do num
chamando o método.
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using std::cout;
using std::endl;
using std::string;
using std::vector;
class CustomString {
public:
CustomString() = default;
explicit CustomString(const string& s) : str(s) { num = s.size(); }
virtual ~CustomString() = default;
string& getString() { return str; };
private:
string str;
protected:
int num{};
};
class CustomSentence : public CustomString {
public:
CustomSentence() = default;
explicit CustomSentence(const string& s) : sent(s) { num = s.size(); }
~CustomSentence() override = default;
int getSize() const { return num; };
string& getSentence() { return sent; };
private:
string sent;
};
int main() {
CustomString str1("Hello There 1");
CustomSentence sent1("Hello There 2");
cout << "str1: " << str1.getString() << endl;
cout << "sent1: " << sent1.getSentence() << endl;
cout << "size: " << sent1.getSize() << endl;
exit(EXIT_SUCCESS);
}
Resultado:
str1: Hello There 1
sent1: Hello There 2
size: 13
Founder of DelftStack.com. Jinku has worked in the robotics and automotive industries for over 8 years. He sharpened his coding skills when he needed to do the automatic testing, data collection from remote servers and report creation from the endurance test. He is from an electrical/electronics engineering background but has expanded his interest to embedded electronics, embedded programming and front-/back-end programming.
LinkedIn Facebook