Modificadores de acesso em C++
Modificadores de acesso são usados para gerenciar a acessibilidade e a visibilidade dos dados de uma classe. Eles definem algumas restrições aos membros de dados para que não possam ser acessados por funções externas. Os modificadores de acesso são de três tipos em C++:
Modificador de acesso público em C++
Todos os membros da classe declarados sob a palavra-chave public estarão disponíveis para todas as funções fora da classe dentro do programa. O operador de acesso direto ao membro (.), também conhecido como operador ponto, pode ser usado com o objeto dessa classe específica para acessar esses membros de dados.
Exemplo
O modificador de acesso público é usado para declarar uma classe, e seus membros de dados são acessados por outras funções do programa.
#include
#include
#include
usando namespace std ;
classe Triângulo
{
público :
flutuador x , e , Com ;
vazio entrada ( )
{
corte << 'Insira o lado x de um triângulo:-' ;
comendo >> x ;
corte << 'Insira o lado y de um triângulo:-' ;
comendo >> e ;
corte << 'Insira o lado z de um triângulo:-' ;
comendo >> Com ;
}
vazio Área ( )
{
flutuador é = ( x + e + Com ) / 2 ;
flutuador área = quadrado ( é * ( é - x ) * ( é - e ) * ( é - Com ) ) ;
corte << ' \n Área do Triângulo = ' << área ;
}
} ;
interno principal ( )
{
Triângulo t1 ;
t1. entrada ( ) ;
t1. Área ( ) ;
retornar 0 ;
}
O Triângulo é definido como a classe e seus parâmetros estão sob a palavra-chave pública. Em seguida, a área do triângulo é calculada fora desta classe acessando os membros de dados do modificador público.
Os três lados do triângulo são inseridos pelo usuário e a área do triângulo é calculada acessando os valores fora da classe, utilizando a fórmula padrão, que é 13,4164.
Modificador de acesso privado em C++
Todos os membros da classe declarados sob a palavra-chave private não estarão disponíveis para nenhuma função fora da classe no programa. Esses membros privados só podem ser lidos pelos membros diretos da mesma classe. No entanto, funções e classes de amigos também podem acessar os dados.
Exemplo
As duas classes pública e privada são declaradas, e o valor de retorno do programa será a área do triângulo.
#include#include
#include
usando namespace std ;
classe Triângulo
{
privado :
flutuador x , e , Com ;
público :
vazio entrada ( )
{
corte << 'Insira o lado x de um triângulo:-' ;
comendo >> x ;
corte << 'Insira o lado y de um triângulo:-' ;
comendo >> e ;
corte << 'Insira o lado z de um triângulo:-' ;
comendo >> Com ;
}
vazio Área ( )
{
flutuador é = ( x + e + Com ) / 2 ;
flutuador área = quadrado ( é * ( é - x ) * ( é - e ) * ( é - Com ) ) ;
corte << ' \n Área do Triângulo = ' << área ;
}
} ;
interno principal ( )
{
Triângulo t1 ;
t1. entrada ( ) ;
t1. Área ( ) ;
retornar 0 ;
}
Em main(), o objeto t1 não pode acessar diretamente a variável de classe privada float x, y e z, portanto só pode ser manipulado indiretamente através da função pública input(), pois esta função obtém os valores de x, y e z.
A área do triângulo é obtida acessando a classe privada através da manipulação dela através da classe pública. Se os valores de x, y e z não forem declarados na classe pública, então eles não serão acessados em main() para cálculos.
Modificador de acesso protegido em C++
Os membros e funções sob a palavra-chave protected são protegidos e só podem ser acessados dentro da classe e da classe derivada. O restante das classes não pode acessar seus dados. Eles são altamente protegidos.
Exemplo
Os dados protegidos sob a palavra-chave protected só podem ser lidos dentro da classe e pela classe que é a classe derivada. Este exemplo é a demonstração prática do modificador de acesso protegido.
#include#include
#include
usando namespace std ;
//classe pai
classe Triângulo
{
protegido :
flutuador x , e , Com ;
} ;
//classe filha
classe TriânguloCriança : Triângulo público {
público :
vazio entrada ( )
{
corte << 'Insira o lado x de um triângulo:-' ;
comendo >> x ;
corte << 'Insira o lado y de um triângulo:-' ;
comendo >> e ;
corte << 'Insira o lado z de um triângulo:-' ;
comendo >> Com ;
}
vazio Área ( )
{
flutuador é = ( x + e + Com ) / 2 ;
flutuador área = quadrado ( é * ( é - x ) * ( é - e ) * ( é - Com ) ) ;
corte << ' \n Área do Triângulo = ' << área ;
}
} ;
interno principal ( )
{
TriânguloCriança Criança ;
Criança. entrada ( ) ;
Criança. Área ( ) ;
retornar 0 ;
}
TriangleChild é uma classe herdada derivada da classe Triangle. As variáveis x, y e z são declaradas em Triângulo com a palavra-chave protegida. Isso significa que essas variáveis são protegidas, mas podem ser acessadas pelo TriangleChild, já que Triangle é sua classe pai. Os valores das variáveis foram atribuídos em TriangleChild mesmo que sejam declarados na classe Triangle.
As variáveis são acessadas através da classe filha e então a área de um triângulo é calculada.
Conclusão
A ocultação de dados evita o acesso indesejado externo aos dados de uma classe. Modificadores de acesso são usados para gerenciar a acessibilidade e a visibilidade dos dados em um programa. Modificadores de acesso privado, protegido e público são usados para ocultar os dados. Os dados sob a palavra-chave public também podem ser lidos pelas funções de fora da classe. Os dados declarados como privados só podem ser lidos dentro da classe, enquanto os dados protegidos também podem ser acessados pela classe pai e pela classe filha.