República Bolivariana de Venezuela

Universidad Nacional Experimental del Táchira

Departamento de Ingeniería Informática

Computacion II-Ingeniería Electrónica (415201)

San Cristóbal-Venezuela

Tema Perteneciente a la II Unidad: Programación Orientada a Objetos en C++.

Autor: Lcdo. José Froilán Guerrero Pulido

Mayo, 2005

En un material previo se definio la herencia como la habilidad que tiene una clase derivada de heredar las características de una clase base existente. En este material se indicará la manera de cómo programar una herencia simple y múltiple, y una cadena de herencia respectivamente.

Herencia Simple

Sintaxis:

class BASE

{

public:

BASE (tipo_dato1,...,tipo_datoN);

:

//Otros métodos

private:

tipo_dato atributo1;

:

tipo_dato atributoN;

};

class DERIVADA: public BASE

{

public:

DERIVADA (tipo_dato1,...,tipo_datoM);

:

//Otros métodos

private:

tipo_dato atributo[N+1];

:

tipo_dato atributoM;

};

DERIVADA::DERIVADA (tipo_dato param1,... ,tipo_dato paramM)

:BASE (param1,... ,paramN) //No incluye el tipo de dato

{

//Asignación de los valores de los parámetros

//a los atributos de la clase derivada

}

//Cuerpo Principal

DERIVADA identificador (valor1,...,valorM);

Herencia Múltiple

Sintaxis:

class BASE1

{

public:

BASE1 (tipo_dato1,...,tipo_datoN);

:

//Otros métodos

private:

tipo_dato atributo1;

:

tipo_dato atributoN;

};

class BASE2

{

public:

BASE2 (tipo_dato[N+1],...,tipo_datoM);

:

//Otros métodos

private:

tipo_dato atributo[N+1];

:

tipo_dato atributoM;

};

class DERIVADA: public BASE1, public BASE2

{

public:

DERIVADA (tipo_dato1,...,tipo_datoK);

:

//Otros métodos

private:

tipo_dato atributo[M+1];

:

tipo_dato atributoK;

};

DERIVADA::DERIVADA (tipo_dato param1,...,tipo_dato paramK)

:BASE1 (param1,... ,paramN), BASE2 (param[N+1],... ,paramM)

{

//Asignación de los valores de los parámetros

//a los atributos de la clase derivada

};

//Cuerpo Principal

DERIVADA identificador (valor1,...,valorK);

Cadena de Herencia

Por otro lado, C++ proporciona miembros protegidos (protected) a los que se puede tener acceso mediante los métodos de la clase base y la clase derivada.

Ejercicios Resueltos

//Programa 1: Herencia simple entre la clase base EMPLEADO y la clase derivada //GERENTE.

#include <iostream.h>

#include <string.h>

#include <conio.h>

class empleado

{

public:

empleado(char *, char *, float);

void mostrar_empleado(void);

private:

char nombre[15], puesto[15];

float salario;

};

class gerente:public empleado

{

public:

gerente(char *, char *, char *, float, float, int);

void mostrar_gerente(void);

private:

float bono;

char automovil[15];

int acciones;

};

empleado::empleado(char *t_nom, char *t_pue, float t_sal)

{

strcpy(nombre, t_nom);

strcpy(puesto, t_pue);

salario = t_sal;

}

void empleado::mostrar_empleado(void)

{

cout << "\nNombre: " << nombre << endl;

cout << "Puesto: " << puesto << endl;

cout << "Salario: Bs." << salario << endl;

}

gerente::gerente(char *t_nom, char *t_pue, char *t_aut, float t_sal, float t_bono,

int t_acc):empleado(t_nom,t_pue,t_sal)

{

strcpy(automovil, t_aut);

bono = t_bono;

acciones = t_acc;

}

void gerente::mostrar_gerente(void)

{

mostrar_empleado();

cout << "Automóvil de la Empresa: " << automovil << endl;

cout << "Bonificacion Anual: Bs." << bono << endl;

cout << "Acciones de la Empresa: " << acciones << endl;

}

void main()

{

empleado trabajador("Juan Pérez","Programador",850000);

gerente jefe("Carmen Gómez","Vicepresidente","Corsa",2500000,30000,500);

trabajador.mostrar_empleado();

jefe.mostrar_gerente();

cout<<"\nPresione una Tecla para Continuar";

getch();

}

