Especificadores de acesso C ++

C Access Specifiers



Em C ++, uma classe é um conjunto de variáveis ​​e funções que foram configuradas para funcionarem juntas. Quando as variáveis ​​da classe recebem valores, um objeto é obtido. Um objeto possui as mesmas variáveis ​​e funções que uma classe, mas, desta vez, as variáveis ​​possuem valores. Muitos objetos podem ser criados a partir de uma classe. Um objeto difere de outro objeto de acordo com o conjunto diferente de valores atribuídos às variáveis ​​do outro objeto. A criação de um objeto a partir de uma classe é considerada uma instância do objeto. Mesmo que dois objetos diferentes tenham os mesmos valores para suas variáveis, esses objetos são entidades diferentes, identificadas por nomes diferentes no programa. As variáveis ​​de um objeto e sua classe correspondente são chamadas de membros de dados. As funções de um objeto e sua classe correspondente são chamadas de funções-membro. Membros de dados e funções de membro são chamados de membros.

A palavra acesso significa ler ou alterar o valor de uma variável e também significa usar uma função. Os especificadores de acesso C ++ são as palavras, privado, protegido e público. Eles decidem se um membro pode acessar outros membros de sua classe ou se uma função ou operador fora da classe e não pertencente à classe pode acessar qualquer membro da classe. Eles também decidem se um membro de uma classe derivada (filha) pode acessar um membro de uma classe pai.







É necessário conhecimento básico de C ++ para entender este artigo e testar o código fornecido.



Conteúdo do Artigo

Os especificadores públicos e privados

Classe
Qualquer membro de uma classe pode acessar qualquer outro membro da mesma classe, independentemente de ser rotulado como público ou privado. Considere o seguinte programa:



#incluir
usando namespacehoras;

classeTheCla
{
privado:
intnum1;
intnum2;
público:
TheCla(intn1,intn2)
{
num1=n1;num2=n2;
}
intmétodo()
{
Retornanum1;
}
};

inta Principal()
{
TheCla obj(10,vinte);
intno2=obj.método();
custo<<no2<<' n';

// int no1 = obj.num1;

Retorna 0;
}

A saída é 10. Os membros privados são num1 e num2. Os membros públicos são TheCla () e method (). Observe que TheCla () é a função construtora que inicializa as variáveis ​​de interesse. A região de um especificador de acesso começa a partir de seu rótulo até o final da descrição da classe (definição) ou até o início de outro especificador de acesso.





Na função main (), a primeira instrução é a instanciação envolvendo a função construtora, que inicializa num1 e num2. A próxima instrução chama o membro público, method (), da classe.

Agora, na descrição da classe (definição), a função de membro público, TheCla (), acessa os membros privados, num1 e num2. Além disso, a função de membro público, method (), acessa o membro privado, num1. Qualquer membro dentro de uma descrição de classe pode acessar qualquer outro membro dentro da mesma descrição de classe; não importa qual membro é privado ou público.



No entanto, uma função ou operador não declarado na descrição da classe e fora da descrição da classe pode acessar apenas membros públicos da classe. A função main (), por exemplo, é uma função declarada fora da descrição da classe. Ele foi capaz de acessar apenas os membros públicos method () e TheCla (). Dentro da função main (), a função TheCla () é obj (10, 20).

Uma função externa ou operador externo, como a função main (), não pode acessar nenhum dos membros privados da classe, como num1 ou num2. Remova o indicador de comentário, //, da penúltima declaração em main (). Se você tentar compilar o programa, observe que o programa não será compilado, apresentando uma mensagem de erro.

Especificador Padrão
O especificador padrão para uma classe é privado. Portanto, a descrição da classe acima é igual à seguinte, privada, mas sem o especificador:

classeTheCla
{
intnum1;
intnum2;
público:
TheCla(intn1,intn2)
{
num1=n1;num2=n2;
}
intmétodo()
{
Retornanum1;
}
};

Observação : o rótulo do especificador de acesso começa com o especificador e é seguido por dois pontos.

