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 acceso a los miembros:

Miembro base	herencia public	herencia protected	herencia private
public	public	protected	private
protected	protected	protected	private
private	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 protegida y privada modela relaciones de tipo "implementado en términos de". Ocultan la interfaz de la clase base al código externo, lo cual es útil cuando se desea 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 originales de la base.

Desafío

Fácil

Exploremos cómo los diferentes tipos de herencia afectan la accesibilidad de los miembros construyendo una jerarquía de dispositivos simple. 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>
Luego 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 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 (string)
2. Número de serie (entero)
Crea un objeto de cada tipo derivado con los mismos valores de entrada. Luego 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 internamente a los miembros protegidos a través de sus propios métodos.

Hoja de referencia

C++ ofrece tres tipos de herencia que controlan cómo se accede a los miembros de la clase base en las clases derivadas:

Miembro Base	herencia public	herencia protected	herencia private
public	public	protected	private
protected	protected	protected	private
private	inaccesible	inaccesible	inaccesible

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" (is-a) y es la más común. El código externo puede acceder a los miembros públicos de la clase base a través de la clase derivada.

La herencia protegida y privada modelan relaciones de tipo "implementado-en-términos-de" (implemented-in-terms-of). Estas ocultan la interfaz de la clase base al código externo. Con la herencia privada, incluso las clases derivadas posteriormente pierden el acceso a los miembros originales de la base.

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: Crear objetos de cada tipo derivado con los valores de entrada
    // PublicDevice pubDev(modelName, serialNum);
    // ProtectedDevice protDev(modelName, serialNum);
    // PrivateDevice privDev(modelName, serialNum);
    
    // TODO: Demostrar el acceso a PublicDevice
    cout << "--- PublicDevice ---" << endl;
    // - Llamar a showModel() directamente en el objeto
    // - Acceder a model directamente e imprimir: Direct model access: <model>
    // - Llamar a displaySerial()
    
    // TODO: Demostrar el acceso a ProtectedDevice
    cout << "--- ProtectedDevice ---" << endl;
    // - Solo llamar a displaySerial() (showModel y model no son accesibles públicamente)
    
    // TODO: Demostrar el acceso a PrivateDevice
    cout << "--- PrivateDevice ---" << endl;
    // - Solo llamar a displaySerial() (showModel y model no son accesibles públicamente)
    
    return 0;
}