//Programa 2: Herencia simple entre la clase base LIBRO y la clase derivada //FICHA_PRESTAMO.

#include <iostream.h>

#include <string.h>

#include <conio.h>

class libro

{

public:

libro(char *, char *, int);

void mostrar_libro(void);

private:

char titulo[20], autor[20];

int paginas;

};

class ficha_prestamo : public libro

{

public:

ficha_prestamo(char *, char *, int, int, int);

void mostrar_ficha(void);

private:

int entrega; // Número de días del préstamo

int prestado; // 1 si ha sido prestado, de otra manera 0

};

libro::libro(char *t_tit, char *t_aut, int t_pag)

{

strcpy(titulo, t_tit);

strcpy(autor, t_aut);

paginas = t_pag;

}

void libro::mostrar_libro(void)

{

cout << "Título: " << titulo << endl;

cout << "Autor: " << autor << endl;

cout << "Páginas: " << paginas << endl;

}

ficha_prestamo::ficha_prestamo(char *t_tit, char *t_aut, int t_pag, int t_ent,

int t_pre):libro(t_tit, t_aut, t_pag)

{

entrega = t_ent;

prestado = t_pre;

}

void ficha_prestamo::mostrar_ficha(void)

{

mostrar_libro();

cout << "Numero de dias del Prestamo: " << entrega << endl;

if (prestado)

cout << "Estado: No disponible" << endl;

else

cout << "Estado: Disponible" << endl;

}

void main()

{

ficha_prestamo ficha("Herencia en C++","Carmen Cordero",272,3,0);

ficha.mostrar_ficha();

cout<<"\nPresione una Tecla para Continuar";

getch();

}

//Programa 3: Herencia simple entre la clase base EMPLEADO y la clase derivada //GERENTE. Uso de la parte protegida en la clase base.

#include <iostream.h>

#include <string.h>

#include <conio.h>

class empleado

{

public:

void mostrar_empleado(void);

protected:

char nombre[15], puesto[15];

float salario;

};

class gerente:public empleado

{

public:

gerente(char *, char *, char *, float, float, int);

void mostrar_gerente(void);

private:

float bono;

char automovil[15];

int acciones;

};

void empleado::mostrar_empleado(void)

{

cout << "Nombre: " << nombre << endl;

cout << "Puesto: " << puesto << endl;

cout << "Salario: Bs." << salario << endl;

}

gerente::gerente(char *t_nom, char *t_pue, char *t_aut, float t_sal, float t_bono,int t_acc)

{

strcpy(nombre, t_nom);

strcpy(puesto, t_pue);

salario = t_sal;

strcpy(automovil, t_aut);

bono = t_bono;

acciones = t_acc;

}

void gerente::mostrar_gerente(void)

{

mostrar_empleado();

cout << "Automóvil de la Empresa: " << automovil << endl;

cout << "Bonificacion Anual: Bs." << bono << endl;

cout << "Acciones de la Empresa: " << acciones << endl;

}

void main()

{

gerente jefe("Carmen Gómez","Vicepresidente","Corsa",2500000,30000,500);

jefe.mostrar_gerente();

cout<<"\nPresione una Tecla para Continuar";

getch();

}

//Programa 4: Herencia simple entre la clase base LIBRO y la clase derivada //FICHA_PRESTAMO. Uso de la parte protegida en la clase base.

#include <iostream.h>

#include <string.h>

#include <conio.h>

class libro

{

public:

libro(char *, char *, int);

protected:

char titulo[20], autor[20];

int paginas;

};

class ficha_prestamo : public libro

{

public:

ficha_prestamo(char *, char *, int, int, int);

void mostrar_ficha(void);

private:

int entrega; // Número de días del préstamo

int prestado; // 1 si ha sido prestado, de otra manera 0

};

libro::libro(char *t_tit, char *t_aut, int t_pag)

{

strcpy(titulo, t_tit);

strcpy(autor, t_aut);

paginas = t_pag;

}

ficha_prestamo::ficha_prestamo(char *t_tit, char *t_aut, int t_pag, int t_ent,

int t_pre):libro(t_tit, t_aut, t_pag)

{

entrega = t_ent;

prestado = t_pre;

}

void ficha_prestamo::mostrar_ficha(void)

