Níveis de Acesso na Herança

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy — lição 49 de 104.

O tipo de herança que você escolhe afeta como os membros da classe base são acessados na classe derivada. O C++ oferece três opções: herança public, protected e private.

Veja como cada tipo transforma o acesso aos membros:

Membro Base	herança public	herança protected	herança private
public	public	protected	private
protected	protected	protected	private
private	inacessível	inacessível	inacessível

class Base {
public:
    int pub;
protected:
    int prot;
private:
    int priv;
};

class PublicDerived : public Base {
    // pub é público, prot é protegido, priv é inacessível
};

class ProtectedDerived : protected Base {
    // pub é protegido, prot é protegido, priv é inacessível
};

class PrivateDerived : private Base {
    // pub é privado, prot é privado, priv é inacessível
};

Herança pública modela relacionamentos "é-um" e é de longe a mais comum. Um Dog é um Animal, então o código externo pode tratá-lo como tal.

Herança protegida e privada modelam relacionamentos do tipo "implementado-em-termos-de". Elas escondem a interface da classe base do código externo, o que é útil quando você deseja reutilizar a implementação sem expor o relacionamento de herança. Com a herança privada, até mesmo classes derivadas subsequentes perdem o acesso aos membros originais da base.

Desafio

Fácil

Vamos explorar como diferentes tipos de herança afetam a acessibilidade dos membros construindo uma hierarquia simples de dispositivos. Você criará uma classe base Device e três classes derivadas, cada uma usando um tipo de herança diferente, para ver em primeira mão como a herança pública, protegida e privada transforma o acesso aos membros.

Você organizará seu código em dois arquivos:

Device.h: Defina uma classe base Device com três membros em diferentes níveis de acesso:
- Um std::string model público
- Um int serialNumber protegido
- Um int internalCode privado (definido como 999 por padrão)
- Um método público showModel() que imprime: Model: <model>
Em seguida, crie três classes derivadas que herdam de Device usando diferentes tipos de herança:
- PublicDevice usando herança pública — adicione um método displaySerial() que imprime: Serial: <serialNumber>
- ProtectedDevice usando herança protegida — adicione um método displaySerial() que imprime: Serial: <serialNumber>
- PrivateDevice usando herança privada — adicione um método displaySerial() que imprime: Serial: <serialNumber>
Cada classe derivada deve ter um construtor que receba um nome de modelo e um número de série, passando o modelo para a classe base e definindo o número de série.
main.cpp: Leia duas entradas (cada uma em uma linha separada):
1. Nome do modelo (string)
2. Número de série (inteiro)
Crie um objeto de cada tipo derivado com os mesmos valores de entrada. Em seguida, demonstre as diferenças de acesso:

Para PublicDevice:
- Chame showModel() diretamente no objeto (funciona porque a herança pública o mantém público)
- Acesse model diretamente e imprima: Direct model access: <model>
- Chame displaySerial()
Para ProtectedDevice e PrivateDevice:
- Chame apenas displaySerial() (os membros herdados showModel() e model não são mais acessíveis publicamente pelo lado de fora)
Formato de saída:
```
--- PublicDevice ---
Model: <model>
Direct model access: <model>
Serial: <serial>
--- ProtectedDevice ---
Serial: <serial>
--- PrivateDevice ---
Serial: <serial>
```

Por exemplo, com as entradas Laptop e 12345:

--- PublicDevice ---
Model: Laptop
Direct model access: Laptop
Serial: 12345
--- ProtectedDevice ---
Serial: 12345
--- PrivateDevice ---
Serial: 12345

Observe como apenas PublicDevice permite o acesso externo aos membros públicos herdados. Os outros tipos de herança ocultam a interface da classe base do código externo, mas as classes derivadas ainda podem acessar membros protegidos internamente por meio de seus próprios métodos.

Folha de consulta

O C++ oferece três tipos de herança que controlam como os membros da classe base são acessados nas classes derivadas:

Membro da Base	herança pública	herança protegida	herança privada
public	public	protected	private
protected	protected	protected	private
private	inacessível	inacessível	inacessível

class Base {
public:
    int pub;
protected:
    int prot;
private:
    int priv;
};

class PublicDerived : public Base {
    // pub é public, prot é protected, priv é inacessível
};

class ProtectedDerived : protected Base {
    // pub é protected, prot é protected, priv é inacessível
};

class PrivateDerived : private Base {
    // pub é private, prot é private, priv é inacessível
};

A herança pública modela relacionamentos do tipo "é-um" (is-a) e é a mais comum. O código externo pode acessar membros públicos da classe base por meio da classe derivada.

A herança protegida e privada modelam relacionamentos do tipo "implementado-em-termos-de" (implemented-in-terms-of). Elas escondem a interface da classe base do código externo. Com a herança privada, até mesmo classes derivadas posteriormente perdem o acesso aos membros originais da base.

Experimente você mesmo

#include <iostream>
#include <string>
#include "Device.h"

using namespace std;

int main() {
    // Ler entrada
    string modelName;
    int serialNum;
    
    getline(cin, modelName);
    cin >> serialNum;
    
    // TODO: Criar objetos de cada tipo derivado com os valores de entrada
    // PublicDevice pubDev(modelName, serialNum);
    // ProtectedDevice protDev(modelName, serialNum);
    // PrivateDevice privDev(modelName, serialNum);
    
    // TODO: Demonstrar o acesso a PublicDevice
    cout << "--- PublicDevice ---" << endl;
    // - Chamar showModel() diretamente no objeto
    // - Acessar model diretamente e imprimir: Direct model access: <model>
    // - Chamar displaySerial()
    
    // TODO: Demonstrar o acesso a ProtectedDevice
    cout << "--- ProtectedDevice ---" << endl;
    // - Chamar apenas displaySerial() (showModel e model não são acessíveis publicamente)
    
    // TODO: Demonstrar o acesso a PrivateDevice
    cout << "--- PrivateDevice ---" << endl;
    // - Chamar apenas displaySerial() (showModel e model não são acessíveis publicamente)
    
    return 0;
}