Concepto de Herencia
Es el mecanismo por el cual una clase permite heredar las características (atributos y
métodos) de otra clase.
La herencia permite que se puedan definir nuevas clases basadas de unas ya existentes a fin
de reutilizar el código, generando así una jerarquía de clases dentro de una aplicación. Si
una clase deriva de otra, esta hereda sus atributos y métodos y puede añadir nuevos
atributos, métodos o redefinir los heredados.
En otras palabras, tendremos unas clases que serán hijos, y otras clases que serán padres.
Las clases hijas pueden utilizar tanto sus métodos y propiedades como de la clase padre,
siempre que su modificador de acceso lo permita.
Por ejemplo, el siguiente código
class Vehiculo
public decimal VelocidadMaxima { get; set; }
public int NumeroRuedas { get; set; }
public string Marca { get; set; }
public string Modelo { get; set; }
class Moto : Vehiculo
public int Cilindrada { get; set; }
class Coche : Vehiculo
{
public string Traccion { get; set; }
Traducido a una imagen será la siguiente:
Como podemos observar tanto coche como Moto apuntan a Vehículo, eso quiere decir que
pueden usar tanto sus propiedades como sus métodos. Por lo que el siguiente
código Moto.VelocidadMaxima o Moto.Cilindrada es igual de válido
que Coche.VelocidadMaxima o Coche.Traccion.
Para indicar que una clase deriva de otra debemos indicarlo con los dos puntos : como vemos
en el ejelmplo.
Cuando heredamos de una clase padre únicamente podemos hacerlo de una sola clase.
No podemos heredar de dos clases, por ejemplo class Triciclo : Mixto, Vehiculo no es válido.
Ejemplo de herencia:
#include<iostream>
#include<stdlib.h>
using namespace std;
class Persona{
private:
int id;
string nombre;
public:
Persona(int,string);
void mostrarPersona();
};
class Empleado : public Persona{
private:
string contrato;
string empleo;
public:
Empleado(int,string,string,string);
void mostrarEmpleado();
};
class Estudiante : public Persona{
private:
float notafinal;
string materia;
public:
Estudiante(int,string,float,string);
void mostrarEstudiante();
};
class Universitario : public Estudiante{
private:
string carrera;
public:
Universitario(int,string,float,string,string);
void mostrarUniversitario();
};
//Constructor de la clase persona
Persona::Persona(int _id,string _nombre){
id = _id;
nombre= _nombre;
void Persona::mostrarPersona(){
cout<<"id: "<<id<<endl;
cout<<"Nombre: "<<nombre<<endl;
//COnstructor de la clase Empleado
Empleado::Empleado(int _id,string _nombre,string _contrato, string _empleo) : Persona(_id, _nombre){
contrato = _contrato;
empleo= _empleo;
void Empleado::mostrarEmpleado(){
Persona::mostrarPersona();
cout<<"contrato: "<<contrato<<endl;
cout<<"empleo: "<<empleo<<endl;
//constructor de la clase Estudiante
Estudiante::Estudiante(int _id,string _nombre,float _notafinal,string _materia) :Persona(_id,_nombre){
notafinal= _notafinal;
materia= _materia;
void Estudiante::mostrarEstudiante(){
mostrarPersona();
cout<<"Nota final :"<<notafinal<<endl;
cout<<"Materia :"<<materia<<endl;
//constructor de la clase universidad
Universitario::Universitario(int _id,string _nombre,float _notafinal,string _materia,string _carrera):
Estudiante(_id,_nombre,_notafinal,_materia){
carrera= _carrera;
void Universitario::mostrarUniversitario(){
mostrarEstudiante();
cout<<"Carrera: "<<carrera<<endl;
int main(){
Empleado E1 (001,"Samuel","fijo","gerente");
cout<<"Empleado"<<endl;
E1.mostrarEmpleado();
cout<<"\n";
Estudiante Estudiante1(101,"Jesus",17.5,"Base de datos");
cout<<"Estudiante"<<endl;
Estudiante1.mostrarEstudiante();
cout<<"\n";
Universitario Un1(101,"jesus",17.5,"Bse de datos","imformatica");
cout<<"Universitario"<<endl;
Un1.mostrarUniversitario();
cout<<"\n";
system("pause");
return 0;
Polimorfismo:
En pocas palabras el polimorfismo dinámico se refiere a que se puede apuntar un puntero del tipo de
la clase base a objetos del tipo de la clase derivada, esto permite que una instancia del tipo de la
clase base pueda invocar métodos del tipo de la clase derivada, siempre y cuando sean métodos
redefinidos y que hayan sido declarados en la clase base con la palabra virtual. El siguiente ejemplo
permite observar con mayor claridad la situación:
#include<iostream>
using namespace std;
class Base
{
public:
virtual void MetodoOne()
{
cout<<"Clase Base MetodoOne"<<endl;
}
void MetodoTwo()
{
cout<<"Clase Base MetodoTwo"<<endl;
}
};
class Derivada:public Base
{
public:
void MetodoOne()
{
cout<<"Clase Derivada MetodoOne"<<endl;
}
void MetodoTwo()
{
cout<<"Clase Derivada MetodoTwo"<<endl;
}
};
int main()
{
Base *ptr = new Derivada; //Puntero de clase Base a un objeto de clase Derivada
ptr->MetodoOne();
ptr->MetodoTwo();
delete ptr;
return 0;
}
El resultado de la ejecución del código anterior se entiende así: en el caso del llamado a MetodoOne,
al ser este una redefinición de un método virtual, entonces se busca en la tabla virtual y se ejecuta el
que corresponde a la clase derivada. En el caso del llamado a MetodoTwo, por no ser una
redefinición de un método virtual entonces C++ ejecuta el método que corresponde al tipo del
puntero, en este caso la clase Base, ya que no está pendiente del tipo que se almacena en el puntero
sino del tipo del puntero.
EJERCICIOS DE PRACTICA
1. Realice un programa en C++ de tal manera que se construya una solución para la jerarquía
(herencia) de clases mostrada en la siguiente figura:
Trabajador
Gerente Encargado
Licenciado
2. Realice un programa en C++ que tenga la siguiente jerarquía de clases: Animal (Clase padre) -
> Humano (Clase hija) -> Delfín (Clase hija), y hacer polimorfismo con el método nadar ().
Animal
Humano Delfin
3. Se pretende desarrollar un conjunto de clases que representen, de forma simplificada, a una
hipotética empresa dedicada a vender un producto. A continuación, se describen las
características básicas de estas clases:
• Empleado. Clase básica que describe a un empleado. Incluye sus datos personales (nombre,
apellidos, DNI, dirección) y algunos datos tales como los años de antigüedad, teléfono de
contacto y su salario. Incluye también información de quién es el empleado que lo supervisa
(Empleado *). Tendrá, al menos, las siguientes funciones miembro:
• Constructores para definir correctamente un empleado, a partir de su nombre, apellidos, DNI,
dirección, teléfono y salario.
• Imprimir (A través de los operadores de E/S redefinidos)
• Cambiar supervisor
• Incrementar salario
