Dominando la herencia en C++: construya clases potentes con código reutilizable

Herencia en C++

En este tutorial, aprenderemos sobre la herencia en C++ con la ayuda de ejemplos.

La herencia es una de las características clave de la programación orientada a objetos en C++. Permite crear una nueva clase (clase derivada) a partir de una clase existente (clase base).

La clase derivada hereda las características de la clase base y puede tener características adicionales propias. Por ejemplo,

class Animal {
    // función comer()
    // función dormir()
};
class Perro : public Animal {
    // función ladrar()
};

Aquí, la clase Perro se deriva de la clase Animal. Como Perro se deriva de Animal, los miembros de Animal son accesibles para Perro.

Observe el uso de la palabra clave public al heredar Perro de Animal.

class Perro : public Animal {...};

También podemos usar las palabras clave private y protected en lugar de public. Aprenderemos sobre las diferencias entre usar private, public y protected más adelante en este tutorial.

---

Relación es-un

La herencia es una relación es-un. Usamos herencia solo si una relación es-un está presente entre las dos clases.

Aquí hay algunos ejemplos:

• Un coche es un vehículo.
• Una naranja es una fruta.
• Un cirujano es un doctor.
• Un perro es un animal.

---

Ejemplo 1: Ejemplo simple de herencia en C++

// Programa en C++ para demostrar herencia
#include <iostream>
using namespace std;

// clase base
class Animal {
public:
    void comer() {
        cout << "¡Puedo comer!" << endl;
    }
    void dormir() {
        cout << "¡Puedo dormir!" << endl;
    }
};

// clase derivada
class Perro : public Animal {
public:
    void ladrar() {
        cout << "¡Puedo ladrar! ¡Guau guau!!" << endl;
    }
};

int main() {
    // Crear objeto de la clase Perro
    Perro perro1;
    // Llamar a miembros de la clase base
    perro1.comer();
    perro1.dormir();
    // Llamar a miembro de la clase derivada
    perro1.ladrar();
    return 0;
}

Salida

¡Puedo comer!
¡Puedo dormir!
¡Puedo ladrar! ¡Guau guau!!

Aquí, perro1 (el objeto de la clase derivada Perro) puede acceder a miembros de la clase base Animal. Es porque Perro se hereda de Animal.

// Llamar a miembros de la clase Animal
perro1.comer();
perro1.dormir();

---

Miembros protected en C++

El modificador de acceso protected es especialmente relevante cuando se trata de herencia en C++.

Al igual que los miembros private, los miembros protected son inaccesibles desde fuera de la clase. Sin embargo, pueden ser accedidos por clases derivadas y clases/funciones amigas.

Necesitamos miembros protected si queremos ocultar los datos de una clase, pero aún queremos que esos datos sean heredados por sus clases derivadas.

Para aprender más sobre protected, consulte nuestro tutorial de Modificadores de acceso en C++.

---

Ejemplo 2: Miembros protected en C++

// Programa en C++ para demostrar miembros protected
#include <iostream>
#include <string>
using namespace std;

// clase base
class Animal {
private:
    string color;
protected:
    string tipo;
public:
    void comer() {
        cout << "¡Puedo comer!" << endl;
    }
    void dormir() {
        cout << "¡Puedo dormir!" << endl;
    }
    void setColor(string clr) {
        color = clr;
    }
    string getColor() {
        return color;
    }
};

// clase derivada
class Perro : public Animal {
public:
    void setTipo(string tp) {
        tipo = tp;
    }
    void mostrarInfo(string c) {
        cout << "Soy un " << tipo << endl;
        cout << "Mi color es " << c << endl;
    }
    void ladrar() {
        cout << "¡Puedo ladrar! ¡Guau guau!!" << endl;
    }
};

int main() {
    // Crear objeto de la clase Perro
    Perro perro1;
    // Llamar a miembros de la clase base
    perro1.comer();
    perro1.dormir();
    perro1.setColor("negro");
    // Llamar a miembro de la clase derivada
    perro1.ladrar();
    perro1.setTipo("mamífero");
    // Usar getColor() de perro1 como argumento
    // getColor() devuelve datos string
    perro1.mostrarInfo(perro1.getColor());
    return 0;
}

Salida

¡Puedo comer!
¡Puedo dormir!
¡Puedo ladrar! ¡Guau guau!!
Soy un mamífero
Mi color es negro

Aquí, la variable tipo es protected y por lo tanto es accesible desde la clase derivada Perro. Podemos ver esto ya que hemos inicializado tipo en la clase Perro usando la función setTipo().

Por otro lado, la variable private color no puede ser inicializada en Perro.

class Perro : public Animal {
public:
    void setColor(string clr) {
        // Error: miembro "Animal::color" es inaccesible
        color = clr;
    }
};

Además, ya que la palabra clave protected oculta datos, no podemos acceder a tipo directamente desde un objeto de la clase Perro o Animal.

// Error: miembro "Animal::tipo" es inaccesible
perro1.tipo = "mamífero";

---

Modos de acceso en la herencia de C++

En nuestros tutoriales anteriores, hemos aprendido sobre los especificadores de acceso de C++ como public, private y protected.

Hasta ahora, hemos usado la palabra clave public para heredar una clase de una clase base existente. Sin embargo, también podemos usar las palabras clave private y protected para heredar clases. Por ejemplo,

class Animal {
    // código
};
class Perro : private Animal {
    // código
};

class Gato : protected Animal {
    // código
};

Las diversas formas en que podemos derivar clases se conocen como modos de acceso. Estos modos de acceso tienen el siguiente efecto:

1. public: Si una clase derivada se declara en modo public, los miembros de la clase base son heredados por la clase derivada tal como son.
2. private: En este caso, todos los miembros de la clase base se vuelven miembros private en la clase derivada.
3. protected: Los miembros public de la clase base se vuelven miembros protected en la clase derivada.

Los miembros private de la clase base son siempre private en la clase derivada.

Para aprender más, visite nuestro tutorial de herencia public, private, protected en C++.

---

Sobreescritura de funciones miembro en herencia

Supongamos que la clase base y la clase derivada tienen funciones miembro con el mismo nombre y argumentos.

Si creamos un objeto de la clase derivada e intentamos acceder a esa función miembro, se invoca la función miembro en la clase derivada en lugar de la de la clase base.

La función miembro de la clase derivada sobreescribe la función miembro de la clase base.

Aprenda más sobre Sobreescritura de funciones en C++.

---

Lectura recomendada: Herencia múltiple en C++