TEMA: HERENCIA

PROPSITO: Conocer, comprender y utilizar la propiedad de herencia

entre clases
DEFINICIN:
Herencia: es la capacidad para derivar una clase de otra.
Una clase derivada es un tipo de datos abstracto nuevo que incorpora
todos los miembros de datos (atributos) y las funciones miembro
(mtodos) de la clase original con los nuevos miembros propios. La clase
original usada para derivar se conoce como clase base, padre o
superclase y la clase obtenida a partir de la original se conoce como
clase derivada, hija o subclase.
Existen dos tipos de herencia, la herencia simple donde una clase
derivada solo tiene una clase base inmediata. El complemento de la
herencia simple es la herencia mltiple. En la herencia mltiple una
clase derivada tiene dos o ms clases base.
Las derivaciones de clases se conocen de manera formal como
jerarquas de clase porque ilustran la jerarqua u orden en el que una
clase se deriva de otra.
Nota: Puede haber jerarqua de clases por niveles, donde la clase del nivel
inmediato inferior hereda de la clase base de donde se deriva, y as
sucesivamente.
UTILIDAD:

Reutilizacin de Cdigo
Modelar de una mejor manera el mundo real

Hasta ahora solo se han usado especificadores de acceso privados y

pblicos dentro de la clase. Dar categora de privados a todos los
miembros de datos (atributos), aseguraba que solo podan tener
acceso a ellos las funciones miembro o amigas de clase. Este
acceso restringido impide el acceso a las funciones que no sean de la
clase (excepto amigas), lo cual tambin impide el acceso a las
funciones de clase derivada. Esta es una restriccin sensible, porque si
no existiera cualquiera podra saltarse la restriccin privada con solo
derivar una clase. Para conservar un tipo de acceso restringido a travs
de clases derivadas, C++ proporciona una tercera especificacin de
acceso: protegida. Un acceso protegido se comporta en forma idntica al
acceso privado en cuanto a que solo permite el acceso a las funciones
miembro o amigas, pero permite que esta restriccin sea heredada por
cualquier clase derivada. Entonces la clase derivada define el tipo de
herencia que est dispuesta a tomar, sujeta a las restricciones de acceso

de la clase base. Esto se hace con el especificador de acceso a la clase,

el cual aparece despus de los dos puntos al principio de su seccin de
declaracin. La siguiente tabla muestra el acceso al miembro de la clase
derivada resultante, con base en las especificaciones de los miembros
de la clase base y el especificador de acceso de la clase derivada.
SINTAXIS HERENCIA SIMPLE:
class Nombre_Clase_Base
{
miembros;
}

class Nombre_Clase_Derivada: acceso Nombre_Clase_Base

{
miembros;
}
Los miembros tanto de las clases base como de las clases derivadas pueden
ser: privados, pblicos o protegidos. Y el acceso a la clase base puede ser:
privado, protegido o pblico. Como se muestra en la tabla 1.

Tabla 1.
Miembro (atributo) de
Acceso
de
la clase base
clase derivada

Privado
Privado

protegido
Privado

Pblico
Privado

Privado
Pblico

protegido
Pblico

Pblico
Pblico

Privado
Protegido

protegido
Protegido

Pblico
Protegido

la

Miembro (atributo) de la
clase derivada
Inaccesible
Privado
Privado
Inaccesible
Protegido
Pblico
Inaccesible
Protegido
Protegido

Usando la tabla puede verse (regin sombreada) que:

1) Si el atributo de la clase base tiene acceso protegido y el
especificador de acceso de la clase derivada es public, entonces el
atributo de la clase derivada estar protegido en su clase.
2) Del mismo modo, si la clase base tiene un acceso pblico y el
especificador de la clase derivada es public, el miembro de la clase
derivada ser pblico.

Como este es el tipo de especificacin ms usado para los datos

(atributos) de la clase base y los miembros mtodos,
respectivamente, es el que usaremos. Esto significa que para todas
las clases que pretendan utilizarse como una clase base y derivadas
se usara un acceso protected a los miembros de datos (atributos) en
lugar de una designacin private.

EJEMPLO1:
PROBLEMA: Sumar dos nmeros reales utilizando herencia de clases con el
paradigma OO en C++. La clase base leer los dos datos a sumar, la clase
derivada calcular la suma y mostrar el resultado de la suma. Permita al
usuario decidir cundo terminar, valide la respuesta.

Clase Datos

Atributos
Protegidos:
a,b
Mtodos
Publicos:
leer_a();
leer_b();
Diagrama de Herencia de
Clases

Clase Resultados

Atributos
Protegidos:
c
Mtodos
Pblicos:
entrada();
calcula_c();
escribe_c();

