Prácticas de C++

Anuncio
Prácticas de C++
Practica Nº 12
Informática II
Fundamentos de Programación
Prof. Dr. Paul Bustamante
Practica Nº 12 Programación en C++
Pág. 1
ÍNDICE
ÍNDICE ........................................................................................................................................ 1
1. Introducción...................................................................................................................... 1
1.1
Ejercicio 1: Herencia I................................................................................................ 1
1.2
Ejercicio 1: 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 <iostream.h>
class Empleado {
private:
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=""):Empleado(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º 12 Programación en C++
Pág. 2
// Fichero main.cpp
#include <string.h>
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();
}
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 (los cuales debe agregar con el fin del estudio).
1.2 Ejercicio 1: 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:
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.
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 otras funciones no miembro de la clase:
char *AsignarCadena(char *pref );
A continuación se dan las características y el código de cada clase:
Informática II – Fundamentos de Programación - Tecnun
Practica Nº 12 Programación en C++
Pág. 3
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 *pA=0, char *pE=0, char *pR=0, char *pT=0);
~CFichaLibro(){ delete [] pAutor; delete [] pEditorial; }
void VisualizarFicha();
};
//FichaLibro.cpp
CFichaLibro::CFichaLibro( char *pR, char *pT, char *pA, char *pE)
{
Informática II – Fundamentos de Programación - Tecnun
Practica Nº 12 Programación en C++
Pág. 4
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(pA,pE,pR,pT)
{
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
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:
Informática II – Fundamentos de Programación - Tecnun
Practica Nº 12 Programación en C++
//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 sgte. Forma:
Figura 2 Salida por consola del ejercicio 2
Informática II – Fundamentos de Programación - Tecnun
Pág. 5
Descargar