Introdução aos modificadores de acesso em C ++
A proteção de dados está em tendência há muito tempo, pois é a parte mais importante de todos os domínios. Se for na mão errada, você sofrerá muito. Para manipular seus dados de maneira sistemática, a programação orientada a objetos oferece um recurso importante conhecido como Ocultamento de dados. Esse conceito pode ser implementado em C ++ usando modificadores de acesso. São palavras-chave usadas para definir a acessibilidade de métodos, classes e outros membros. Público, Privado e Protegido é conhecido como Modificadores de Acesso ou Especificadores de Acesso em linguagens de programação orientadas a objetos. Para impedir que as funções de um programa acessem diretamente a representação interna de uma classe, oculta-se os dados.
Tipos de modificadores de acesso em C ++
Existem 3 tipos de modificadores de acesso em C ++
- Público
- Privado
- Protegido
Vamos dar uma olhada nesses modificadores com exemplos:
1. Público
Como o nome sugere, disponível para todos. Todos os membros da classe estarão disponíveis para todos depois de declarados como públicos. Um membro público pode ser acessado em qualquer lugar fora da classe, mas dentro de um programa. Os membros de dados também podem ser acessados por outras classes, se declarados públicos. Como não há restrições no modificador público, podemos usar o operador de ponto (.) Para acessar diretamente funções e dados de membros.
Código:
#include
using namespace std;
class parent
(
private:
int p;
protected:
int q;
public:
int r;
parent() //constructor to initialize data members
(
p = 100;
q = 200;
r = 300;
)
);
//Inheritance concept
class child: public parent
(
//q becomes protected and r becomes public members of class child
public:
void showdata()
(
cout << "p is not accessible" << endl;
cout << "value of q is " << q << endl;
cout << "value of r is " << r << endl;
)
);
int main()
(
child c; //object of derived class(child)
c.showdata();
//cp = 100; invalid : private member, no access
//cq = 200; invalid : q is now private member of child class
//cr = 300; invalid : r is also now a private member of child class
return 0;
)
Resultado:
2. Privado
Um modificador privado é um dos melhores modificadores de acesso em C ++. O escopo dos membros de dados privados permanece dentro da classe, por isso a função dentro da classe pode acessar os membros da classe declarados como privados. Porque é isso que privado significa que apenas você decide quem pode usar suas coisas (como um amigo) ou não. Você não pode acessar membros diretamente por qualquer objeto ou função que esteja fora da classe. A função de um amigo (como eu disse pode usar suas coisas) pode ser usada para acessar os membros de dados privados da classe. Você receberá um erro em tempo de compilação ao acessar membros de dados privados de qualquer lugar fora da classe.
Código:
#include
using namespace std;
// Defining class
class Circle
( // private data member
private:
double radius;
// public member function
public:
void areaOfCircle(double r)
( // member function can access private
// data member radius
radius = r;
double area = 3.14*radius*radius;
cout << "Radius is: " << radius << endl;
cout << "Area is: " << area;
) );
// Main function
int main()
( // creating class object
Circle c;
/* trying to access private data member
directly outside the class */
c.areaOfCircle(4.5);
return 0;
)
Resultado:
Usando o código acima, podemos acessar membros de dados privados de uma classe indiretamente, usando as funções de membro públicas da classe indiretamente.
3. Protegido
O último especificador de acesso mais importante usado como Modificadores de Acesso em C ++, pois seu comportamento é bastante semelhante a um modificador de acesso privado. Membros ou funções de dados protegidos não podem ser acessados diretamente de outras classes. Você pode usar uma função de amigo para acessar membros protegidos, pois permite essa funcionalidade. Existem algumas restrições no modificador protegido. Membros declarados em protegido só podem ser protegidos até o próximo nível e depois se tornar privado.
Código:
#include
using namespace std;
// Base class
class Parent
( // Protected data members
protected:
int id_protect;
);
// Derived class
class Child : public Parent
( public:
void set(int id)
( /* Child class to access the inherited protected data
members of the Base class */
id_protect = id;
)
void display() (
cout << "id_protect is: " << id_protect << endl;
)
);
// Main function
int main() (
Child p;
/* member function(derived class) can easily
access the data members(protected) of the base class */
p.set(07);
p.display();
return 0;
)
Resultado:
No código acima, você pode ver que id_protect é declarado como protegido e pode ser acessado usando a função de membro da classe derivada. Isso significa que você pode acessar o membro de dados protegido da classe base usando a função de membro da classe derivada.
Vantagens dos modificadores de acesso em C ++
Abaixo estão as diferentes vantagens dos Modificadores de Acesso em C ++:
- O modificador de acesso fornece a autoridade para controlar seus dados, dependendo dos cenários. Se você estiver trabalhando em um domínio bancário, precisará usar membros de dados privados para manter seus dados ocultos de outros usuários, a autoridade está na sua mão. Você pode torná-los públicos, se quiser, mas não será uma ótima abordagem, pois, nesse caso, qualquer pessoa poderá alterar seus dados a qualquer momento
- Todo membro público da classe base se torna membro público da classe derivada. Da mesma forma, todo membro protegido da classe base se torna membro protegido da classe derivada, o que o ajudará a gerenciar dados com facilidade em todos os aspectos, porque, como você pode ver, não há alterações no acesso a esses membros se você usar herança pública na sua linguagem de programação. .
- No cenário de herança privada, todos os membros públicos da classe base se tornam membros privados da classe derivada. Da mesma maneira, todo membro protegido da classe base se torna membro privado da classe derivada, enquanto que, no cenário de herança protegida, todo membro público da classe base se torna membro protegido da classe derivada e todo membro protegido da classe base se torna membro protegido da classe derivada. Observe que, em C ++, a especificação de acesso funciona em uma base por classe, não por objeto.
Conclusão
Várias linguagens de programação não têm acesso privado e protegido; portanto, qualquer usuário pode usá-lo da maneira que desejar. Os codificadores C ++ não confiam nos usuários e, portanto, não têm permissão para usá-los. Como membros de dados públicos, pode haver um sério risco potencial para bugs ou hackers.
Artigos recomendados
Este é um guia para Modificadores de Acesso em C ++. Aqui discutimos os tipos de modificadores de acesso em C ++, juntamente com seus exemplos e algumas vantagens. Você também pode consultar os seguintes artigos para saber mais:
- Modificadores de acesso em Java
- Encapsulamento em C ++
- Comandos C ++
- Melhor compilador C ++
- Tipos de modificadores de acesso em c #
- Encapsulamento em JavaScript
- Os 11 principais recursos e vantagens do C ++