SOLUCIN:
//Programa que suma dos nmeros utilizando la propiedad de herencia simple
//entre una clase Base y una clase Derivada
#include <iostream.h>
#include <ctype.h>
#include <conio.h>
//Clase Base
class Datos
{
protected:
float a,b;
public:
void leer_a();
void leer_b();
};
void Datos::leer_a()
{
cout<<"A=";
cin>>a;
};
void Datos::leer_b()
{
cout<<"B=";
cin>>b;
};
//Clase Derivada
class Resultados:public Datos
{
protected:
float c;
public:
void calcula_c();
void escribe_c();
};
void Resultados::calcula_c()
{
c=a+b;
};
void Resultados::escribe_c()
{
cout<<a<<"+"<<b<<"="<<c;
};
main()
{

Resultados r;
char resp;
do
{
clrscr();
r.leer_a();
r.leer_b();
r.calcula_c();
r.escribe_c();
do
{
cout<<"\n\nContinuar S/N: ";
cin>>resp;
resp=toupper(resp);
}while((resp!='S') && (resp!='N'));
}while(resp=='S');
}
Ejemplo 2: Herencia simple
//Programa que suma dos nmeros utilizando la propiedad de herencia simple
//entre una clase Base y una clase Derivada
#include <iostream.h>
#include <ctype.h>
#include <conio.h>
//Clase Base
class Datos
{
protected:
float a,b;
public:
void leer_a();
void leer_b();
};
void Datos::leer_a()
{
cout<<"A=";
cin>>a;
};
void Datos::leer_b()
{
cout<<"B=";
cin>>b;
};
//Clase Derivada
class Resultados:public Datos
{
protected:

float c;
public:
void calcula_c();
void escribe_c();
void ciclo();
};
void Resultados::calcula_c()
{
c=a+b;
};
void Resultados::escribe_c()
{
cout<<a<<"+"<<b<<"="<<c;
};
void Resultados::ciclo()
{
char resp;
do
{
clrscr();
leer_a();
leer_b();
calcula_c();
escribe_c();
do
{
cout<<"\n\nContinuar S/N: ";
cin>>resp;
resp=toupper(resp);
}while((resp!='S') && (resp!='N'));
}while(resp=='S');
}
main()
{
Resultados r;
r.ciclo();
}
Ejemplo 3: Con miembros pblicos
//Programa que suma dos nmeros utilizando la propiedad de herencia simple
//entre una clase Base y una clase Derivada con miembros pblicos
#include <iostream.h>
#include <ctype.h>
#include <conio.h>
//Clase Base
class Datos
{

public:
float a,b;
void leer_a();
void leer_b();
};
void Datos::leer_a()
{
cout<<"A=";
cin>>a;
};
void Datos::leer_b()
{
cout<<"B=";
cin>>b;
};
//Clase Derivada
class Resultados:public Datos
{
public:
float c;
void calcula_c();
void escribe_c();
void ciclo();
};
void Resultados::calcula_c()
{
c=a+b;
};
void Resultados::escribe_c()
{
cout<<a<<"+"<<b<<"="<<c;
};
void Resultados::ciclo()
{
char resp;
do
{
clrscr();
leer_a();
leer_b();
calcula_c();
escribe_c();
do
{

cout<<"\n\nContinuar S/N: ";

cin>>resp;
resp=toupper(resp);
}while((resp!='S') && (resp!='N'));
}while(resp=='S');
}
main()
{
Resultados r;
r.ciclo();
}
Ejemplo 4: Avanzado Herencia Simple
//Programa que suma dos nmeros utilizando la propiedad de herencia simple
//entre una clase Base y una clase Derivada
// Con la complejidad de llamar desde la clase derivada metodos de la clase
base
#include <iostream.h>
#include <ctype.h>
#include <conio.h>
//Clase Base
class Datos
{
protected:
float a,b;
public:
void leer_a();
void leer_b();
};
void Datos::leer_a()
{
cout<<"A=";
cin>>a;
};
void Datos::leer_b()
{
cout<<"B=";
cin>>b;
};
//Clase Derivada
class Resultados:public Datos
{
protected:
float c;
public:
void entrada();
void calcula_c();

void escribe_c();
};
void Resultados::entrada()
{
Datos :: leer_a();
Datos :: leer_b();
};
void Resultados::calcula_c()
{
c=a+b;
};
void Resultados::escribe_c()
{
cout<<a<<"+"<<b<<"="<<c;
};
main()
{
Resultados r;
char resp;
do
{
r.entrada();
r.calcula_c();
r.escribe_c();
do
{
cout<<"\n\nContinuar S/N: ";
cin>>resp;
resp=toupper(resp);
}while((resp!='S') && (resp!='N'));
}while(resp=='S');
}
Ejemplo 5: Avanzado
//Programa que suma dos nmeros utilizando la propiedad de herencia simple
//entre una clase Base y una clase Derivada
// Con la complejidad de llamar desde la clase derivada metodos de la clase
base
#include <iostream.h>
#include <ctype.h>
#include <conio.h>
//Clase Base
class Datos
{
protected:
float a,b;

public:
void leer_a();
void leer_b();
};
void Datos::leer_a()
{
cout<<"A=";
cin>>a;
};
void Datos::leer_b()
{
cout<<"B=";
cin>>b;
};
//Clase Derivada
class Resultados:public Datos
{
protected:
float c;
public:
void entrada();
void calcula_c();
void escribe_c();
void ciclo();
};
void Resultados::entrada()
{
Datos :: leer_a();
Datos :: leer_b();
};
void Resultados::calcula_c()
{
c=a+b;
};
void Resultados::escribe_c()
{
cout<<a<<"+"<<b<<"="<<c;
};
void Resultados::ciclo()
{
char resp;
do

{
entrada();
calcula_c();
escribe_c();
do
{
cout<<"\n\nContinuar S/N: ";
cin>>resp;
resp=toupper(resp);
}while((resp!='S') && (resp!='N'));
}while(resp=='S');
};
main()
{
Resultados r;
r.ciclo();
}
Ejemplo 6: Avanzado con miembros pblicos
//Programa que suma dos nmeros utilizando la propiedad de herencia simple
//entre una clase Base y una clase Derivada
// Con la complejidad de llamar desde la clase derivada metodos de la clase
base
#include <iostream.h>
#include <ctype.h>
#include <conio.h>
//Clase Base
class Datos
{
public:
float a,b;
void leer_a();
void leer_b();
};
void Datos::leer_a()
{
cout<<"A=";
cin>>a;
};
void Datos::leer_b()
{
cout<<"B=";
cin>>b;
};
//Clase Derivada

