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 cómo se accede a los miembros de la clase base en la clase derivada. C++ ofrece tres opciones: herencia public, protected y private.

Aquí se muestra cómo cada tipo transforma el `access` a los miembros:

Miembro `Base`	`inheritance` pública	`inheritance` protegida	`inheritance` privada
`public`	`public`	`protected`	`private`
`protected`	`protected`	`protected`	`private`
`private`	`inaccessible`	`inaccessible`	`inaccessible`

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

class PublicDerived : public Base {
    // pub es public, prot es protected, priv es inaccesible
};

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

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

La herencia pública modela relaciones de tipo "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 protegida y privada modela relaciones del tipo "implementado-en-términos-de". Ocultan la interfaz de la clase base del código externo, lo cual es útil cuando deseas reutilizar la implementación sin exponer la relación de herencia. Con la herencia privada, incluso las clases derivadas posteriores pierden el acceso a los miembros originales de la clase base.

Desafío

Fácil

Exploremos cómo los diferentes tipos de herencia afectan la accesibilidad de los miembros construyendo una jerarquía simple de dispositivos. Crearás una clase base Device y tres clases derivadas, cada una utilizando un tipo de herencia diferente, para ver de primera mano cómo la herencia pública, protegida y privada transforma el acceso a los miembros.

Organizarás tu código en dos archivos:

Device.h: Define una clase base Device con tres miembros en diferentes niveles de acceso:
- Un std::string model público
- Un int serialNumber protegido
- Un int internalCode privado (establecido en 999 por defecto)
- Un método público showModel() que imprime: Model: <model>
Después, crea tres clases derivadas que hereden de Device utilizando diferentes tipos de herencia:
- 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 acepte 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 de texto)
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 a showModel() directamente en el objeto (funciona porque la herencia pública lo mantiene público)
- Accede a model directamente e imprime: Direct model access: <model>
- Llama a displaySerial()
Para ProtectedDevice y PrivateDevice:
- Solo llama a displaySerial() (los miembros heredados showModel() 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 al código externo, pero las clases derivadas aún pueden acceder a los miembros protegidos internamente a través de 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;
}