Diferença entre privado e protegido em C ++

O conceito de encapsulamento e ocultação de dados é amplamente utilizado em linguagens de programação orientadas a objetos, como C++. Conhecer esses conceitos garante a segurança e a integridade dos dados em um programa. Em C ++, dois especificadores de acesso - privados e protegidos - são usados ​​para aplicar esses conceitos. Este artigo cobre a diferença entre privado e protegido em C ++ e como eles afetam a visibilidade e a acessibilidade dos alunos.

Índice

• O que são especificadores de acesso em C++
• O que é privado em C++
• O que está protegido em C++
• Diferença entre privado e protegido em c++
• Exemplos de especificadores de acesso privado e protegido
• Conclusão

O que são especificadores de acesso em C++

Em C ++, os especificadores de acesso são palavras -chave reservadas que servem ao objetivo de determinar a visibilidade e a acessibilidade dos membros de uma classe. Essas palavras -chave são usadas para restringir ou permitir o acesso a diferentes membros da classe em um programa.

Os especificadores de acesso determinam a partir de onde um membro da classe pode ser acessado. Esses especificadores permitem que o código C ++ acesse um membro da classe de dentro ou fora de uma classe. Eles também permitem que classes derivadas acessem os principais membros da classe.

No C ++, os especificadores de acesso podem ser categorizados em três especificadores diferentes:

• privado
• protegido
• público

Esses especificadores controlam a visibilidade dos membros da classe, que determina onde e por quem podem ser acessados ​​no programa.

O que é privado em C++

Privado é um especificador de acesso em C ++ que limita a visibilidade e a acessibilidade dos membros da classe a apenas o classe em si. Os membros definidos como privados não são acessíveis de fora da classe ou de suas classes derivadas. Os membros privados estão ocultos de outras classes, o que os impede de modificar ou acessar os dados.

O que está protegido em C++

Protegido é um especificador de acesso em C ++ que limita a visibilidade e a acessibilidade dos membros da classe ao classe em si e os seus classes derivadas. Os membros definidos como protegidos podem ser acessados ​​de dentro de uma classe ou de suas classes derivadas, mas não de fora da classe. Os membros protegidos também estão ocultos de outras classes, o que os impede de modificar ou acessar os dados.

Diferença entre privado e protegido em c++

A principal diferença entre privado e protegido em C ++ é o nível de acessibilidade dos alunos da classe. O acesso a membros privados é restrito na classe, enquanto os membros protegidos também são acessíveis a partir de classes derivadas.

Outra diferença é que os membros privados estão completamente ocultos de outras classes, enquanto os membros protegidos estão parcialmente ocultos. Isso significa que as classes derivadas podem acessar membros protegidos, mas não os modificam diretamente. Por outro lado, os membros privados não podem ser acessados ​​ou modificados por qualquer outra classe.

Exemplos de especificadores de acesso privado e protegido

Para demonstrar o conceito de especificadores de acesso na programação orientada a objetos, é útil fornecer exemplos de especificadores de acesso privado e protegido. Vamos dar uma olhada em como os especificadores de acesso privado e protegidos funcionam e alguns exemplos de como eles podem ser usados.

Exemplo de aula privada em C++

O especificador de acesso privado restringe a visibilidade de um membro da classe dentro da própria classe. O código abaixo explica a classe privada em um programa C ++:

#incluir
usando namespace std;
classe de classe
// membros particulares
privado:
string fullName;
Int Yearsold;
// Membros públicos
público:
Void getPersonInfo ()

cout << "Enter full name: ";
getLine (CIN, FullName);
cout << "Enter age in years: ";
Cin >> anos;

Void DisplayPersonInfo ()

cout << "Name: " << fullName << endl;
cout << "Age: " << yearsOld << endl;

;
// função principal
int main ()

// criando objeto
Pessoa pessoa;
pessoa.getPersonInfo ();
pessoa.displayPersonInfo ();
retornar 0;

Este programa C ++ define uma pessoa de classe com duas variáveis ​​de membro privado nome completo e anos, e duas funções de membro público getPersonInfo () e DisplayPersonInfo ().

A função getPersonInfo () leva o usuário a inserir o nome completo e a idade da pessoa. Depois disso, os armazena nas variáveis ​​de membro privado FullName e Yearsold, respectivamente.

A função DisplayPersonInfo () simplesmente imprime o nome da pessoa e a idade do console.

Na função Main (), criamos uma pessoa do objeto da classe Pessoa e chamamos suas funções getPersonInfo () e DisplayPersonInfo () para levar o usuário a inserir as informações de uma pessoa e depois exibi -las no console.

Exemplo de classe protegida em C++

O especificador de acesso protegido limita a visibilidade de um membro da classe a dentro da classe e suas subclasses. Vamos dar um exemplo que explica classes protegidas em um programa C ++.

#incluir
usando namespace std;
// classe base
classe de classe
// membros particulares
privado:
string fullName;
Int Age;
// Membro protegido
protegido:
int idNumber;
// Membros públicos
público:
Void getPersonInfo ()

cout << "Enter full name: ";
getLine (CIN, FullName);
cout << "Enter age: ";
Cin >> idade;

Void DisplayPersonInfo ()

cout << "Name: " << fullName << endl;
cout << "Age: " << age << endl;

;
// classe derivada
Classe Student: Public Pessoa
// membros particulares
privado:
String City;
// Membros públicos
público:
Void SetId (int id)

// aqui idnumber é o membro protegido da pessoa
// classe, é acessível aqui
idNumber = id;

void getStudentinfo ()

// chamando getPersonInfo () para ler detalhes básicos
getPersonInfo ();
// Cidade de entrada
cout << "Enter city: ";
City City;

Void DisplayStudentInfo ()

// Número de identificação exibindo
cout << "ID Number: " << idNumber << endl;
// Calling DisplayPersonInfo () para imprimir detalhes básicos
displayPersonInfo ();
// exibindo cidade também
cout << "City: " << city << endl;

;
// função principal
int main ()

// criando objeto
Estudante estudantil;
// Número de identificação de configuração
estudante.SetId (12345);
// Obtendo todos os detalhes
estudante.getStudentInfo ();
// imprimindo todos os detalhes
estudante.displayStudentInfo ();
retornar 0;

Aqui neste código, a classe base é uma pessoa com membros particulares nome completo e idade, e um membro protegido número de identidade. A turma derivada é estudante de uma cidade privada e funções públicas de membros setid (), getStudentinfo () e displayStudentInfo ().

A função setId () define o número de identificação, que define um membro protegido da classe base. A função getStudentInfo () lê os detalhes básicos do aluno, como nome completo, idade e a cidade em que vivem.

O DisplayStudentInfo () Função imprime todos os detalhes do aluno, que incluem seu número de identificação, nome completo, idade e cidade.

Conclusão

Especificadores de acesso privado e protegido na programação orientada a objetos garantem encapsulamento e ocultação de dados. Os membros privados estão completamente ocultos de outras classes, enquanto os membros protegidos estão parcialmente ocultos e podem ser acessados ​​por classes derivadas. A escolha entre o uso de especificadores de acesso privado e protegido depende do design e implementação da classe. Leia o artigo para entender os detalhes dos especificadores de acesso privado e protegido.