Herencia simple.

Cuando slo se tiene una clase base de la cual hereda la clase derivada, se dice que hay
herencia simple. Sin embargo, la herencia simple no excluye la posibilidad de que de una
misma clase base se pueda derivar ms de una subclase o clase derivada

Cuando se necesita representar un concepto general y a partir de ste, conceptos ms

especficos, resulta conveniente organizar la informacin usando herencia.
Esto permite compartir atributos y mtodos ya definidos, evita la duplicidad y, por otra parte,
proporciona mayor claridad en la representacin que se haga de la informacin. Es decir, se
logra un mejor diseo de la solucin del problema.
Existen numerosos casos en los cuales se da este tipo de relacin.

En la figura 2a, la clase Persona es la clase base y Empleado es la clase derivada. Un objeto
de esta clase tambin es un objeto de la clase Persona, por lo tanto tendr los atributos y
mtodos de ambas clases.
En la figura 2b, la clase Mamfero es la clase base y Vacuno y Equino son las clases derivadas.
En este caso, se dice que todo Vacuno y todo Equino tambin son objetos de la clase
Mamfero y en consecuencia tendrn todos los atributos y mtodos que heredan de la clase
base.
La herencia pblica permite que los miembros privados de la clase base se puedan acceder
slo por medio de los mtodos de dicha clase.
Los miembros protegidos de la clase base podrn ser usados por los mtodos de las clases
derivadas, pero no por sus clientes.
Los miembros pblicos estarn disponibles para los mtodos de las clases derivadas y para
todos sus clientes.
class Base
{ private:
// Miembros declarados en la seccin privada: accesibles slo para miembros de esta
clase
protected:
/* Miembros declarados en la seccin protegida: accesibles slo para miembros de
esta
clase y de sus derivadas */
public:

// Miembros declarados en la seccin pblica: accesibles para todos

};
Para declarar una clase derivada de una clase previamente definida se utiliza la
siguiente
Sintaxis:

Con la palabra reservada public en el encabezado de la declaracin de la clase Derivada se

hace referencia a que dicha clase hereda los atributos y mtodos de la clase Base.
La declaracin del constructor de la clase Derivada debe incluir un llamado al constructor de
la clase Base.
Para ello se utiliza la siguiente sintaxis:

Cuando se declara un objeto del tipo de la clase derivada se invoca al constructor de sta. De
este constructor lo primero que se ejecuta es la llamada al constructor de la clase base, y
posteriormente se ejecutan sus propias instrucciones.
En cuanto a los parmetros, al invocar al constructor de la clase base se le deben proporcionar
los parmetros que necesita para asignar valores a los atributos propios de la clase base y que
la clase derivada hereda.
En el cuerpo de la clase derivada se harn las asignaciones correspondientes a los atributos
propios de esta clase.

Solucin al problema de la herencia repetida.- Clases virtuales.

La Herencia Repetida
Cuando una clase hereda de 2 ms superclases que a su vez heredan de la misma
superclase

Se permite la duplicacin de superclases, pero requiere el uso de nombres cualificados

totalmente para referirse a los miembros de una copia especfica.

C++ ( class B: public B { ) Caso (b)

Se puede tratar referencias a la misma clase como si fueran la misma clase

C++ -- Superclases repetidas como clases base virtual

Subclase nombra otra clase como su superclase y la marca como virtual, para indicar
que es una clase compartida ( class B: virtual public B { ) Caso (a)

Duplicacin de propiedades en herencia mltiple

En C++ se resuelve usando herencia virtual:
class Madre_1: virtual public Abuela{

}
class Madre_2: virtual public Abuela{

}
class Hija: public Madre_1, public Madre_2 {

Hija() : Madre_1(), Madre_2(), Abuela(){

};
}
2) Herencia mltiple.

#include<iostream>
#include<conio.h>
#include<string.h>
#include<windows.h>
using namespace std;
class monitor{ //INICIO DE LA CLASE EMPLEADO
public:
//CONSTRUCTOR
monitor(char *,long,int,int);

//FUNCIONES
void muestra_pantalla(void);
private:
char tipo[30];
long colores;
int resolucion_x;
int resolucion_y;
};
monitor::monitor(char *tipo,long colores,int x_res, int y_res){
strcpy(monitor::tipo,tipo);
monitor::colores=colores;
monitor::resolucion_x=x_res;
monitor::resolucion_y=y_res;
}
void monitor::muestra_pantalla(void){
cout<<"Tipo de Video....: "<<tipo<<endl;
cout<<"Colores..........: "<<colores<<endl;
cout<<"Resolucin.......: "<<resolucion_x<<resolucion_y<<endl;
}
class tarjeta_principal{
public:
tarjeta_principal(int,int,int);
void muestra_tarjeta(void);
private:
int procesador;
int velocidad;
int memoria;
};
tarjeta_principal::tarjeta_principal(int procesador,int velocidad,int memoria){
tarjeta_principal::procesador=procesador;
tarjeta_principal::velocidad=velocidad;
tarjeta_principal::memoria=memoria;
}
void tarjeta_principal::muestra_tarjeta(){

cout<<"Procesador....: "<<procesador<<endl;
cout<<"Velocidad.....: "<<velocidad<<" Mhz"<<endl;
cout<<"Memoria.......: "<<memoria<<" Mb"<<endl;
}
class computadora:public monitor,public tarjeta_principal{
public:
computadora(char *, int, float, char *, long, int, int, int, int, int);
void muestra_computadora(void);
private:
char marca[50];
int disco_duro;
float disco_flexible;
};
computadora::computadora(char *marca,int disco_duro,float disco_flexible,char *pantalla,long
colores,int res_x,int res_y,int procesador,int velocidad,int
memoria):monitor(pantalla,colores,res_x,res_y),tarjeta_principal(procesador,velocidad,memoria
){
strcpy(computadora::marca,marca);
computadora::disco_duro=disco_duro;
computadora::disco_flexible=disco_flexible;
}
void computadora::muestra_computadora(void){
cout<<"Marca................: "<<marca<<endl;
cout<<"Disco duro...........: "<<disco_duro<<" Mbytes"<<endl;
cout<<"Unidad de disquetes..: "<<disco_flexible<<" Mbytes"<<endl;
muestra_tarjeta();
muestra_pantalla();
}
int main(void){ //INICIO MAIN
system("cls");
computadora mi_pc("Compaq",212,1.44,"SVGA",16000000,640,480,486,66,8);
mi_pc.muestra_computadora();
getch();
}

//FIN MAIN