Níveis de acesso da 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 da classe base	herança pública	herança protegida	herança privada
público	público	protegido	privado
protegido	protegido	protegido	privado
privado	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
};

Herança pública modela relações de “é um” e é de longe a mais comum. Um Dog é um Animal, portanto, o código externo pode tratá-lo como tal.

Herança protegida e privada modela relacionamentos de “implementado em termos de”. Elas ocultam a interface da classe base do código externo, sendo úteis quando você quer reutilizar a implementação sem expor o relacionamento de herança. Com a herança privada, até mesmo as classes derivadas posteriormente perdem o acesso aos membros da classe base original.

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 diferente de herança, para ver na prática como as heranças pública, protegida e privada transformam 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:
- Uma std::string model pública
- 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, cada uma herdando de Device usando um tipo diferente 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() (o showModel() herdado e model não estão mais publicamente acessíveis de fora)
Formato da 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 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.

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: Crie objetos de cada tipo derivado com os valores de entrada
    // PublicDevice pubDev(modelName, serialNum);
    // ProtectedDevice protDev(modelName, serialNum);
    // PrivateDevice privDev(modelName, serialNum);
    
    // TODO: Demonstrate PublicDevice access
    cout << "--- PublicDevice ---" << endl;
    // - Chame showModel() diretamente no objeto
    // - Access model directly and print: Direct model access: <model>
    // - Chame displaySerial()
    
    // TODO: Demonstrate ProtectedDevice access
    cout << "--- ProtectedDevice ---" << endl;
    // - Chame apenas displaySerial() (showModel e model não são acessíveis publicamente)
    
    // TODO: Demonstrate PrivateDevice access
    cout << "--- PrivateDevice ---" << endl;
    // - Chame apenas displaySerial() (showModel e model não são acessíveis publicamente)
    
    return 0;
}