class Resultados:public Datos

{
public:
float c;
void entrada();
void calcula_c();
void escribe_c();
void ciclo();
};
void Resultados::entrada()
{
Datos :: leer_a();
Datos :: leer_b();
};
void Resultados::calcula_c()
{
c=a+b;
};
void Resultados::escribe_c()
{
cout<<a<<"+"<<b<<"="<<c;
};
void Resultados::ciclo()
{
char resp;
do
{
entrada();
calcula_c();
escribe_c();
do
{
cout<<"\n\nContinuar S/N: ";
cin>>resp;
resp=toupper(resp);
}while((resp!='S') && (resp!='N'));
}while(resp=='S');
};
main()
{
Resultados r;
r.ciclo();
}

PROBLEMA: Leer datos desde la clase Base y la Clase Derivada, posteriormente

escribir los datos ledos desde la clase Base y la clase Derivada utilizando la
propiedad de Herencia Simple entre dos clases utilizando el paradigma OO.
Permita al usuario decidir cundo terminar (valide).

Clase Empleado

Atributos
Protegidos:
Nombre,
ced,edad
Mtodos
Publicos:
leer_datos();
leer_datos();
Diagrama Herencia de
Clases

Clase Administrativo

Atributos
Protegidos:
Categora,desti
no
Mtodos
Pblicos:
leer_datos();
leer_datos();

#include <iostream.h>
#include <conio.h>
#include<ctype.h>
#include<stdlib.h>
//Clase Base
class Empleado
{
protected:
char nombre[50];
long ced;
int edad;
public:
void leer_datos();
void escribir_datos();
};
void Empleado::leer_datos()
{
gotoxy(20,10);
cout<<"Digite el nombre : ";
cin.getline(nombre,50);
gotoxy(20,11);
cout<<"Digite la cedula : ";
cin>>ced;
gotoxy(20,12);
cout<<"Digite la edad : ";
cin>>edad;
}
void Empleado::escribir_datos()
{
gotoxy(20,10);
cout<<"El nombre es : "<<nombre;
gotoxy(20,11);
cout<<"La cedula es : "<<ced;
gotoxy(20,12);
cout<<"La edad es : "<<edad;
}
//Clase Derivada
class Administrativo : public Empleado //Herencia
{
protected:
char categoria[50];
char destino[50];
public:
void leer_datos();
void escribir_datos();
};