{

cout << "Título: " << titulo << endl;

cout << "Autor: " << autor << endl;

cout << "Páginas: " << paginas << endl;

cout << "Numero de dias del Prestamo: " << entrega << endl;

if (prestado)

cout << "Estado: No disponible" << endl;

else

cout << "Estado: Disponible" << endl;

}

void main()

{

ficha_prestamo ficha("Herencia en C++","Carmen Cordero",272,3,0);

ficha.mostrar_ficha();

cout<<"\nPresione una Tecla para Continuar";

getch();

}

//Programa 5: Herencia simple entre la clases base EMPLEADO y la clases derivadas

//ASALARIADO, POR_HORA y TEMPORAL.

#include <iostream.h>

#include <string.h>

#include <conio.h>

class empleado

{

public:

empleado (char *, char *, char *, char *);

void mostrar_empleado (void);

private:

char nombre [20];

char telefono_casa [20];

char telefono_oficina [20];

char reporta_a [20];

};

class asalariado : public empleado

{

public:

asalariado (char *, char *, char *, char *, float, float, char *);

void mostrar_asalariado (void);

private:

float salario;

float nivel_de_primas;

char asistente [20];

};

class por_hora : public empleado

{

public:

por_hora (char *, char *, char *, char *,float);

void mostrar_por_hora (void);

private:

float sueldo;

};

class temporal : public empleado

{

public:

temporal (char *, char *, char *, char *, float);

void mostrar_temporal (void);

private:

float sueldo;

};

empleado::empleado (char *t_nom, char *t_casa, char *t_oficina, char *t_rep)

{

strcpy (nombre, t_nom);

strcpy (telefono_casa, t_casa);

strcpy (telefono_oficina, t_oficina);

strcpy (reporta_a, t_rep);

}

void empleado::mostrar_empleado (void)

{

cout << "Nombre: " << nombre << endl;

cout << "Teléfono de casa: " << telefono_casa <<endl;

cout << "Teléfono de oficina: " << telefono_oficina << endl;

cout << "Reporta a:" << reporta_a << endl;

}

asalariado::asalariado (char *t_nom, char *t_casa, char *t_oficina, char *t_rep,

float t_sal, float t_primas, char *t_asi) :

empleado (t_nom, t_casa, t_oficina, t_rep)

{

salario = t_sal;

nivel_de_primas = t_primas;

strcpy (asistente, t_asi);

}

void asalariado:: mostrar_asalariado (void)

{

mostrar_empleado ( ) ;

cout << "Salario: Bs." << salario << endl;

cout << "Nivel de primas: Bs." << nivel_de_primas << endl;

cout << "Asistente: " << asistente << endl;

}

por_hora::por_hora (char *t_nom, char *t_casa, char *t_oficina, char *t_rep,

float t_sue) : empleado (t_nom, t_casa, t_oficina, t_rep)

{

sueldo = t_sue;

}

void por_hora::mostrar_por_hora (void)

{

mostrar_empleado ();

cout << "Sueldo: Bs." << sueldo << endl;

}

temporal::temporal (char *t_nom, char *t_casa, char *t_oficina, char *t_rep,

float t_sue) : empleado (t_nom, t_casa, t_oficina, t_rep)

{

sueldo = t_sue;

}

void temporal :: mostrar_temporal (void)

{

mostrar_empleado ( );

cout << "Sueldo: Bs." << sueldo << endl;

}

void main (void)

{

asalariado gerente ("Joel Pérez", "555-1111", "555-1112", "Marco López",

3000000, 10000.0, "Alicia Hernández");

por_hora plomero ("David García", "555-2222", "555-2223", "Marco Sánchez", 45000);

temporal recepcionista ("María Flores","555-3333","555-3334","Dora Galván", 40000);

gerente.mostrar_asalariado();

cout << endl << endl;

plomero.mostrar_por_hora();

cout << endl << endl;

recepcionista.mostrar_temporal();

cout<<"\nPresione una Tecla para Continuar";

getch();

}

//Programa 6: Herencia múltiple entre la clases base MONITOR y TARJETA y la clase

//derivada COMPUTADORA.

#include <iostream.h>

#include <string.h>

#include <conio.h>

class monitor

{

public:

monitor(char *, long, int, int);

void mostrar_pantalla(void);

private:

char tipo[32];

long colores;

int resolucion_x;

int resolucion_y;

};

class tarjeta

{

public:

tarjeta(int, int);

void mostrar_tarjeta(void);

private:

int procesador;

int velocidad;

};

class computadora : public monitor, public tarjeta

