Excepciones

Ejercicios propuestos de Programación orientada a objetos con C++

Cristina Cachero Pedro J. Ponce de León

Departamento de Lenguajes y Sistemas Informáticos

Universidad de Alicante

Esta obra está bajo licencia Creative Commons

Programación orientada a objetos Ejercicios propuestos

D.L.S.I. 2 Universidad de Alicante

En cada ejercicio se indica la convocatoria de examen en la que apareció (por ejemplo, DIC05: Convocatoria extraordinaria de Diciembre de 2005).

1. DIC05

(2 puntos) Implementad tanto el .h como el .cpp de la clase taller La función meter (coche o moto) implica introducir el coche en el taller y la función arreglarCoches o arreglarMotos implica recorrer todos los coches y motos que haya y arrancarlos.

1

Coche Int motor;

Coche();

Taller -int max_vehiculos; -int num_vehiculos;

Taller(int); Void meter(vehiculo); Void arreglarVehiculos();

Vehículo String color; String marca;

Vehiculo(); Void arrancar()=0; Void parar()=0; Void repostar()=0;

Moto Int cilindrada;

Moto();

1..*

Programación orientada a objetos Ejercicios propuestos

D.L.S.I. 3 Universidad de Alicante

2. SEP05 (1,5 puntos) Declarad (sólo cabecera), para cada una de las siguientes sentencias A, B y C, qué haría falta añadir a una clase Matriz (implementada mediante undoble puntero a enteros) para que funcionasen correctamente.

int main(){ Matriz c; /*A*/ c[3,5]; //devuelve el elto. En la pos. 3,5 /*B*/ c[3][5]; // idem /*C*/ c(3,5); // idem return (0); };

3. SEP05 (2,5 puntos) Dadas las siguientes definiciones de clase

//------------------------------------------------------------------ // CLASE BASE //------------------------------------------------------------------ class cBase { private: int objeto_base_1; int objeto_base_2; public: cBase(); virtual ~cBase();

void funcion_A(); void funcion_B(); virtual void funcion_C(); virtual void funcion_D() = 0; };

cBase :: cBase() : objeto_base_1(1 ), objeto_base_2(2 ) { cout << "Constructor de BASE" << endl; }

cBase :: ~cBase() { cout << "Destructor de BASE" << endl;}

void cBase :: funcion_A() { cout << "Funcion A de BASE" << endl;}

void cBase :: funcion_B() { cout << "Funcion B de BASE" << endl;}

void cBase :: funcion_C() { cout << "Funcion C de BASE" << endl;}

//------------------------------------------------------------------ // CLASE DERIVADA //------------------------------------------------------------------ class cDerivada : public cBase { private:

Programación orientada a objetos Ejercicios propuestos

D.L.S.I. 4 Universidad de Alicante

int objeto_deriv_1; int objeto_deriv_2; public: cDerivada(); ~cDerivada();

void funcion_A(); void funcion_D(); };

cDerivada :: cDerivada() : cBase(), objeto_deriv_1(3), objeto_deriv_2(4) { cout << "Constructor de DERIVADA" << endl; }

cDerivada :: ~cDerivada() { cout << "Destructor de DERIVADA" << endl;}

void cDerivada :: funcion_A() { cout << "Funcion A de DERIVADA" << endl;}

void cDerivada :: funcion_D() { cout << "Funcion D de DERIVADA" << endl;}

se pide:

a. Especificad qué métodos invoca el siguiente programa.

