UNIVERSIDAD DE EL SALVADOR

FACULTAD DE INGENIERIA Y
ARQUITECTURA
ESCUELA DE INGENIERIA ELECTRICA
PROGRAMACION I
CICLO II / 2015

Laboratorio N° 5
Tema: “Herencia en C++”
Grupo de laboratorio:01

Integrantes:

Castro Contreras. Fidel Ernesto……….…………...…. CC14009

Monterrosa Aquino, Salvador Edgardo……………... MA14052
Ramírez Márquez, Oscar Joaquín…………………..… RM05009

Ciudad Universitaria, viernes 13 de Noviembre del 2015

Desarrollo de la práctica.

EJEMPLO 01:

Partiremos de la clase "Persona". Independientemente de la profesión, todas las

personas tienen propiedades comunes, nombre, fecha de nacimiento, género, estado
civil, etc.
La siguiente clasificación debe ser menos general, supongamos que dividimos a todas
las personas en dos grandes clases: empleados y estudiantes. (Dejaremos de lado, de
momento, a los estudiantes que además trabajan). Lo importante es decidir qué
propiedades que no hemos incluido en la clase "Persona" son exclusivas de los
empleados y de los estudiantes. Por ejemplo, los ingresos por nómina son exclusivos de
los empleados, la nota media del curso, es exclusiva de los estudiantes. Una vez hecho
eso crearemos dos clases derivadas de Persona: "Empleado" y "Estudiante".
Haremos una nueva clasificación, ahora de los empleados. Podemos clasificar a los
empleados en ejecutivos y comerciales (y muchas más clases, pero para el ejemplo nos
limitaremos a esos dos). De nuevo estableceremos propiedades exclusivas de cada
clase y crearemos dos nuevas clases derivadas de "Empleado": "Ejecutivo" y "Comercial".
Ahora veremos las ventajas de disponer de una jerarquía completa de clases.

Cada vez que creemos un objeto de cualquier tipo derivado, por ejemplo de tipo
Comercial, estaremos creando en un solo objeto un Comercial, un Empleado y una
Persona. Nuestro programa puede tratar a ese objeto como si fuera cualquiera de esos
tres tipos. Es decir, nuestro comercial tendrá, además de sus propiedades como
comercial, su nómina como empleado y su nombre, edad y género como persona.
Siempre podremos crear nuevas clases para resolver nuevas situaciones. Consideremos
el caso de que en nuestra clasificación queremos incluir una nueva clase "Becario", que
no es un empleado, ni tampoco un estudiante; la derivaríamos de Persona. También
podemos considerar que un becario es ambas cosas, sería un ejemplo de derivación
múltiple, podríamos hacer que la clase derivada Becario, lo fuera de Empleado y
Estudiante.
Podemos aplicar procedimientos genéricos a una clase en concreto, por ejemplo,
podemos aplicar una subida general del salario a todos los empleados,
independientemente de su profesión, si hemos diseñado un procedimiento en la clase
empleado para ello.
#include <iostream>
#include <cstring>
using namespace std;
class Persona {
public:
Persona(char *n) { strcpy(nombre, n); }
void VerNombre() { cout << nombre << endl; }
protected:
char nombre[30];
};
class Empleado : public Persona {
public:
Empleado(char *n) : Persona(n) {}
void VerNombre() { cout << "Emp: " << nombre << endl; }
};
class Estudiante : public Persona {
public:
Estudiante(char *n) : Persona(n) {}
void VerNombre() { cout << "Est: " << nombre << endl; }
};
int main() {
Persona *Pepito = new Estudiante("Jose");
Persona *Carlos = new Empleado("Carlos");
Carlos->VerNombre();
Pepito->VerNombre();
delete Pepito;
delete Carlos;
cin.get();
return 0
;
}

Ejemplo 2
#include <iostream>
using namespace std;
class ClaseA {
public:
ClaseA() : datoA(10) { cout << "Constructor de A" << endl; }
~ClaseA() { cout << "Destructor de A" << endl; }
int LeerA() const { return datoA; }
protected:
int datoA;
};
class ClaseB : public ClaseA {
public:
ClaseB() : datoB(20) {cout << "Constructor de B" << endl; }
~ClaseB() { cout << "Destructor de B" << endl; }
int LeerB() const { return datoB; }
protected:
int datoB;
};
int main() {
ClaseB objeto;
cout << "a = " << objeto.LeerA() << ", b = " << objeto.LeerB() << endl;
cin.get();
return 0;
}
Asignación: Terminar la Clase Base Persona según se muestra en el diagrama de
jerarquías mostrado.
#include <iostream>
#include <cstring>
using namespace std;
//************************* PERSONA
**************************************
class Persona {
public:
Persona(char *, int, char *, char *);
void VerNombre();
protected:
char nombre[30], direccion[50], telefono[10];
int edad;
};
Persona::Persona(char *n, int ed, char *dir, char *tel){
strcpy(nombre, n);
edad = ed;
strcpy(direccion, dir);
strcpy(telefono, tel);
}
void Persona::VerNombre() {
cout << "Persona: " << nombre
<<"\nEdad: "<<edad
<<" años\nDireccion: "<<direccion
<<"\nTelefono: "<<telefono
<< endl;
}
//************************ EMPLEADO
***************************************
class Empleado : public Persona {
public:
Empleado(char *, int , char *, char *, char *);
void VerNombre();
protected:
char cargo[20];
};
Empleado::Empleado(char *n, int ed, char *dir, char *tel, char *car) : Persona(n, ed, dir,
tel) {
strcpy(cargo, car);
}
void Empleado::VerNombre() {
cout << "Empleado: " << nombre
<<"\nEdad: "<<edad
<<" años\nDireccion: "<<direccion
<<"\nTelefono: "<<telefono
<<"\nCargo: "<<cargo
<< endl;
}
//************************ ESTUDIANTE
*************************************
class Estudiante : public Persona {
public:
Estudiante(char *, int, char *, char *, char *);
void VerNombre();
protected:
char lugar[30];
};
Estudiante::Estudiante(char *n, int ed, char *dir, char *tel, char *lug) : Persona(n, ed,
dir, tel) {
 strcpy(lugar, lug);
}

