Prácticas de C++

Prácticas de C++
Practica Nº 07
Informática II
Fundamentos de Programación
Prof. Dr. Paul Bustamante
Practica Nº 07 Programación en C++
Pág. 1
ÍNDICE
ÍNDICE ........................................................................................................................................ 1
1. Introducción...................................................................................................................... 1
1.1
Ejercicio 1: Herencia I................................................................................................ 1
1.2
Ejercicio 2: Estudio del ejercicio Herencia I.............................................................. 2
1.3
Ejercicio 3: Herencia II .............................................................................................. 2
1. Introducción.
En esta práctica vamos a hacer algunos ejercicios de un nuevo tema: Herencia, visto
esta semana en las clases de teoría.
1.1 Ejercicio 1: Herencia I
En este ejercicio se van a aplicar los primeros
conceptos de herencia dados en clase, para lo
cual vamos a utilizar la Clase Empleado y
derivar a partir de ella la jerarquía de clases
de la siguiente figura. Debe Crear un proyecto
llamado Ejer1 y los ficheros *.h y *.cpp de
cada una de las clases.
A continuación se reproducen los
ficheros del primer proyecto de la práctica:
// Fichero Empleado1.h
Empleado
Operario
Oficial
Directivo
Tecnico
Figura 1 Jerarquía de clases
#include <string.h>
class Empleado {
protected:
char nombre[40];
public:
Empleado(char *name=""){ strcpy(nombre,name); }
void imprime_cargo(){
cout << " Cargo no definido" << endl;
}
char *GetName(){ return nombre;}
};
// En este caso, al tener sólo una función y ser ésta muy simple
// se ha decidido implementar todas las funciones como "inline"
class Directivo : public Empleado {
public:
Directivo(char *name=""){ strcpy(nombre,name); }
void imprime_cargo(){ cout << " es un directivo"<<endl; }
};
Debe implementar las demás clases con el fin de poder poner el siguiente código en
main().
Informática II – Fundamentos de Programación - Tecnun
Practica Nº 07 Programación en C++
Pág. 2
// Fichero main.cpp
// incluir ficheros .h que sean necesarios
void main()
{
Empleado
Directivo
Operario
Oficial
Tecnico
Rafa("Rafa");
Mario("Mario");
Anton("Anton");
Luis("Luis");
Pablo("Pablo");
// El tipo del objeto determina la función que se llama
cout << "Con nombres de objetos:\n" << endl;
cout << Rafa.GetName();
Rafa.imprime_cargo();
cout << Mario.GetName();
Mario.imprime_cargo();
cout << Anton.GetName();
Anton.imprime_cargo();
cout << Luis.GetName();
Luis.imprime_cargo();
cout << Pablo.GetName();
Pablo.imprime_cargo();
}
Compile el proyecto y ejecútelo, observando la salida por consola.
1.2 Ejercicio 2: Estudio del ejercicio Herencia I
En este ejercicio es importante que pueda ver la secuencia de creación de objetos, según el
orden cómo se van ejecutando los constructores y destructores. Para ello debe poner en los
constructores el código para que saque por consola qué constructor se está ejecutando. Debe
hacer lo mismo con los destructores. Observará que la secuencia de creación y destrucción de
objetos es inversa, esto es, los constructores de las clases base se ejecutan primero, mientras
que los destructores de las clases base son los últimos en ejecutarse.
Utilice el proyecto anterior para hacer este ejercicio.
1.3 Ejercicio 3: Herencia II
Este ejercicio consiste en hacer
uso de la herencia, para lo cual
va a crear una clase CFicha que
será la clase base, a partir de la
cual empezará a derivar para
hacer las demás clases. Tenga en
cuenta que la clase CFichaLibro
es clase derivada de CFicha y es
clase base a su vez de la clase
CFichaVolumen.
CFicha
CFichaLibro
CFichaRevista
CFichaVolumen
Cada clase debe tener sus propios ficheros (usar Insert-New class para crear las clases):
Clase
CFicha
CFichaRevista
CFichaLibro
CFichaVolumen
Ficheros
Ficha.h, Ficha.cpp
FichaRevista.h, FichaRevista.cpp
FichaLibro.h, FichaLibro.cpp
FichaVolumen.h, FichaVolumen.cpp
El programa principal main() debe estar en el fichero Biblioteca.cpp.
Informática II – Fundamentos de Programación - Tecnun
Practica Nº 07 Programación en C++
Pág. 3
La clase Base CFicha tiene una función miembro que heredan todas las clases y la utilizan de
forma directa, ya que está declarada como protected, lo que hace que a su vez no sea accedida
por otra función no miembro de la clase:
char *AsignarCadena(char *pref );
A continuación se dan las características y el código de cada clase:
Clase CFicha: Las características son:
1. Dos variables puntero miembro para almacenar la Referencia y el Título de la
ficha.
2. Un método AsignarCadena para la reserva de memoria dinámica.
3. Un método VisualizarFicha para sacar los datos por consola.
4. El constructor y destructor (en él se libera la memoria asignada desde el
constructor).
Clase CFicha
//Ficha.h
class CFicha
{
protected:
char *pRef, *pTitulo;
protected:
char *AsignarCadena(char *pref);
public:
CFicha(char *r=0, char *tit=0);
~CFicha(){ delete [] pRef;
delete [] pTitulo; }
void VisualizarFicha();
};
//Ficha.cpp
CFicha::CFicha(char *pr, char *pt)
{
pRef = AsignarCadena(pr);
pTitulo = AsignarCadena(pt);
}
char *CFicha::AsignarCadena( char *pcad)
{
char *tmp;
if (pcad == NULL) return NULL;
tmp = new char[strlen(pcad)+1];
strcpy(tmp,pcad);
return tmp;
}
void CFicha::VisualizarFicha()
{
cout <<"\tRef: " << pRef << endl;
cout <<"\tTitulo: "<<pTitulo<<endl;
}
Clase CFichaLibro: Las características son:
1. Clase derivada de la clase CFicha.
2. Dos variables miembro puntero para almacenar el Autor y la Editorial del Libro.
3. Redefinir el método VisualizarFicha para sacar por consola los datos del libro. En
este método usamos también el VisualizarFicha de la clase base, para no tener que
escribir más código.
4. El constructor y destructor para asignar y liberar memoria.
// FichaLibro.h
class CFichaLibro: public CFicha
{
protected:
char *pAutor, *pEditorial;
public:
CFichaLibro( char *pR=0, char *pT=0, char *pA=0, char *pE=0);
Informática II – Fundamentos de Programación - Tecnun
Practica Nº 07 Programación en C++
};
Pág. 4
~CFichaLibro(){ delete [] pAutor; delete [] pEditorial; }
void VisualizarFicha();
//FichaLibro.cpp
CFichaLibro::CFichaLibro( char *pR, char *pT, char *pA, char *pE)
{
pAutor = AsignarCadena(pA);
//autor
pEditorial = AsignarCadena(pE);
//editorial
pRef = AsignarCadena(pR);
//referencia (de clase base)
pTitulo = AsignarCadena(pT);
//titulo
//puede utilizar la llamada al constructor de la clase base para
asignar los datos
}
void CFichaLibro::VisualizarFicha()
{
cout << "Libro:" << endl;
CFicha::VisualizarFicha();
//de clase base CFicha
cout << "\tAutor: " << pAutor << endl;
cout << "\tEditorial: " << pEditorial << endl;
}
Clase CFichaRevista: Las características son:
1. Clase derivada de la clase CFicha.
2. Dos variables miembro int Anyo, NumRevista, para representar el año y el número
de la revista.
3. Redefinir el método VisualizarFicha, al igual que el de CFichaLibro, para
representar los datos de la revista en la consola.
4. El constructor para copiar los datos. No es necesario destructor.
Clase CFichaVolumen: Las características son:
1. Clase derivada de la clase CFichaLibro, con lo cual hereda todo lo de
CFichaLibro y CFicha.
2. Sólo tendrá una variable miembro tipo int para representar el número del volumen
(int NroVolumen), el cual debe ser también pedido en el constructor.
3. Redefinir el método VisualizarFicha y que llame a su vez al mismo método de
CFichaLibro (el cual llama a su vez al método VisualizarFicha de CFicha).
4. El constructor adecuado para asignar los datos (Tampoco es necesario un
destructor, ya que en esta clase no se asigna memoria, se hace en CFichaLibro).
5. Un nuevo método PedirDatos() para que el usuario pueda introducir todos los
datos del volumen: NroVolumen, Autor, Editorial, Titulo y Referencia.
Desde el constructor de una clase derivada se puede invocar al constructor de la clase base, de
la siguiente forma, para dejarle que él haga las asignaciones correspondientes:
CFichaVolumen::CFichaVolumen(int num, char*pA,char *pE, char *pR, char *pT)
:CFichaLibro(pR,pT,pA,pE)
{
NroVolumen = num;
}
Como la clase CFichaVolumen deriva de CFichaLibro, se puede invocar
directamente al constructor de dicha clase para pasarle las variables. Esto se hace antes de las
Informática II – Fundamentos de Programación - Tecnun
Practica Nº 07 Programación en C++
Pág. 5
llaves { }. Entonces, en nuestro constructor lo único que copiamos es la variable NroVolumen
de esta clase.
A continuación se da el código de main(), en el cual se construyen tres objetos de cada
clase. De la clase base no se construye ningún objeto. Hace falta agregar los correspondientes
ficheros de cabecera de cada una de las clases:
//Biblioteca.cpp
#include <iostream.h>
#include “fichalibro.h”
#include “ficharevista.h”
#include “fichavolumen.h”
void main()
{
CFichaLibro lib1("1111","Visual C++","Ceballos","RAMA");
CFichaRevista rev1("1112","Programming C++",2000, 9);
CFichaVolumen vol1(1,"1113","C++","Bjarne","Addison");
CFichaVolumen vol2;
Vol2.PedirDatos();
//visualizar todos los datos
lib1.VisualizarFicha();
rev1.VisualizarFicha();
vol1.VisualizarFicha();
vol2.VisualizarFicha();
}
La salida por consola sería de la siguiente forma:
Figura 2 Salida por consola
Informática II – Fundamentos de Programación - Tecnun