O especificador protegido

Dentro de uma descrição de classe e de uma função externa ou operador externo, o especificador protegido é o mesmo que o especificador privado. Agora, substitua o especificador privado no programa acima pelo especificador, proteja e remova o indicador de comentário, //, da penúltima instrução na função main (). Se você tentar compilar o programa, observe que o programa não será compilado, apresentando uma mensagem de erro.

O problema do especificador protegido surge quando os membros da classe derivada (herdada) devem acessar os membros da classe base (pai).

Classe Derivada Pública com membros públicos
Considere o seguinte programa:

#incluir
usando namespacehoras;

classeTheCla
{
público:
intnum1= 10;
protegido:
intnum2= vinte;
privado:
intnum3= 30;
};

classeChildCla: públicoTheCla
{
público:
intMétodo 1()
{
Retornanum1;
}
intmétodo 2()
{
Retornanum2;
}
/ * int method3 ()
{
return num3;
} * /

};

inta Principal()
{
ChildCla childObj;
intno1=childObj.Método 1();
custo<<no1<<' n';

intno2=childObj.método 2();
custo<<no2<<' n';

Retorna 0;
}

A saída é:
10
vinte

Na classe base, num1 é público, num2 é protegido e num3 é privado. Na classe derivada, todas as funções de membro são públicas. A primeira função, method1 (), acessa o membro de dados públicos, num1. A segunda função, method2 (), acessa o membro de dados protegido, num2. A terceira função, method3 (), embora atualmente comentado, deve acessar o membro de dados privado, num3.

Uma classe derivada não é declarada sem um especificador de acesso (público, protegido ou privado). Acima, a classe derivada é declarada com o especificador público, ou seja:

classeChildCla: públicoTheCla{}

Agora remova o comentário da terceira definição de função de membro na classe derivada. Se você tentar compilar o programa, observe que ele não será compilado, apresentando uma mensagem de erro.

Observação : Quando toda a classe derivada é declarada pública, seus membros não podem acessar os membros privados da classe base. Seus membros podem, no entanto, acessar os membros públicos e protegidos da classe base. O programa acima ilustra isso.

No entanto, observe que um membro público da classe derivada pública pode acessar um membro protegido da classe base.

Especificadores de classe derivados e especificadores de membro

Classe derivada protegida com membros públicos
Substitua o especificador público por protegido na declaração da classe derivada acima, da seguinte maneira:

classeChildCla: protegidoTheCla{}

Compile e execute o programa e observe que o resultado é o mesmo de antes.

Portanto, quando toda a classe derivada é declarada protegida, seus membros não podem acessar os membros privados da classe base. Seus membros podem, no entanto, acessar os membros públicos e protegidos da classe base. É o mesmo que quando a classe derivada é declarada pública.

Observação : um membro protegido da classe derivada pública pode acessar um membro protegido da classe base.

Classe derivada privada com membros públicos
Substitua o especificador protegido por privado na declaração da classe derivada acima, da seguinte maneira:

classeChildCla: privadoTheCla{}

Compile e execute o programa e observe que o resultado é o mesmo de antes.

Portanto, quando toda a classe derivada é declarada privada, seus membros não podem acessar os membros privados da classe base. Seus membros podem, no entanto, acessar os membros públicos e protegidos da classe base. É o mesmo que quando a classe derivada é declarada protegida ou pública.

Classe derivada pública com membros protegidos
Digite, compile e execute o programa a seguir, no qual toda a classe derivada está protegida e seus membros também estão protegidos. Alguns segmentos de código são os seguintes:

#incluir
usando namespacehoras;

classeTheCla
{
público:
intnum1= 10;
protegido:
intnum2= vinte;
privado:
intnum3= 30;
};

classeChildCla: públicoTheCla
{
protegido:
intMétodo 1()
{
Retornanum1;
}
intmétodo 2()
{
Retornanum2;
}
/ * int method3 ()
{
return num3;
} * /

};