void Estudiante::VerNombre(){
cout << "Estudiante: " << nombre
<<"\nEdad: "<<edad
<<" años\nDireccion: "<<direccion
<<"\nTelefono: "<<telefono
<<"\nLugar de Est.: "<<lugar
<< endl;
}
//************************ EJECUTIVO
****************************************
class Ejecutivo : public Empleado{
public:
Ejecutivo(char *, int, char *, char *, char *, char *);
void VerNombre();
protected:
char deprt[20];
};
Ejecutivo::Ejecutivo(char *n, int ed, char *dir, char *tel, char *car, char *dep) :
Empleado(n, ed, dir, tel, car) {
strcpy(deprt, dep);
}

void Ejecutivo::VerNombre() {
cout << "Ejecutivo: " << nombre
<<"\nEdad: "<<edad
<<" años\nDireccion: "<<direccion
 <<"\nTelefono: "<<telefono
<<"\nCargo: "<<cargo
<<"\nDepartamento: "<<deprt
<< endl;
}
//************************* EMPLEADO
***************************************
class Comercial : public Empleado{
public:
Comercial(char *, int , char *, char *, char *, char *);
void VerNombre();
protected:
char ruta[30];
};
Comercial::Comercial(char *n, int ed, char *dir, char *tel, char *car, char *rut) :
Empleado(n, ed, dir, tel, car) {
strcpy(ruta, rut);
}

void Comercial::VerNombre() {
cout << "Comercial: " << nombre
<<"\nEdad: "<<edad
<<" años\nDireccion: "<<direccion
<<"\nTelefono: "<<telefono
<<"\nCargo: "<<cargo
<<"\nRuta: "<<ruta
<< endl;
}
//************************* MAIN
******************************************
int main() {

Persona *Per = new Persona("Pepito Peña", 14, "El Salvador, San Salvador, Apopa",
"2136-9865");
Estudiante *Est = new Estudiante("Vicente Fernandez", 25, "Recidencial Univercitaria",
"2235-6896", "Univercidad de El Salvador");
Empleado *Emp = new Empleado("Vilma Palma", 45, "San Miguel, Santa Rosa de Lima",
"2569-9898", "Limpiesa");
Ejecutivo *Eje = new Ejecutivo("Ernesto Solorsano", 35, "San Miguel de Mercedes",
"2301-0838", "Presidente", "Relaciones Publicas");
Comercial *Com = new Comercial("Estela Echeverria", 25, "La Paz, El Salvador", "2569-
0008", "Vendedora", "Centro, S. Salvador");

cout<<'\n';
Per->VerNombre();
cout<<'\n';
Est->VerNombre();
cout<<'\n';
Emp->VerNombre();
cout<<'\n';
Eje->VerNombre();
cout<<'\n';
Com->VerNombre();

cout<<'\n';

delete Per;
delete Est;
delete Emp;
delete Eje;
delete Com;

//cin.get();

return 0;
}
 Conclusión

La herencia es, seguramente, la característica más potente de la POO, después de las

clases. Por herencia conocemos el proceso de crear nuevas clases, llamadas clases
derivadas, a partir de una clase base.

En C++ la herencia se manifiesta con la creación de un tipo definido por el usuario

(clase), que puede heredar las características de otra clase ya existente o derivar las
suyas a otra nueva clase. Cuando se hereda, las clases derivadas reciben las
características (estructuras de datos y funciones) de la clase original, a las que se
pueden añadir nuevas características o modificar las características heredadas. El
compilador hace realmente una copia de la clase base en la nueva clase derivada y
permite al programador añadir o modificar miembros sin alterar el código de la clase
base.

La derivación de clases consigue la reutilización efectiva del código de la clase base

para sus necesidades. Si se tiene una clase base totalmente depurada, la herencia
ayuda a reutilizar ese código en una nueva clase. No es necesario comprender el código
fuente de la clase original, sino sólo lo que hace.