void Administrativo::leer_datos()
{
Empleado::leer_datos(); //encapsulamiento
gotoxy(20,13);
cin.get();
cout<<"Digite la categoria : ";
cin.getline(categoria,50);
gotoxy(20,14);
cout<<"Digite el destino : ";
cin.getline(destino,50);
}
void Administrativo::escribir_datos()
{
Empleado::escribir_datos(); //encapsulamiento
gotoxy(20,13);
cout<<"La categoria es : "<<categoria;
gotoxy(20,14);
cout<<"El destino es : "<<destino;
}
main()
{
Administrativo a;
char resp;
do
{
clrscr();
a.leer_datos();
clrscr();
a.escribir_datos();
do
{
cout<<"\n\nContinuar (S/N):";
cin>>resp;
cin.get();
resp=toupper(resp);
}while((resp!='S') && (resp!='N'));
}while(resp=='S');
}

Clase Empleado

Atributos
Protegidos:
Nombre,
ced,edad
Mtodos
Publicos:
leer_empleado();
escribir_emplead
o();

Atributos
Protegidos:
Categora, turno
Mtodos
Pblicos:
leer_admin();
escribir_admin();

Clase Administrativo

Atributos
Protegidos:
Producto, Ventas
Mtodos
Pblicos:
leer_vend();
escribir_vend();

Clase Vendedores

//Programa tipo de empleado y sus datos utilizando la propiedad de Herencia

//con una clase Base y dos clases Derivadas
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<stdio.h>
class empleado
{
protected:
char nombre[50];
long ced;
int edad;
public:
void leer_emple();
void escribir_emple();
};
void empleado::leer_emple()
{
gotoxy(20,10);
cout<<"Digite el nombre : ";
cin.getline(nombre,50);
gotoxy(20,11);
cout<<"Digite la cedula : ";
cin>>ced;
gotoxy(20,12);
cout<<"Digite la edad : ";
cin>>edad;
}
void empleado::escribir_emple()
{
gotoxy(20,8);
cout<<"LOS DATOS LEIDOS SON ";
gotoxy(20,10);
cout<<"El nombre es : "<<nombre;
gotoxy(20,11);
cout<<"La cedula es : "<<ced;
gotoxy(20,12);
cout<<"La edad es : "<<edad;
}
class administrativo : public empleado
{
protected:
char categoria[50];
char turno[50];
public:
void leer_admin();

void escribir_admin();
};
void administrativo::leer_admin()
{
gotoxy(20,13);
cout<<"Digite la categoria : ";
cin.getline(categoria,50);
gotoxy(20,14);
cout<<"Digite el destino : ";
cin.getline(turno,50);
}
void administrativo::escribir_admin()
{
gotoxy(20,13);
cout<<"La categoria es : "<<categoria;
gotoxy(20,14);
cout<<"El destino es : "<<turno;
}
class vendedores : public empleado
{
private:
char producto[50];
double ventas;
public:
void leer_vend();
void escribir_vend();
};
void vendedores::leer_vend()
{
gotoxy(20,13);
cout<<"Digite la titulacion : ";
cin.getline(producto,50);
gotoxy(20,14);
cout<<"Digite las ventas : ";
cin>>ventas;
}
void vendedores::escribir_vend()
{
gotoxy(20,13);
cout<<"La titulacion es : "<<producto;
gotoxy(20,14);
cout<<"Las ventas son : "<<ventas;
}

main()
{
clrscr();
administrativo uno;
vendedores dos;
int ele;
char op;
op='S';
while (op=='S')
{
clrscr();
gotoxy(20,22);cout<<" 1 ->> ADMINISTRATIVO. 2 ->> VENDEDORES. ";
gotoxy(20,5);cout<<"Digite que clase de emleado : ";cin>>ele;
if(ele==1)
{
clrscr();
gotoxy(15,5);cout<<"EMPLEADO ADMINISTRATIVO ";
uno.leer_emple();
uno.leer_admin();
clrscr();
uno.escribir_emple();
uno.escribir_admin();
getch();
}
else
if(ele==2)
{
clrscr();
gotoxy(15,5);cout<<"EMPLEADO VENDEDOR ";
dos.leer_emple();
dos.leer_vend();
clrscr();
dos.escribir_emple();
dos.escribir_vend();
}
do
{
gotoxy(20,22);cout<<"DESEA CONTINUAR -S/N- ";
op=getch();
op=toupper(op);
}while((op!='S')&&(op!='N'));
}
}

--------------------0------------------SINTAXIS HERENCIA MLTIPLE:

class Nombre_Clase_Base1
{
miembros;
}
class Nombre_Clase_Base2
{
miembros;
}

class Nombre_Clase_Derivada: acceso Nombre_Clase_Base1, acceso

Nombre_Clase_Base2

{
protected:
atributos;
public:
mtodos:
}

