Niveles de acceso en la herencia

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 49 de 104.

El tipo de herencia que elijas afecta a cómo se accede a los miembros de la clase base en la clase derivada. C++ ofrece tres opciones: herencia public, protected y private.

Así es como cada tipo transforma el acceso a los miembros:

Miembro base	herencia pública	herencia protegida	herencia privada
público	público	protegido	privado
protegido	protegido	protegido	privado
privado	inaccesible	inaccesible	inaccesible

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

class PublicDerived : public Base {
    // pub es público, prot es protegido, priv es inaccesible
};

class ProtectedDerived : protected Base {
    // pub es protegido, prot es protegido, priv es inaccesible
};

class PrivateDerived : private Base {
    // pub es privado, prot es privado, priv es inaccesible
};

La herencia pública modela relaciones «es-un» y es, con diferencia, la más común. Un Dog es un Animal, por lo que el código externo puede tratarlo como tal.

La herencia protected y privada modela relaciones de «implementado en términos de». Ocultan la interfaz de la clase base del código externo, lo que resulta útil cuando quieres reutilizar la implementación sin exponer la relación de herencia. Con la herencia privada, incluso las clases derivadas posteriormente pierden el acceso a los miembros de la clase base original.

Desafío

Fácil

Exploremos cómo los distintos tipos de herencia afectan la accesibilidad de los miembros mediante la construcción de una jerarquía sencilla de dispositivos. Crearás una clase base Device y tres clases derivadas, cada una con un tipo de herencia diferente, para comprobar de primera mano cómo la herencia pública, protegida y privada transforman el acceso a los miembros.

Organizarás tu código en dos archivos:

Device.h: Define una clase base Device con tres miembros en distintos niveles de acceso:
- Un std::string model público
- Un int serialNumber protegido
- Un int internalCode privado (establecido en 999 de forma predeterminada)
- Un método público showModel() que imprime: Model: <model>
Después crea tres clases derivadas, cada una heredando de Device mediante un tipo de herencia diferente:
- PublicDevice usando herencia pública: añade un método displaySerial() que imprime: Serial: <serialNumber>
- ProtectedDevice usando herencia protegida: añade un método displaySerial() que imprime: Serial: <serialNumber>
- PrivateDevice usando herencia privada: añade un método displaySerial() que imprime: Serial: <serialNumber>
Cada clase derivada debe tener un constructor que reciba un nombre de modelo y un número de serie, pasando el modelo a la clase base y estableciendo el número de serie.
main.cpp: Lee dos entradas (cada una en una línea separada):
1. Nombre del modelo (cadena)
2. Número de serie (entero)
Crea un objeto de cada tipo derivado con los mismos valores de entrada. Después demuestra las diferencias de acceso:

Para PublicDevice:
- Llama directamente a showModel() sobre el objeto (funciona porque la herencia pública lo mantiene público)
- Accede directamente a model e imprime: Direct model access: <model>
- Llama a displaySerial()
Para ProtectedDevice y PrivateDevice:
- Llama únicamente a displaySerial() (el showModel() heredado y model ya no son accesibles públicamente desde el exterior)
Formato de salida:
```
--- PublicDevice ---
Model: <model>
Direct model access: <model>
Serial: <serial>
--- ProtectedDevice ---
Serial: <serial>
--- PrivateDevice ---
Serial: <serial>
```

Por ejemplo, con las entradas Laptop y 12345:

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

Observa cómo solo PublicDevice permite el acceso externo a los miembros públicos heredados. Los otros tipos de herencia ocultan la interfaz de la clase base del código externo, pero las clases derivadas aún pueden acceder internamente a los miembros protegidos mediante sus propios métodos.

Pruébalo tú mismo

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

using namespace std;

int main() {
    // Leer entrada
    string modelName;
    int serialNum;
    
    getline(cin, modelName);
    cin >> serialNum;
    
    // TODO: Crea objetos de cada tipo derivado con los valores de entrada
    // PublicDevice pubDev(modelName, serialNum);
    // ProtectedDevice protDev(modelName, serialNum);
    // PrivateDevice privDev(modelName, serialNum);
    
    // TODO: Demonstrate PublicDevice access
    cout << "--- PublicDevice ---" << endl;
    // - Llama a showModel() directamente en el objeto
    // - Access model directly and print: Direct model access: <model>
    // - Llama a displaySerial()
    
    // TODO: Demonstrate ProtectedDevice access
    cout << "--- ProtectedDevice ---" << endl;
    // - Solo llama a displaySerial() (showModel y model no son accesibles públicamente)
    
    // TODO: Demonstrate PrivateDevice access
    cout << "--- PrivateDevice ---" << endl;
    // - Solo llama a displaySerial() (showModel y model no son accesibles públicamente)
    
    return 0;
}