Neste tutorial, aprenderemos sobre os modificadores de acesso para classes C ++ com a ajuda de exemplos. Os modificadores de acesso do C ++ são públicos, privados e protegidos.
Um dos principais recursos das linguagens de programação orientadas a objetos, como C ++, é o ocultamento de dados .
A ocultação de dados refere-se à restrição do acesso a membros de dados de uma classe. Isso evita que outras funções e classes interfiram nos dados da classe.
No entanto, também é importante tornar acessíveis algumas funções de membro e dados de membro para que os dados ocultos possam ser manipulados indiretamente.
Os modificadores de acesso do C ++ nos permitem determinar quais membros da classe são acessíveis a outras classes e funções e quais não são.
Por exemplo,
class Patient ( private: int patientNumber; string diagnosis; public: void billing() ( // code ) void makeAppointment() ( // code ) );
Aqui, as variáveis número do paciente e diagnóstico da Patientclasse são ocultados por meio da privatepalavra - chave, enquanto as funções membro são acessíveis por meio da publicpalavra - chave.
Tipos de modificadores de acesso C ++
Em C ++, existem 3 modificadores de acesso:
publicprivateprotected
Modificador de acesso público
- A
publicpalavra-chave é usada para criar membros públicos (dados e funções). - Os membros públicos podem ser acessados em qualquer parte do programa.
Exemplo 1: Modificador de acesso público C ++
#include using namespace std; // define a class class Sample ( // public elements public: int age; void displayAge() ( cout << "Age = " << age << endl; ) ); int main() ( // declare a class object Sample obj1; cout <> obj1.age; // call class function obj1.displayAge(); return 0; )
Resultado:
Digite sua idade: 20 Idade = 20
Neste programa, criamos uma classe chamada Sample, que contém uma publicvariável idade e uma publicfunção displayAge().
Em main(), criamos um objeto da Sampleclasse denominado obj1. Em seguida, acessamos os elementos públicos diretamente usando os códigos obj.agee obj.displayAge().
Modificador de acesso privado
- A
privatepalavra-chave é usada para criar membros privados (dados e funções). - Os membros privados podem ser acessados apenas de dentro da classe.
- No entanto, classes de amigos e funções de amigos podem acessar membros privados.
Exemplo 2: especificador de acesso privado C ++
#include using namespace std; // define a class class Sample ( // private elements private: int age; // public elements public: void displayAge(int a) ( age = a; cout << "Age = " << age << endl; ) ); int main() ( int ageInput; // declare an object Sample obj1; cout <> ageInput; // call function and pass ageInput as argument obj1.displayAge(ageInput); return 0; )
Resultado:
Digite sua idade: 20 Idade = 20
Em main(), o objeto obj1 não pode acessar diretamente a variável de classe idade.
// error cin>> obj1.age;
Podemos apenas manipular idade indiretamente por meio da função pública displayAge(), uma vez que essa função atribui idade ao argumento passado para ela, ou seja, o parâmetro da função int a.
Modificador de acesso protegido
Antes de aprendermos sobre o protectedespecificador de acesso, certifique-se de saber sobre herança em C ++.
- A
protectedpalavra-chave é usada para criar membros protegidos (dados e função). - Os membros protegidos podem ser acessados dentro da classe e da classe derivada.
Exemplo 3: especificador de acesso protegido por C ++
#include using namespace std; // declare parent class class Sample ( // protected elements protected: int age; ); // declare child class class SampleChild : public Sample ( public: void displayAge(int a) ( age = a; cout << "Age = " << age << endl; ) ); int main() ( int ageInput; // declare object of child class SampleChild child; cout <> ageInput; // call child class function // pass ageInput as argument child.displayAge(ageInput); return 0; )
Resultado:
Digite sua idade: 20 Idade = 20
Aqui, ChildSampleestá uma classe herdada que é derivada de Sample. A variável idade é declarada Samplecom a protectedpalavra - chave.
Isso significa que ChildSamplepode acessar idade, pois Sampleé sua classe pai.
Vemos isso quando atribuímos o valor de idade ChildSample, embora a idade seja declarada na Sampleclasse.
Resumo: público, privado e protegido
publicos elementos podem ser acessados por todas as outras classes e funções.privateos elementos não podem ser acessados fora da classe em que foram declarados, exceto porfriendclasses e funções.protectedelementos são iguais aprivate, exceto que podem ser acessados por classes derivadas.
| Especificadores | Mesma classe | Classe derivada | Classe Externa |
|---|---|---|---|
public | sim | sim | sim |
private | sim | Não | Não |
protected | sim | sim | Não |
Nota: Por padrão, os membros da classe em C ++ são private, a menos que especificado de outra forma.