int main( void ) { cDerivada derivada; cBase *base_ptr = &derivada;

// funcion de base, redefinida en derivada derivada.funcion_A(); base_ptr->funcion_A(); // funcion de base, no redefinida en derivada derivada.funcion_B(); base_ptr->funcion_B(); // funcion virtual de base, no redefinida en derivada derivada.funcion_C(); base_ptr->funcion_C(); // funcion virtual pura de base, redefinida en derivada derivada.funcion_D(); base_ptr->funcion_D();}

Programación orientada a objetos Ejercicios propuestos

D.L.S.I. 5 Universidad de Alicante

4. SEP04

Fig. 2. Diagrama de clases Sistema de Gestión de Bibliotecas

a. Define la función mo s t ra r( ) de la clase Volumen, así como la de la clase Revista (signatura y cuerpo de la función), teniendo en cuenta que dicha función debe comportarse de manera polimórfica. ¿Qué otra circunstancia tiene que darse para que el tipo de la variable que invoca al método no determine el método a utilizar? (2 puntos)

b. Implementa (signatura y código) una función in cluir( . . . ) en la clase Biblioteca que permita añadir con el mismo código tanto una revista como un libro que se le pase como parámetro. (1,5 puntos)

5. DIC03 Supongamos que los diseñadores de nuestra empresa nos entregan el diagrama de clases de la figura:.

+mostrar() : void

#nombre #numVol Volumen

+mostrarBiblioteca() : void +incluir(entrada v : Volumen&) : bool

-maxLibros -maxRevistas Biblioteca

+mostrar() : void --numLibros Libro

+mostrar() : void -numRevistas Revista

1..1 0..*

+C3(entrada p1 : String, entrada p2 : String) +C3(entrada p : C3&) +~C3() +o1() : int

#a1 : String #a2 : String

C3

+C4(entrada p1 : String, entrada p2 : String, entrada p3 : String) +C4(entrada p : C4&) +~C4() +o1() : int -a1 : String C4

+C5(entrada p1 : String, entrada p2 : String, entrada p3 : String) +C5(entrada p : C5&) +~C5() +o1() : int -a1 : String C5

+C2(entrada p : String) +~C2() -a1 : String C2

+C1(entrada p1 : String, entrada p2 : String) +C1(entrada p : C1&) +~C1() +operator=(entrada p : C1&) : C1&

-a1 : String -a2 : String

C1

-c1

1

-c2

0..20

-c30..1

-c20..*

-c3

0..30

-c1*

Programación orientada a objetos Ejercicios propuestos

D.L.S.I. 6 Universidad de Alicante

Barco

virtual void propio() void ver()

Submarino Destructor

Se pide:

a) Implementa la declaración (el .h) y el destructor de C1 (2 puntos)

b) Implementa la declaración y el constructor de copia de la clase C4 (1,5 puntos)

6. DIC04

1.- Supongamos que tenemos definida la jerarquía de herencia de la Fig.1.:

Fig.1: Jerarquía de herencia de Barco

1.a. (2.5 puntos) Especifica qué pasará (a qué clase se referirá la invocación) en los siguientes casos, suponiendo que el método propio() está sobreescrito en las clases derivadas. a) Barco *b=new Barco(); b->propio(); b->ver();

b) Barco *b=new Submarino(); b->propio(); b->ver();

c) Barco *b[]={new Barco(),new Submarino()}; b[0]->propio(); b[1]->propio(); b[0]->ver();

d) Barco *b[]={new Destructor(),new Submarino()}; b[0]->propio(); b[1]->propio();

Programación orientada a objetos Ejercicios propuestos

D.L.S.I. 7 Universidad de Alicante

e) Supongamos que añadimos el método ver() heredado del padre tanto en submarino como en destructor.

Barco *b[]={new Destructor(),new Submarino()}; ((Destructor *)b[0])->ver(); ((Submarino *)b[1])->ver(); b[0]->ver(); b[1]->ver();

1.b. (0,5 puntos) Supongamos ahora que la signatura del método propio es la siguiente: virtual void Barco::propio()=0;

y que además dicho método se sobrescribe en las clases derivadas. ¿Qué pasaría con el siguiente código?

Barco *b[]={new Barco(),new Submarino()}; b[0]->propio(); b[0]->ver(); b[1]->propio(); b[1]->ver();

7. FEB07 (4 puntos) A partir del código en C++ que aparece a continuación, contesta a las siguientes preguntas. No olvides hacer referencia en tus respuestas al número de línea involucrado.

a) ¿Existe algún problema que dé como resultado un error de compilación? Justifica brevemente por qué se produce el error o errores e indica qué líneas de código los producen.

b) ¿Qué tipo de polimorfismo se está utilizando en las definiciones de las clases derivadas respecto a sus clases base? Indica, para cada método definido en las clases derivadas, si se trata de redefinición, shadowing o sobrescritura.

c) En el programa principal, indica mediante su signatura completa qué método es ejecutado en cada instrucción antes del comentario TEST.

d) Por último, indica qué salida produce este programa.

Programación orientada a objetos Ejercicios propuestos

D.L.S.I. 8 Universidad de Alicante

1: #include <iostream> 2: using namespace std; 3: 4: class Padre{ 5: friend ostream& operator<<(ostream& o, const Padre& p) { 6: o << "PADRE" << endl; return o; 7: } 8: public: 9: virtual int ejemplo(int a) {} 10: void ejemplo(int a, int b) {} 11: virtual int otro(int x) {} 12: void otro(int a, int b, int c) {} 13: virtual void print() {} 14:}; 15: 16: class Hija : public Padre{ 17: friend ostream& operator<<(ostream& o, const Hija& p) { 18: o << "HIJA" << endl; return o; 19: } 20: public: 21: int ejemplo (int

...