inta Principal()
{
/ * ChildCla childObj;
int no1 = childObj.method1 ();
custo<
/ * int no2 = childObj.method2 ();
custo<
Retorna 0;
}

O programa funciona como está. Não há saída e não deveria haver nenhuma saída, com base em como o programa foi digitado.

Agora, descomente a definição da função, method3 (), na classe derivada. Se você tentar compilar o programa, observe que ele não será compilado, apresentando uma mensagem de erro. Isso significa que um membro privado não pode ser acessado de uma função externa, operador externo ou classe derivada. Esta é a mesma conclusão que foi concluída acima, no que diz respeito ao acesso a um membro privado.

Observação : um membro protegido da classe derivada protegida pode acessar um membro protegido da classe base.

Agora, coloque os comentários de volta na classe derivada e descomente o primeiro segmento de código na função main (). Se você tentar compilar o programa, observe que o programa não será compilado por causa do primeiro segmento de código na função main (). Este efeito não é novo. Além da classe derivada, funções externas e operadores externos, os membros protegidos e privados de uma classe (base ou derivada) são do mesmo especificador, privado. A função main () vê o membro protegido de qualquer classe, seja base ou derivada, como do mesmo especificador, privado, e é proibida de acessá-lo.

Se o segundo segmento de código da função main () não for comentado, a mesma explicação se aplicará. Ou seja, a função main () não poderá acessar um membro protegido ou privado da classe derivada ou da classe base. Isso é independente do fato de um membro protegido da classe derivada poder acessar um membro protegido da classe base.

Classe derivada protegida com membros protegidos
Substitua o especificador público por protegido na declaração da classe derivada acima, da seguinte maneira:

classeChildCla: protegidoTheCla{}

Coloque o comentário dos segmentos de código de volta na função main (), se isso ainda não tiver sido feito. Compile e execute o programa e observe que o resultado é o mesmo.

Classe derivada privada com membros protegidos
Substitua o especificador protegido por privado na declaração da classe derivada acima, da seguinte maneira:

classeChildCla: privadoTheCla

Compile e execute o programa e observe que o resultado será o mesmo.

Classe derivada pública com membros privados
Substitua o especificador privado por público na declaração da classe derivada acima, da seguinte maneira:

classeChildCla: públicoTheCla{}

Torne os membros da classe derivada privados. Compile e rode o programa. O resultado não é diferente do caso Classe Derivada Pública com Membros Protegidos.

Classe derivada protegida com membros privados
Substitua o especificador público por protegido na declaração da classe derivada acima, da seguinte maneira:

classeChildCla: protegidoTheCla{}

Compile e rode o programa. Este resultado não é diferente do caso Classe Derivada Protegida com Membros Protegidos.

Classe derivada privada com membros privados
Substitua o especificador protegido por privado na declaração da classe derivada acima, da seguinte maneira:

classeChildCla: privadoTheCla{}

Compile e rode o programa. Este resultado não é diferente do caso Classe Derivada Privada com Membros Protegidos.

Conclusão

Os especificadores de acesso C ++ são as palavras privado, protegido e público. Eles decidem o acesso dos membros de uma classe. A região de um especificador de acesso começa a partir de seu rótulo, até o final da descrição da classe (definição) ou até o início de outro especificador de acesso. Qualquer membro de uma classe pode acessar qualquer outro membro dessa mesma classe. Um membro privado de uma classe não pode ser acessado por nenhuma função externa, nenhum operador externo ou uma classe derivada.

O membro da classe base deve ser protegido para que um membro privado da classe base possa ser acessado por um membro da classe derivada. Este membro protegido da classe base é visto como um membro privado da classe base por uma função externa ou um operador externo.

Um membro público de uma classe pode ser acessado por qualquer função externa, qualquer operador externo ou uma classe derivada.

Na ausência de qualquer especificador de acesso em uma classe, o especificador privado é assumido. Ou seja, o especificador de acesso padrão é privado.

Referências usadas neste trabalho