Donde el acceso a la clase base puede ser: privado, protegido o pblico

Ejemplo1: Herencia Mltiple del programa anterior
PROBLEMA: Sumar dos nmeros reales utilizando herencia mltiple de clases
con el paradigma OO en C++. Las clases bases leern los dos datos a sumar,
la clase derivada calcular la suma y mostrar el resultado de la suma. Permita
al usuario decidir cundo terminar, valide la respuesta.
//Programa que suma dos nmeros utilizando la propiedad de herencia Mltiple
//entre dos clases Base y una clase Derivada
#include <iostream.h>
#include <ctype.h>
#include <conio.h>
//Clase Base1
class Datos1
{
protected:
float a;
public:
void leer_a();
};
void Datos1::leer_a()
{

cout<<"A=";
cin>>a;
};
//Clase Base2
class Datos2
{
protected:
float b;
public:
void leer_b();
};
void Datos2::leer_b()
{
cout<<"B=";
cin>>b;
};
//Clase Derivada
class Resultados:public Datos1,public Datos2
{
protected:
float c;
public:
void calcula_c();
void escribe_c();
};
void Resultados::calcula_c()
{
c=a+b;
};
void Resultados::escribe_c()
{
cout<<a<<"+"<<b<<"="<<c;
};
main()
{
Resultados r;
char resp;
do
{
clrscr();
r.leer_a();
r.leer_b();
r.calcula_c();

r.escribe_c();
do
{
cout<<"\n\nContinuar S/N: ";
cin>>resp;
resp=toupper(resp);
}while((resp!='S') && (resp!='N'));
}while(resp=='S');
}
Ejemplo2: Avanzado Herencia Mltiple
//Programa que suma dos nmeros utilizando la propiedad de herencia simple
//entre una clase Base y una clase Derivada
// Con la complejidad de llamar desde la clase derivada metodos de la clase
base
#include <iostream.h>
#include <ctype.h>
#include <conio.h>
//Clase Base1
class Datos1
{
protected:
float a;
public:
void leer_a();
};
void Datos1::leer_a()
{
cout<<"A=";
cin>>a;
};
//Clase Base2
class Datos2
{
protected:
float b;
public:
void leer_b();
};
void Datos2::leer_b()
{
cout<<"B=";
cin>>b;
};
//Clase Derivada

class Resultados:public Datos1, public Datos2

{
protected:
float c;
public:
void entrada();
void calcula_c();
void escribe_c();
};
void Resultados::entrada()
{
Datos1 :: leer_a();
Datos2 :: leer_b();
};
void Resultados::calcula_c()
{
c=a+b;
};
void Resultados::escribe_c()
{
cout<<a<<"+"<<b<<"="<<c;
};
main()
{
Resultados r;
char resp;
do
{
r.entrada();
r.calcula_c();
r.escribe_c();
do
{
cout<<"\n\nContinuar S/N: ";
cin>>resp;
resp=toupper(resp);
}while((resp!='S') && (resp!='N'));
}while(resp=='S');
}
Ejemplo 3: Herencia mltiple por niveles
//Programa que suma dos nmeros utilizando la propiedad de herencia mltiple
//por niveles entre clases Base que hereden a una clase Derivada
#include <iostream.h>
#include <ctype.h>

#include <conio.h>
//Clase Base
class Datos
{
protected:
float a,b;
public:
void leer_a();
void leer_b();
};
void Datos::leer_a()
{
cout<<"A=";
cin>>a;
};
void Datos::leer_b()
{
cout<<"B=";
cin>>b;
};
//Clase Derivada
class Resultados:public Datos
{
protected:
float c;
public:
void calcula_c();
};
void Resultados::calcula_c()
{
c=a+b;
};
//
class Escribe:public Resultados
{
public:
void escribe_c();
};
void Escribe::escribe_c()
{
cout<<a<<"+"<<b<<"="<<c;
};
//

main()
{
Escribe e;
char resp;
do
{
clrscr();
e.leer_a();
e.leer_b();
e.calcula_c();
e.escribe_c();
do
{
cout<<"\n\nContinuar S/N: ";
cin>>resp;
resp=toupper(resp);
}while((resp!='S') && (resp!='N'));
}while(resp=='S');
}
Instrucciones: Haga uso de la herencia (simple y mltiple) de clases con el
paradigma OO en C++.
EJERCICIO1: Calcule el rea de circunferencias. Permita al usuario decidir
cundo terminar y valide la respuesta.
EJERCICIO2: Calcule las races reales y complejas de ecuaciones de segundo
grado. Permita al usuario decidir cundo terminar y valide la respuesta.