Herencia
La herencia en C++ es un pilar fundamental de la programación orientada a objetos que permite que una clase derive de otra, reutilizando atributos y métodos existentes. Gracias a la herencia, es posible crear jerarquías de clases donde las clases derivadas heredan propiedades de las clases base y, si es necesario, amplían o modifican su comportamiento. Esto reduce la duplicación de código, mejora la mantenibilidad y facilita el diseño de arquitecturas de software más limpias y escalables. Por ejemplo, una clase base "Vehículo" podría definir atributos comunes como marca y año, mientras que las clases derivadas "Coche" y "Motocicleta" heredan esos atributos y agregan sus propios detalles específicos.
Se utiliza herencia cuando múltiples clases comparten comportamiento similar o cuando se requiere un interfaz uniforme para manipular diferentes tipos de objetos. C++ ofrece tipos de herencia: public, protected y private, los cuales controlan el acceso de los miembros de la clase base en la clase derivada. En este tutorial, aprenderá a crear clases base y derivadas, utilizar constructores y destructores, implementar funciones virtuales y polimorfismo, y aplicar herencia en proyectos reales para construir sistemas modulares, mantenibles y eficientes en C++.
Ejemplo Básico
text\#include <iostream>
\#include <string>
class Vehiculo {
protected:
std::string marca;
int anio;
public:
Vehiculo(const std::string& m, int a) : marca(m), anio(a) {}
virtual void mostrar() const {
std::cout << "Marca: " << marca << ", Año: " << anio << std::endl;
}
virtual \~Vehiculo() {}
};
class Coche : public Vehiculo {
private:
int puertas;
public:
Coche(const std::string& m, int a, int p) : Vehiculo(m, a), puertas(p) {}
void mostrar() const override {
std::cout << "Marca: " << marca << ", Año: " << anio << ", Puertas: " << puertas << std::endl;
}
};
int main() {
Vehiculo v("Genérico", 2020);
Coche c("Toyota", 2023, 4);
v.mostrar();
c.mostrar();
Vehiculo* ptr = &c;
ptr->mostrar(); // Demostración de polimorfismo
return 0;
}En este ejemplo, Vehiculo es la clase base que contiene los miembros protected marca y anio, así como la función virtual mostrar. La clase Coche hereda públicamente de Vehiculo e inicializa los miembros base mediante la lista de inicialización del constructor. La función mostrar se sobrescribe para incluir el número de puertas. Cuando un puntero de tipo clase base apunta a un objeto derivado, la llamada a mostrar ejecuta la versión derivada, demostrando polimorfismo. El destructor virtual garantiza que los recursos se liberen correctamente y previene fugas de memoria. Este ejemplo muestra claramente cómo implementar herencia, control de acceso, constructores y funciones virtuales siguiendo buenas prácticas de C++.
Ejemplo Práctico
text\#include <iostream>
\#include <vector>
\#include <memory>
class Empleado {
protected:
std::string nombre;
double salario;
public:
Empleado(const std::string& n, double s) : nombre(n), salario(s) {}
virtual void mostrar() const {
std::cout << "Empleado: " << nombre << ", Salario: " << salario << std::endl;
}
virtual double calcularBono() const = 0; // Función virtual pura
virtual \~Empleado() {}
};
class Gerente : public Empleado {
private:
int tamanioEquipo;
public:
Gerente(const std::string& n, double s, int t) : Empleado(n, s), tamanioEquipo(t) {}
void mostrar() const override {
std::cout << "Gerente: " << nombre << ", Salario: " << salario << ", Equipo: " << tamanioEquipo << std::endl;
}
double calcularBono() const override {
return salario * 0.1 + tamanioEquipo * 100;
}
};
class Desarrollador : public Empleado {
private:
std::string lenguaje;
public:
Desarrollador(const std::string& n, double s, const std::string& l) : Empleado(n, s), lenguaje(l) {}
void mostrar() const override {
std::cout << "Desarrollador: " << nombre << ", Salario: " << salario << ", Lenguaje: " << lenguaje << std::endl;
}
double calcularBono() const override {
return salario * 0.15;
}
};
int main() {
std::vector\<std::unique_ptr<Empleado>> equipo;
equipo.push_back(std::make_unique<Gerente>("Alice", 90000, 5));
equipo.push_back(std::make_unique<Desarrollador>("Bob", 80000, "C++"));
for (const auto& e : equipo) {
e->mostrar();
std::cout << "Bono: $" << e->calcularBono() << std::endl;
}
return 0;
}Aquí, Empleado es una clase abstracta con la función virtual pura calcularBono. Gerente y Desarrollador heredan de Empleado y sobrescriben mostrar y calcularBono. El uso de std::unique_ptr asegura la gestión segura de memoria, y std::vector permite almacenar diferentes tipos de objetos derivados. La llamada a funciones virtuales se resuelve dinámicamente, mostrando polimorfismo. Este ejemplo integra herencia, abstracción y buenas prácticas modernas de C++ para construir arquitecturas escalables y seguras en proyectos reales.
Las mejores prácticas incluyen el uso de destructores virtuales para liberar recursos, herencia pública para relaciones "is-a", inicialización de miembros mediante listas de inicialización, y evitar object slicing. Mantenga las jerarquías de herencia poco profundas y considere composición cuando sea apropiado. Para optimización, utilice contenedores STL y algoritmos eficientes. Para depuración, herramientas como Valgrind pueden detectar fugas de memoria. La seguridad se mejora usando adecuadamente miembros protected/private y evitando punteros colgantes.
📊 Tabla de Referencia
| C++ Element/Concept | Description | Usage Example |
|---|---|---|
| Clase base | Clase de la cual se hereda | class Vehiculo { /* miembros */ }; |
| Clase derivada | Clase que hereda de la base | class Coche : public Vehiculo { /* miembros */ }; |
| Función virtual | Puede ser sobrescrita en derivada | virtual void mostrar() const; |
| Función virtual pura | Debe implementarse en derivada | virtual double calcularBono() const = 0; |
| Polimorfismo | Llamada correcta en tiempo de ejecución | Vehiculo* ptr = \&c; ptr->mostrar(); |
| Lista de inicialización | Inicializa miembros de forma eficiente | Coche(const std::string& m,int a,int p): Vehiculo(m,a), puertas(p) {} |
La herencia en C++ permite modelar relaciones entre objetos, reutilizar código y aplicar polimorfismo. Dominar la herencia facilita el diseño de sistemas mantenibles y escalables, gestionando jerarquías de clases y aplicando principios avanzados de OOP. Los siguientes pasos incluyen estudiar herencia múltiple, clases abstractas y patrones de diseño como Factory o Strategy. Practicar con STL y objetos polimórficos fortalece habilidades avanzadas en C++.
🧠 Pon a Prueba tu Conocimiento
Test Your Knowledge
Test your understanding of this topic with practical questions.
📝 Instrucciones
- Lee cada pregunta cuidadosamente
- Selecciona la mejor respuesta para cada pregunta
- Puedes repetir el quiz tantas veces como quieras
- Tu progreso se mostrará en la parte superior