{

public:

computadora(char *, int, float, char *, long, int, int,int, int);

void mostrar_computadora(void);

private:

char marca[25];

int disco_duro; //Capacidad de almacenamiento.

float disco_flexible; //Capacidad de almacenamiento.

};

monitor::monitor(char *t_tipo, long t_col,int x_res, int y_res)

{

strcpy(tipo, t_tipo);

colores = t_col;

resolucion_x = x_res;

resolucion_y = y_res;

}

void monitor::mostrar_pantalla(void)

{

cout << "Tipo de video: " << tipo << endl;

cout << "Colores: " << colores << endl;

cout << "Resolucion: " << resolucion_x << " por "<< resolucion_y << endl;

}

tarjeta::tarjeta(int t_pro,int t_vel)

{

procesador = t_pro;

velocidad = t_vel;

}

void tarjeta::mostrar_tarjeta(void)

{

cout << "Procesador: " << procesador << endl;

cout << "Velocidad: " << velocidad << " Mhz" << endl;

}

computadora::computadora(char *t_mar, int t_duro, float t_fle, char *t_pan, long t_col,int res_x, int res_y, int t_pro, int t_vel): monitor (t_pan, t_col,res_x, res_y), tarjeta(t_pro, t_vel)

{

strcpy(marca, t_mar);

disco_duro = t_duro;

disco_flexible = t_fle;

}

void computadora::mostrar_computadora(void)

{

cout << "Marca: " << marca << endl;

cout << "Disco Duro: " << disco_duro << " GB" << endl;

cout << "Unidad de disquete: " << disco_flexible << " MB" << endl;

mostrar_tarjeta();

mostrar_pantalla();

}

void main()

{

computadora mipc("Compaq",12,1.44,"VGA",16000000,800,600,586,133);

mipc.mostrar_computadora();

cout<<"\nPresione una Tecla para Continuar";

getch();

}

Ejercicios Propuestos

1. La clase habitación describe una habitación de un edificio, esta clase contiene el tamaño de la habitación (mts²), el número de habitación, y un método que permite mostrar los atributos de la clase. El constructor de la clase se inicializa con instancias dadas por el usuario, y el destructor registra el hecho de que la instancia del objeto ya no se requiere. Una clase oficina se deriva de la clase habitación y describe una oficina de un edificio. La función constructora de la clase derivada se inicializa con los atributos de la clase base y adicionalmente con los atributos largo, ancho, número de empleados y número de computadoras de la oficina, así como del método para mostrar el tamano de la oficina.

2. Modificar el ejercicio número seis resuelto para adicionar la clase derivada “usuario” que contiene los siguientes atributos: nombre de usuario, contraseña y dirección IP; y un método para mostrar todos los atributos contenidos en la cadena hereditaria.

3. Definir una clase base “Persona” que contenga información de propósito general común a todas las personas (atributos: nombre, dirección, fecha de nacimiento y sexo; métodos: constructor de la clase se inicializa con instancias dadas por el usuario a través del teclado, y la respectiva función destructora). Diseñar una jerarquia de clases que contemple las clases siguientes: Estudiante (atributos: especialidad y índice académico; métodos: constructor de la clase se inicializa con instancias dadas por el usuario a través del teclado, la función destructora y una función para listar alfabéticamente los atributos de la cadena) y el Empleado (atributos: cargo, sueldo básico, deducciones; métodos: constructor de la clase se inicializa con instancias dadas por el usuario a través del teclado, la función destructora y una función para calcular el sueldo neto). Los datos deben guardarse en archivos de texto o binarios.

4. Implementar una jerarquía “Empleado” de cualquier tipo de empresa que le sea familiar. La jerarquía debe tener al menos cuatro niveles, con herencia de miembros dato y métodos. Los métodos deben poder calcular salarios, despidos, promoción, jubilación, entre otros. Los métodos deben permitir también calcular aumentos salariales y primas para “Empleados” de acuerdo con su categoría y productividad. La jerarquia de herencia debe poder ser utilizada para proporcionar diferentes tipos de acceso a “Empleados”. Por ejemplo, el tipo de acceso garantizado al público general diferirá del tipo de acceso proporcionado a un supervisor de empleado, el departamento de nóminas, o al Ministerio de Hacienda. Utilice la herencia para distinguir entre al menos cuatro tipos diferentes de acceso a la información de “Empleado”.