Programación II. Relación de Ejercicios. Sonido e Imagen. Tema 1: Almacenamiento en Memoria Secundaria. Ficheros 2

Transcripción

1 Programación II Relación de Ejercicios UNIVERSIDAD DE MÁLAGA Dpto. Lenguajes y CC. Computación E.T.S.I. Telecomunicación Sonido e Imagen Contenido Tema : Almacenamiento en Memoria Secundaria. Ficheros Tema : Tipos Abstractos de Datos 3 Tema.: Programacion Modular Tema.: Tipos Abstractos de Datos Tema 3: Gestión de Memoria Dinámica 8 Tema 3.: Listas Enlazadas Tema 3.: Abstracción en la Gestión de Memoria Dinámica Tema 4: Introducción a la Programación Orientada a Objetos 5 Tema 5: Colecciones 9 Prácticas de Laboratorio Práctica : Almacenamiento Persistente de Datos Práctica : Tipos Abstractos de Datos (I) Práctica 3: Tipos Abstractos de Datos (II) Práctica 4: Tipos Abstractos de Datos (III) Práctica 5: Gestión de Memoria Dinámica Práctica 6: Abstracción en la Gestión de Memoria Dinámica (I) Práctica 7: Abstracción en la Gestión de Memoria Dinámica (II) Práctica 8: Introducción a la Programación Orientada a Objetos Práctica 9: La Clase Vector de la Biblioteca Estándar Prácticas de Autoevaluación 4 Gestión de Factoría de Androides Gestión de Tareas Periódicas cc Esta obra se encuentra bajo una licencia Reconocimiento-NoComercial-CompartirIgual 4. Internacional (CC BY-NC-SA 4.) de Creative Commons. Véase

2 Tema : Almacenamiento en Memoria Secundaria. Ficheros. Escribir un programa que cuente el número de letras minúsculas, de letras mayúsculas y de dígitos de un fichero.. Escribir un programa con la opción de encriptar y de desencriptar un fichero de texto, dependiendo de la extensión del fichero de entrada. La encriptación (codificación) consiste en que dado un fichero de texto de entrada (extensión txt) genere otro fichero de salida encriptado (extensión cod). Esta codificación consiste reemplazar cada letra por la tercera siguiente de forma circular (ej. a d, b e,, w z, x a, y b, z c). La opción de desencriptado consiste en leer un fichero codificado (extensión cod) y recuperar la información original en un fichero de texto (extensión txt). 3. Escribir un programa para procesar información sobre los clientes de una agencia matrimonial. El programa debe crear un fichero de texto (cuyo nombre se leerá por teclado) en el que se guarde la información de un número indeterminado de personas. La información que se guardará por cada persona será: Nombre: Edad Género Arte Deporte Libros Música Cadena de caracteres. int. char (M/F). char (S/N). char (S/N). char (S/N). char (S/N). La información correspondiente a cada persona se leerá del teclado. El proceso finalizará cuando se teclee un campo Nombre que esté vacío. 4. Ampliar el programa que procesa clientes de una agencia matrimonial para que tome los datos de todos los candidatos a estudiar del fichero del ejercicio anterior, lea el cliente del teclado y finalmente genere como resultado un fichero (cuyo nombre será leído desde teclado) con toda la información correspondiente a los candidatos aceptados. Una persona del fichero de entrada se considerará aceptable como candidato si tiene diferente género y por lo menos tres aficiones comunes con respecto al aspirante introducido por pantalla. (El programa debe ser capaz de trabajar con cualquier número de personas en el fichero de entrada). 5. Codifique un programa que cree un fichero para contener los datos relativos a los artículos de un almacén. Para cada artículo habrá de guardar la siguiente información: Código del artículo Nombre del artículo Existencias Precio Numérico Cadena de caracteres Numérico Numérico Se deberá pedir datos de cada artículo por teclado hasta que se teclee (cero) como código de artículo. 6. Escriba un programa que tome como entrada el fichero del ejercicio anterior y una condición sobre los campos existencias o precio. La condición podrá ser: <campo> [<,<=,>,>=, ==,! =] <número> Este programa debe generar como salida un fichero que contenga todos aquellos artículos para los que se cumple la condición de entrada.

3 Tema : Tipos Abstractos de Datos Tema.: Programacion Modular Diseñe e implemente los siguientes Módulos, dentro del espacio de nombres umalcc, así como programas de utilización que permitan comprobar su funcionamiento.. Diseñe un módulo que proporcione soporte adecuado a la arímetica con números complejos. El módulo deberá definir el tipo Complejo, así como los siguientes subprogramas: void sumar ( Complejo & r, const Complejo & a, const Complejo & b) ; // Devuelve un numero complejo ( r ) que c o n t i e n e e l r e s u l t a d o de // sumar l o s numeros complejos ( a ) y ( b ). void restar ( Complejo & r, const Complejo & a, const Complejo & b) ; // Devuelve un numero complejo ( r ) que c o n t i e n e e l r e s u l t a d o de // r e s t a r l o s numeros complejos ( a ) y ( b ). void multiplicar ( Complejo & r, const Complejo & a, const Complejo & b) ; // Devuelve un numero complejo ( r ) que c o n t i e n e e l r e s u l t a d o de // m u l t i p l i c a r l o s numeros complejos ( a ) y ( b ). void dividir ( Complejo & r, const Complejo & a, const Complejo & b) ; // Devuelve un numero complejo ( r ) que c o n t i e n e e l r e s u l t a d o de // d i v i d i r l o s numeros complejos ( a ) y ( b ). bool iguales ( const Complejo & a, const Complejo & b) ; // Devuelve t r u e s i l o s numeros complejos ( a ) y ( b ) son i g u a l e s. void escribir ( const Complejo & a) ; // Muestra en p a n t a l l a e l numero complejo ( a ) void leer ( Complejo & a) ; // Lee de t e c l a d o e l v a l o r d e l numero complejo ( a ). // Lee l a p a r t e r e a l y l a p a r t e imaginaria d e l numero. Diseñe un módulo que proporcione soporte adecuado a la arímetica con números racionales. El módulo deberá definir el tipo Racional, así como los subprogramas adecuados teniendo en cuenta las siguientes consideraciones: Los números racionales se representan mediante fracciones, donde tanto el numerador como denominador son de tipo int). Las fracciones se representarán en todo momento normalizadas (simplificadas): Es recomendable implementar un subprograma privado de simplificación de la fracción mediante el cálculo del máximo común divisor (m.c.d.) del numerador y el denominador y su posterior división por dicho m.c.d. Para calcular el máximo común divisor de dos numeros enteros positivos n y m, el algoritmo de Euclides funciona como se indica a continuación: a) Si n < m, entonces se intercambian los valores de n y m (para asegurarnos que n siempre sea mayor o igual que m). b) Si el valor de m es distinto de, entonces sea r el resto de la división entera entre n y m; después modificamos los valores de n y m de la siguiente forma: n toma ahora el valor de m y m toma ahora el valor de r (el resto de la división entera entre n y m calculado anteriormente), y se repite este proceso especificado hasta que el valor de m sea igual a. c) Finalmente, cuando el proceso iterativo acaba, el valor de n es el máximo común divisor de ambos números. Para simplificar la determinación del signo de la fracción puede asumirse que el denominador de la fracción es siempre positivo (por lo que una fracción de signo negativo tendrá un numerador de signo negativo y un denominador de signo positivo). El número cero se guardará siempre en su forma canónica /. Debe evitarse en todo momento la asignación de cero a un denominador. Debe proporcionar subprogramas para leer, escribir, sumar, restar, multiplicar y dividir fracciones. Pueden también suministrarse métodos para comparación de números racionales (iguales, menor, etc). void sumar ( Racional & r, const Racional & r, const Racional & r ); // Asigna a l numero r a c i o n a l ( r ) e l r e s u l t a d o de // sumar l o s numeros r a c i o n a l e s ( r ) y ( r ) void restar ( Racional & r, const Racional & r, const Racional & r ); 3

4 // Asigna a l numero r a c i o n a l ( r ) e l r e s u l t a d o de // r e s t a r l o s numeros r a c i o n a l e s ( r ) y ( r ) void multiplicar ( Racional & r, const Racional & r, const Racional & r ); // Asigna a l numero r a c i o n a l ( r ) e l r e s u l t a d o de // m u l t i p l i c a r l o s numeros r a c i o n a l e s ( r ) y ( r ) void dividir ( Racional & r, const Racional & r, const Racional & r ); // Asigna a l numero r a c i o n a l ( r ) e l r e s u l t a d o de // d i v i d i r l o s numeros r a c i o n a l e s ( r ) y ( r ) void escribir ( const Racional & r); // Muestra en p a n t a l l a e l v a l o r d e l numero r a c i o n a l ( r ) void leer ( Racional & r); // Lee de t e c l a d o e l v a l o r d e l numero r a c i o n a l ( r ) bool igual ( const Racional & r, const Racional & r ); // Devuelve t r u e s i e l numero r a c i o n a l ( r ) es i g u a l a ( r ) bool menor ( const Racional & r, const Racional & r ); // Devuelve t r u e s i e l numero r a c i o n a l ( r ) es menor que ( r ) 3. Diseñe un módulo que proporcione soporte adecuado a la manipulación de polinomios de grados positivos menores que. El módulo deberá definir el tipo Polinomio, así como las siguientes operaciones: double evaluar ( const Polinomio & a, double x); // Devuelve e l r e s u l t a d o de e v a l u a r e l polinomio ( a ) // para un v a l o r de ( x ) e s p e c i f i c a d o como parametro void derivar ( Polinomio & r, const Polinomio & a); // PRECOND: (&r!= &a ) // Devuelve un polinomio ( r ) que c o n t i e n e e l r e s u l t a d o de // c a l c u l a r l a d e r i v a d a d e l polinomio ( a ) void sumar ( Polinomio & r, const Polinomio & a, const Polinomio & b); // PRECOND: ((& r!= &a)&&(&r!= &b ) ) // Devuelve un polinomio ( r ) que c o n t i e n e e l r e s u l t a d o de // sumar l o s polinomios ( a ) y ( b ) void escribir ( const Polinomio & a) ; // Muestra en p a n t a l l a e l contenido d e l polinomio ( a ) void leer ( Polinomio & a) ; // Lee de t e c l a d o e l v a l o r d e l polinomio ( a ) // Lee pares de c o e f i c i e n t e y grado hasta que e l c o e f i c i e n t e sea cero Tema.: Tipos Abstractos de Datos Diseñe e implemente los siguientes TADs, dentro del espacio de nombres umalcc, así como programas de utilización que permitan comprobar su funcionamiento.. TAD número complejo que defina los siguientes métodos públicos: class Complejo { public : Complejo () ; // Constructor por Defecto Complejo ( double parte_real, double parte_imag ) ; // Constructor e s p e c i f i c o double parte_real () const ; // Devuelve l a p a r t e r e a l d e l numero complejo double parte_imag () const ; // Devuelve l a p a r t e imaginaria d e l numero complejo void sumar ( const Complejo & a, const Complejo & b) ; // Asigna a l numero complejo ( a c t u a l ) e l r e s u l t a d o de // sumar l o s numeros complejos ( a ) y ( b ). void restar ( const Complejo & a, const Complejo & b) ; // Asigna a l numero complejo ( a c t u a l ) e l r e s u l t a d o de // r e s t a r l o s numeros complejos ( a ) y ( b ). void multiplicar ( const Complejo & a, const Complejo & b) ; // Asigna a l numero complejo ( a c t u a l ) e l r e s u l t a d o de // m u l t i p l i c a r l o s numeros complejos ( a ) y ( b ). void dividir ( const Complejo & a, const Complejo & b) ; // Asigna a l numero complejo ( a c t u a l ) e l r e s u l t a d o de // d i v i d i r l o s numeros complejos ( a ) y ( b ). bool igual ( const Complejo & b) const ; // Devuelve t r u e s i e l numero complejo ( a c t u a l ) es // i g u a l a l numero complejo ( b ) void escribir () const ; // Muestra en p a n t a l l a e l numero complejo ( a c t u a l ) 4

5 } ; void leer () ; // Lee de t e c l a d o e l v a l o r d e l numero complejo ( a c t u a l ). // Lee l a p a r t e r e a l y l a p a r t e imaginaria d e l numero. TAD polinomio de grados positivos menores que que defina los siguientes métodos públicos: class Polinomio { public : Polinomio (); // D e s t r u c t o r Polinomio (); // Constructor por Defecto Polinomio ( const Polinomio & p); // Constructor de copia Polinomio & operator =( const Polinomio & p); // Operador de Asignacion int max_grado () const ; // Devuelve e l mayor grado d e l polinomio a c t u a l // cuyo c o e f i c i e n t e es d i s t i n t o de cero void poner ( int e, double c); // Asigna e l c o e f i c i e n t e ( c ) a l termino de grado ( e ) // d e l polinomio a c t u a l double obtener ( int e) const ; // Devuelve e l c o e f i c i e n t e c o r r e s p o n d i e n t e a l // termino de grado ( e ) d e l polinomio a c t u a l double evaluar ( double x) const ; // Devuelve e l r e s u l t a d o de e v a l u a r e l polinomio a c t u a l // para un v a l o r de ( x ) e s p e c i f i c a d o como parametro void derivar ( const Polinomio & a); // PRECOND: ( t h i s!= &a ) // Asigna a l polinomio a c t u a l e l r e s u l t a d o de // c a l c u l a r l a d e r i v a d a d e l polinomio ( a ) void sumar ( const Polinomio & a, const Polinomio & b); // PRECOND: ( ( t h i s!= &a)&&( t h i s!= &b ) ) // Asigna a l polinomio a c t u a l e l r e s u l t a d o de // sumar l o s polinomios ( a ) y ( b ) void escribir () const ; // Muestra en p a n t a l l a e l contenido d e l polinomio a c t u a l void leer (); // Lee de t e c l a d o e l v a l o r d e l polinomio a c t u a l // Lee pares de c o e f i c i e n t e y grado hasta que e l c o e f i c i e n t e sea cero }; 3. Un conjunto de números enteros es una colección de elementos homogéneos (números enteros) sin repetición y ninguna relación de orden entre ellos (no ordenados y sin repetición). Defina un TAD Conjunto de números enteros que defina los siguientes métodos públicos: class Conjunto { public : Conjunto (); // D e s t r u c t o r Conjunto (); // Constructor por Defecto : conjunto v a c i o Conjunto ( const Conjunto & c); // Constructor de copia Conjunto & operator =( const Conjunto & c); // Operador de Asignacion void clear (); // Elimina todos l o s elementos d e l conjunto a c t u a l ( queda v a c i o ) bool es_vacio () const ; // Devuelve t r u e s i e l conjunto a c t u a l e s t a v a c i o void incluir ( int e); // I n c l u y e e l elemento ( e ) en e l conjunto a c t u a l ( s i n r e p e t i c i o n ) void eliminar ( int e); // Elimina e l elemento ( e ) d e l conjunto a c t u a l bool pertenece ( int e) const ; // Devuelve t r u e s i e l elemento ( e ) p e r t e n e c e a l conjunto a c t u a l bool es_subconjunto ( const Conjunto & a) const ; // Devuelve t r u e s i e l conjunto a c t u a l es subconjunto d e l conjunto ( a ) void union_conj ( const Conjunto & a, const Conjunto & b); // PRECOND: ( ( t h i s!= &a)&&( t h i s!= &b ) ) 5

6 }; // Asigna a l conjunto a c t u a l e l r e s u l t a d o de // l a union de l o s conjuntos ( a ) y ( b ) void interseccion ( const Conjunto & a, const Conjunto & b); // PRECOND: ( ( t h i s!= &a)&&( t h i s!= &b ) ) // Asigna a l conjunto a c t u a l e l r e s u l t a d o de // l a i n t e r s e c c i o n de l o s conjuntos ( a ) y ( b ) void diferencia ( const Conjunto & a, const Conjunto & b); // PRECOND: ( ( t h i s!= &a)&&( t h i s!= &b ) ) // Asigna a l conjunto a c t u a l e l r e s u l t a d o de // l a d i f e r e n c i a de l o s conjuntos ( a ) y ( b ) void diferencia_simetrica ( const Conjunto & a, const Conjunto & b); // Asigna a l conjunto a c t u a l e l r e s u l t a d o de // l a d i f e r e n c i a s i m e t r i c a de l o s conjuntos ( a ) y ( b ) void escribir () const ; // Muestra en p a n t a l l a e l contenido d e l conjunto a c t u a l void leer (); // Lee de t e c l a d o e l v a l o r d e l conjunto a c t u a l, 4. TAD matriz matemática de números reales (de dimensiones menores de N N) que defina los siguientes métodos públicos: class Matriz { public : Matriz (); // D e s t r u c t o r Matriz (); // Constructor por Defecto : matriz v a c i a Matriz ( int nfils, int ncols ); // Constructor e s p e c i f i c o : crea matriz de ( n f i l s ) x ( n c o l s ) con v a l o r e s Matriz ( const Matriz & m); // Constructor de copia Matriz & operator =( const Matriz & m); // Operador de Asignacion void clear ( int nfils, int ncols ); // Elimina todos l o s elementos de l a matriz a c t u a l, y asigna // a l a matriz a c t u a l una matriz de ( n f i l s ) x ( n c o l s ) con v a l o r e s int nfils () const ; // Devuelve e l numero de f i l a s de l a matriz a c t u a l int ncols () const ; // Devuelve e l numero de columnas de l a matriz a c t u a l void poner ( int f, int c, double val ); // PRECOND: ( <= f && f < n f i l s ( ) && <= c && c < n c o l s ( ) ) // Asigna e l v a l o r ( v a l ) a l elemento de l a f i l a ( f ) // y columna ( c ) de l a matriz a c t u a l double obtener ( int f, int c) const ; // PRECOND: ( f < n f i l s ( ) && c < n c o l s ( ) ) // Devuelve e l v a l o r d e l elemento de l a f i l a ( f ) // y columna ( c ) de l a matriz a c t u a l void sumar ( const Matriz & a, const Matriz & b); // PRECOND: ( ( t h i s!= &a)&&( t h i s!= &b ) ) // Asigna a l a matriz a c t u a l e l r e s u l t a d o de // sumar l a s matrices ( a ) y ( b ) void restar ( const Matriz & a, const Matriz & b); // PRECOND: ( ( t h i s!= &a)&&( t h i s!= &b ) ) // Asigna a l a matriz a c t u a l e l r e s u l t a d o de // r e s t a r l a s matrices ( a ) y ( b ) void multiplicar ( const Matriz & a, const Matriz & b); // PRECOND: ( ( t h i s!= &a)&&( t h i s!= &b ) ) // Asigna a l a matriz a c t u a l e l r e s u l t a d o de // m u l t i p l i c a r l a s matrices ( a ) y ( b ) void escribir () const ; // Muestra en p a n t a l l a e l contenido de l a matriz a c t u a l void leer (); // Lee de t e c l a d o e l v a l o r de l a matriz a c t u a l, // Lee n f i l s, n c o l s y l o s v a l o r e s de l o s elementos }; 5. Un TAD Lista de números enteros es una secuencia de elementos homogéneos (números enteros), donde cada elemento ocupa una determinada posición dentro de la secuencia, de tal forma que se puede acceder a cada elemento por la posición donde se encuentra. Así mismo, también es posible insertar y eliminar 6

7 elementos de la secuencia en la posición indicada, manteniendo el mismo orden posicional de los elementos en la secuencia. Diseñe e implemente el TAD que proporcione los siguientes métodos públicos: class ListaInt { public : ListaInt () ; // D e s t r u c t o r ListaInt () ; // Constructor por Defecto ListaInt ( const ListaInt & o) ; // Constructor de copia ListaInt & operator = ( const ListaInt & o) ; // Operador de Asignacion bool llena () const ; // Devuelve t r u e s i e l numero de elementos almacenados // al c a nz a l a capacidad maxima de almacenamiento int size () const ; // Devuelve e l numero de elementos almacenados void clear () ; // Elimina todos l o s elementos de l a l i s t a a c t u a l ( queda v a c i a ) void insertar ( int pos, int dato ) ; // PRECOND: (! l l e n a ( ) && <= pos && pos <= s i z e ( ) ) // I n s e r t a ( dato ) en l a l i s t a a c t u a l en l a p o s i c i o n ( pos ) void eliminar ( int pos ) ; // PRECOND: ( <= pos && pos < s i z e ( ) ) // Elimina de l a l i s t a a c t u a l e l elemento que ocupa l a p o s i c i o n ( pos ) int acceder ( int pos ) const ; // PRECOND: ( <= pos && pos < s i z e ( ) ) // Devuelve e l elemento de l a l i s t a a c t u a l que ocupa l a p o s i c i o n ( pos ) void modificar ( int pos, int dato ); // PRECOND: ( <= pos && pos < s i z e ( ) ) // Asigna ( dato ) a l elemento de l a l i s t a a c t u a l que ocupa l a p o s i c i o n ( pos ) } ; 7

8 Tema 3: Gestión de Memoria Dinámica Tema 3.: Listas Enlazadas. Diseñe un módulo (programación modular) que proporcione soporte adecuado a la manipulación de listas enlazadas en memoria dinámica (véase siguiente figura). El módulo deberá definir el tipo PNodo como un puntero a un registro en memoria dinámica de tipo Nodo que contiene un enlace al siguiente nodo, así como un dato de tipo int. Además, el módulo deberá definir los siguientes subprogramas. Diseñe también un módulo principal que permita comprobar la corrección del módulo lista implementado. lista: void inicializa ( PNodo & lista ) ; // I n i c i a l i z a ( l i s t a ) a una l i s t a v a c i a void destruir ( PNodo & lista ) ; // Destruye todos l o s elementos de l a l i s t a, l i b e r a n d o // todos l o s nodos de memoria dinamica. ( l i s t a ) queda v a c i a void escribir ( PNodo lista ) ; // Muestra en p a n t a l l a e l contenido de ( l i s t a ) PNodo buscar ( PNodo lista, int dt) ; // Devuelve un puntero a l nodo que c o n t i e n e e l elemento // i g u a l a ( dt ). Si no se encuentra, entonces d e v u e l v e NULL void insertar_principio ( PNodo & lista, int dt) ; // I n s e r t a un elemento a l p r i n c i p i o de ( l i s t a ) void insertar_final ( PNodo & lista, int dt) ; // I n s e r t a un elemento a l f i n a l de ( l i s t a ) void insertar_ord ( PNodo & lista, int dt) ; // I n s e r t a un elemento de forma ordenada en ( l i s t a ), que debe e s t a r ordenada void eliminar_primero ( PNodo & lista ) ; // Elimina e l primer elemento de ( l i s t a ), s i e x i s t e void eliminar_ultimo ( PNodo & lista ) ; // Elimina e l ultimo elemento de ( l i s t a ), s i e x i s t e void eliminar_elem ( PNodo & lista, int dt) ; // Elimina de ( l i s t a ) e l primer elemento i g u a l a ( dt ), s i e x i s t e PNodo situar ( PNodo lista, int pos ) ; // Devuelve un puntero a l nodo que se encuentra en l a p o s i c i o n // i n d i c a d a por ( pos ). La p o s i c i o n cero () i n d i c a e l primer nodo. // Si e l nodo no e x i s t e, entonces d e v u e l v e NULL void insertar ( PNodo & lista, int pos, int dt) ; // I n s e r t a en ( l i s t a ) un elemento en l a p o s i c i o n i n d i c a d a por ( pos ) void eliminar ( PNodo & lista, int pos ) ; // Elimina de ( l i s t a ) e l elemento de l a p o s i c i o n i n d i c a d a por ( pos ), s i e x i s t e PNodo duplicar ( PNodo lista ) ; // Devuelve un puntero a una nueva l i s t a r e s u l t a d o de d u p l i c a r en // memoria dinamica l a l i s t a r e c i b i d a como parametro PNodo leer () ; // Devuelve una l i s t a con l o s numeros l e i d o s de t e c l a d o ( en e l mismo // orden que son i n t r o d u c i d o s ) h asta que l e a e l numero ( que no es // i n t r o d u c i d o ) void eliminar_mayor ( PNodo & lista ) ; // Elimina e l mayor elemento de ( l i s t a ), s i e x i s t e void purgar ( PNodo & lista, int dt) ; // Elimina de ( l i s t a ) todos l o s elementos que sean i g u a l e s a ( dt ), s i e x i s t e n. Un conjunto de números enteros es una colección de elementos homogéneos (números enteros) sin repetición y ninguna relación de orden entre ellos (no ordenados y sin repetición). Un conjunto de elementos se puede representar mediante una lista enlazada, donde cada nodo contiene un elemento del conjunto. Por ejemplo el conjunto con los elementos {,, 3} puede ser representado por la siguiente lista enlazada: lista: 3 8

9 Diseñe un módulo (programación modular) que proporcione soporte adecuado a la manipulación de conjuntos de números enteros implementados mediante listas enlazadas en memoria dinámica (véase figura anterior). El módulo deberá definir el tipo Conjunto como un registro con un campo de tipo PNodo, que se define como un tipo puntero a un registro en memoria dinámica de tipo Nodo que contiene un enlace al siguiente nodo, así como un dato de tipo int. Además, el módulo deberá definir los siguientes subprogramas. Diseñe también un módulo principal que permita comprobar la corrección del módulo implementado. void inicializar ( Conjunto & c); // I n i c i a l i z a ( c ) a un conjunto v a c i o void destruir ( Conjunto & c); // Destruye todos l o s elementos d e l conjunto, l i b e r a n d o // todos l o s nodos de memoria dinamica. ( c ) queda v a c i o bool es_vacio ( const Conjunto & c) ; // Devuelve t r u e s i e l conjunto ( c ) e s t a v a c i o void incluir ( Conjunto & c, int e); // I n c l u y e e l elemento ( e ) en e l conjunto ( c ) ( s i n r e p e t i c i o n ) void eliminar ( Conjunto & c, int e); // Elimina e l elemento ( e ) d e l conjunto ( c ) bool pertenece ( const Conjunto & c, int e) ; // Devuelve t r u e s i e l elemento ( e ) p e r t e n e c e a l conjunto ( c ) void escribir ( const Conjunto & c) ; // Muestra en p a n t a l l a e l contenido d e l conjunto ( c ) void leer ( Conjunto & c); // Lee de t e c l a d o e l v a l o r d e l conjunto ( c ) bool es_subconjunto ( const Conjunto & a, const Conjunto & b) ; // Devuelve t r u e s i e l conjunto ( a ) es subconjunto d e l conjunto ( b ) void union_conj ( Conjunto & c, const Conjunto & a, const Conjunto & b); // Asigna a l conjunto ( c ) e l r e s u l t a d o de // l a union de l o s conjuntos ( a ) y ( b ) ( d u p l i c a l o s nodos ) void interseccion ( Conjunto & c, const Conjunto & a, const Conjunto & b); // Asigna a l conjunto ( c ) e l r e s u l t a d o de // l a i n t e r s e c c i o n de l o s conjuntos ( a ) y ( b ) ( d u p l i c a l o s nodos ) void diferencia ( Conjunto & c, const Conjunto & a, const Conjunto & b); // Asigna a l conjunto ( c ) e l r e s u l t a d o de // l a d i f e r e n c i a de l o s conjuntos ( a ) y ( b ) ( d u p l i c a l o s nodos ) void diferencia_simetrica ( Conjunto & c, const Conjunto & a, const Conjunto & b); // Asigna a l conjunto ( c ) e l r e s u l t a d o de // l a d i f e r e n c i a s i m e t r i c a de l o s conjuntos ( a ) y ( b ) ( d u p l i c a l o s nodos ) void copiar ( Conjunto & d, const Conjunto & o) ; // Copia ( d u p l i c a ) e l conjunto ( o ) en e l conjunto ( d ) Nota: aunque el orden en el que se encuentran los elementos en el conjunto no es importante, y por lo tanto, la opción más simple para incluir elementos en él podría ser insertar siempre los elementos por el principio, con objeto de prácticar los conceptos de listas enlazadas, en esta práctica, los elementos del conjunto serán insertados (sin repetición) ordenados en la lista enlazada donde se encuentran almacenados. 3. Diseñe un módulo (programación modular) que proporcione soporte adecuado a la manipulación de listas doblemente enlazadas en memoria dinámica (véase siguiente figura). El módulo deberá definir el tipo PNodo como un puntero a un registro en memoria dinámica de tipo Nodo que contiene un enlace al siguiente nodo, un enlace al nodo anterior, así como un dato de tipo int. Además, el módulo deberá definir los siguientes subprogramas. Diseñe también un módulo principal que permita comprobar la corrección del módulo lista implementado. lista: void inicializa ( PNodo & lista ) ; // I n i c i a l i z a ( l i s t a ) a una l i s t a v a c i a void destruir ( PNodo & lista ) ; // Destruye todos l o s elementos de l a l i s t a, l i b e r a n d o // todos l o s nodos de memoria dinamica. ( l i s t a ) queda v a c i a void escribir ( PNodo lista ) ; // Muestra en p a n t a l l a e l contenido de ( l i s t a ) PNodo buscar ( PNodo lista, int dt) ; // Devuelve un puntero a l nodo que c o n t i e n e e l elemento // i g u a l a ( dt ). Si no se encuentra, entonces d e v u e l v e NULL 9

10 void insertar_principio ( PNodo & lista, int dt) ; // I n s e r t a un elemento a l p r i n c i p i o de ( l i s t a ) void insertar_final ( PNodo & lista, int dt) ; // I n s e r t a un elemento a l f i n a l de ( l i s t a ) void insertar_ord ( PNodo & lista, int dt) ; // I n s e r t a un elemento de forma ordenada en ( l i s t a ), que debe e s t a r ordenada void eliminar_primero ( PNodo & lista ) ; // Elimina e l primer elemento de ( l i s t a ), s i e x i s t e void eliminar_ultimo ( PNodo & lista ) ; // Elimina e l ultimo elemento de ( l i s t a ), s i e x i s t e void eliminar_elem ( PNodo & lista, int dt) ; // Elimina de ( l i s t a ) e l primer elemento i g u a l a ( dt ), s i e x i s t e PNodo situar ( PNodo lista, int pos ) ; // Devuelve un puntero a l nodo que se encuentra en l a p o s i c i o n // i n d i c a d a por ( pos ). La p o s i c i o n cero () i n d i c a e l primer nodo. // Si e l nodo no e x i s t e, entonces d e v u e l v e NULL void insertar ( PNodo & lista, int pos, int dt) ; // I n s e r t a en ( l i s t a ) un elemento en l a p o s i c i o n i n d i c a d a por ( pos ) void eliminar ( PNodo & lista, int pos ) ; // Elimina de ( l i s t a ) e l elemento de l a p o s i c i o n i n d i c a d a por ( pos ), s i e x i s t e PNodo duplicar ( PNodo lista ) ; // Devuelve un puntero a una nueva l i s t a r e s u l t a d o de d u p l i c a r en // memoria dinamica l a l i s t a r e c i b i d a como parametro PNodo leer () ; // Devuelve una l i s t a con l o s numeros l e i d o s de t e c l a d o ( en e l mismo // orden que son i n t r o d u c i d o s ) h asta que l e a e l numero ( que no es // i n t r o d u c i d o ) void eliminar_mayor ( PNodo & lista ) ; // Elimina e l mayor elemento de ( l i s t a ), s i e x i s t e void purgar ( PNodo & lista, int dt) ; // Elimina de ( l i s t a ) todos l o s elementos que sean i g u a l e s a ( dt ), s i e x i s t e n Tema 3.: Abstracción en la Gestión de Memoria Dinámica. Un polinomio en x de grado arbitrario se puede representar mediante una lista enlazada, donde cada nodo contiene el coeficiente y el exponente de un término del polinomio, y donde los coeficientes con valor cero () no serán almacenados. Por ejemplo el polinomio 5x 4x 5 puede ser representado por la siguiente lista enlazada: lista: Diseñe e implemente el TAD polinomio que defina los siguientes métodos públicos, así como un programa para comprobar su funcionamiento: class Polinomio { public : Polinomio (); // D e s t r u c t o r Polinomio (); // Constructor por Defecto Polinomio ( const Polinomio & p); // Constructor de copia Polinomio & operator =( const Polinomio & p); // Operador de Asignacion int max_grado () const ; // Devuelve e l mayor grado d e l polinomio a c t u a l // cuyo c o e f i c i e n t e es d i s t i n t o de cero void poner ( int e, double c); // Asigna e l c o e f i c i e n t e ( c ) a l termino de grado ( e ) // d e l polinomio a c t u a l double obtener ( int e) const ; // Devuelve e l c o e f i c i e n t e c o r r e s p o n d i e n t e a l // termino de grado ( e ) d e l polinomio a c t u a l double evaluar ( double x) const ; // Devuelve e l r e s u l t a d o de e v a l u a r e l polinomio a c t u a l // para un v a l o r de ( x ) e s p e c i f i c a d o como parametro void derivar ( const Polinomio & a);

11 }; // Asigna a l polinomio a c t u a l e l r e s u l t a d o de // c a l c u l a r l a d e r i v a d a d e l polinomio ( a ) void sumar ( const Polinomio & a, const Polinomio & b); // Asigna a l polinomio a c t u a l e l r e s u l t a d o de // sumar l o s polinomios ( a ) y ( b ) void escribir () const ; // Muestra en p a n t a l l a e l contenido d e l polinomio a c t u a l void leer (); // Lee de t e c l a d o e l v a l o r d e l polinomio a c t u a l // Lee pares de c o e f i c i e n t e y grado hasta que e l c o e f i c i e n t e sea cero. Un conjunto de números enteros es una colección de elementos homogéneos (números enteros) sin repetición y ninguna relación de orden entre ellos (no ordenados y sin repetición). Un conjunto de elementos se puede representar mediante una lista enlazada, donde cada nodo contiene un elemento del conjunto. Por ejemplo el conjunto con los elementos {,, 3} puede ser representado por la siguiente lista enlazada: lista: 3 Diseñe e implemente el siguiente TAD conjunto de números enteros que defina los siguientes métodos públicos, así como un programa para comprobar su funcionamiento: class Conjunto { public : Conjunto (); // D e s t r u c t o r Conjunto (); // Constructor por Defecto : conjunto v a c i o Conjunto ( const Conjunto & c); // Constructor de copia Conjunto & operator =( const Conjunto & c); // Operador de Asignacion void clear (); // Elimina todos l o s elementos d e l conjunto a c t u a l ( queda v a c i o ) bool es_vacio () const ; // Devuelve t r u e s i e l conjunto a c t u a l e s t a v a c i o void incluir ( int e); // I n c l u y e e l elemento ( e ) en e l conjunto a c t u a l ( s i n r e p e t i c i o n ) void eliminar ( int e); // Elimina e l elemento ( e ) d e l conjunto a c t u a l bool pertenece ( int e) const ; // Devuelve t r u e s i e l elemento ( e ) p e r t e n e c e a l conjunto a c t u a l bool es_subconjunto ( const Conjunto & a) const ; // Devuelve t r u e s i e l conjunto a c t u a l es subconjunto d e l conjunto ( a ) void union_conj ( const Conjunto & a, const Conjunto & b); // Asigna a l conjunto a c t u a l e l r e s u l t a d o de // l a union de l o s conjuntos ( a ) y ( b ) void interseccion ( const Conjunto & a, const Conjunto & b); // Asigna a l conjunto a c t u a l e l r e s u l t a d o de // l a i n t e r s e c c i o n de l o s conjuntos ( a ) y ( b ) void diferencia ( const Conjunto & a, const Conjunto & b); // Asigna a l conjunto a c t u a l e l r e s u l t a d o de // l a d i f e r e n c i a de l o s conjuntos ( a ) y ( b ) void diferencia_simetrica ( const Conjunto & a, const Conjunto & b); // Asigna a l conjunto a c t u a l e l r e s u l t a d o de // l a d i f e r e n c i a s i m e t r i c a de l o s conjuntos ( a ) y ( b ) void escribir () const ; // Muestra en p a n t a l l a e l contenido d e l conjunto a c t u a l void leer (); // Lee de t e c l a d o e l v a l o r d e l conjunto a c t u a l, }; 3. Se dispone de un procesador con varias etapas, y de unas determinadas tareas que se ejecutarán pasando sucesivamente por todas las etapas del procesador, desde la primera hasta la última. Como el procesador dispone de varias etapas, es posible que esté procesando simultáneamente diferentes tareas. Por tanto,

12 una tarea sólo podrá pasar a la siguiente etapa si ésta se encuentra libre. La siguiente figura muestra un procesador con cuatro etapas y dos tareas, la tarea T va ejecutándose por la etapa e y la tarea T va ejecutándose por la etapa e4. procesador t t e e e3 e4 Se debe diseñar la estructura de datos necesaria para representar la información del estado del procesador en cada momento. Para ello, se sigue el esquema mostrado en la siguiente figura. Como se puede observar cada etapa se representa con dos elementos, una lista de nodos intermedios con tantos nodos como réplicas (véase más adelante) haya de la etapa (en el ejemplo sólo se muestra una réplica por cada etapa) y los correspondientes nodos de etapa. Cada nodo de etapa contendrá su identificador, el número de la tarea que está ejecutando (un número cero indica que está libre, es decir, no está ejecutando ninguna tarea), y un puntero al primer nodo de la lista de nodos intermedios de la siguiente etapa. También se puede observar que la tarea T se está ejecutando en la etapa y la tarea T se está ejecutando en la etapa 4. procesador 3 4 Es posible que en un determinado momento interese ampliar la potencia de una determinada etapa. Para ello, se replicará dicha etapa haciendo tantos duplicados de la misma como se desee. Así mismo, es posible que interese reducir la potencia de una determinada etapa, para ello se eliminarán réplicas de la misma. Defina el TAD Procesador que implemente la estructura de datos especificada anteriormente, y que proporcione los siguientes métodos públicos, así mismo, también se deberá implementar un programa principal que permita su utilización: a) El Constructor recibe el número de etapas que tiene un determinado procesador, y crea la estructura base de étapas sin replicación y todas en estado inicial libre, como se muestra en la siguiente figura para un procesador de 4 etapas: procesador 3 4 b) El Destructor libera todos los recursos asociados al objeto que está siendo destruido. c) El método Mostrar muestra en pantalla la estructura interna de un procesador. Por ejemplo, para la figura anterior: Etapa: Replica: libre Replica: libre Etapa: Replica: tarea Replica: tarea Etapa: 3 Replica: libre Etapa: 4 Replica: libre d) Un método Replicar, que se usará para ampliar la potencia de una determinada etapa del procesador actual. Recibe como parámetros el identificador de la etapa a replicar y el número de réplicas que deseamos añadir. Las réplicas añadidas tendrán el estado inicial libre (no tienen asignadas la ejecución de ninguna tarea). Las réplicas se añadirán a la estructura añadiendo (en cualquier posición SALVO AL PRINCIPIO) nodos a la lista de nodos intermedios correspondiente a la etapa y nodos de etapa apuntados desde los nodos intermedios añadidos. Como se puede observar, todas las réplicas añadidas deben apuntar al primer nodo intermedio de la etapa siguiente (salvo en la última etapa). La siguiente figura muestra el resultado de añadir dos réplicas de la etapa a la figura anterior:

13 procesador 3 4 La siguiente figura muestra el resultado de añadir una réplica de la etapa a la figura anterior: procesador 3 4 e) Un método para Compactar que se usará para disminuir el número de réplicas de una etapa del procesador actual. Para ello, recibe como parámetro el identificador de la etapa a compactar y elimina todas las réplicas de dicha etapa cuyo estado sea libre (no esté ejecutando ninguna tarea). Al compactar etapas habrá que tener en cuenta que: De cada etapa deberá quedar al menos una réplica. Las réplicas que estén ejecutando alguna tarea no pueden ser eliminadas. No se podrá liberar la memoria ocupada por el primer nodo de la lista de nodos intermedios de una etapa (pues sirve de enlace entre una etapa y la siguiente). En caso de que la compactación requiera eliminar la primera réplica de una etapa (porque esté libre), el puntero al nodo de etapa del primer nodo de la lista de nodos intermedios pasará a apuntar a un nodo de etapa que permanezca tras la compactación. Por ejemplo, para la siguiente figura: procesador 3 4 la siguiente figura es el resultado de compactar la etapa de la figura anterior: procesador 3 4 f ) El método AvanzarEvaluacion intenta avanzar una tarea de una determinada etapa a la siguiente. Para ello, recibe como parámetro el número de tarea (distinto de cero) que pretende avanzar a la siguiente etapa. Si la tarea es nueva, buscará una réplica libre de la primera etapa del procesador. Si no hay réplicas libres en esta primera etapa, entonces lanzará una excepción. Si la tarea se está ejecutando en la última etapa del procesador, entonces la tarea habrá terminado su ejecución, y su número desaparecerá de la estructura. En otro caso, intenta avanzar la tarea desde la réplica de la etapa en que se encuentra ejecutándose hasta alguna réplica libre de la siguiente etapa. Si no hay ninguna réplica libre de la siguiente etapa, entonces lanzará una excepción. 3

14 g) Así mismo, también deberá ser posible realizar la copia y asignación (duplicación) de la estructura de datos que representa a un determinado procesador. 4. Diseñe un programa que permita utilizar el TAD especificado en el ejercicio anterior. 4

15 Tema 4: Introducción a la Programación Orientada a Objetos. Para calcular los sueldos de cada empleado de una factoría, se diseña la siguiente jerarquía de clases polimórficas: Empleado Factoria AgVentas Directivo AgVentas_A AgVentas_B Directivo_A Directivo_B La clase polimórfica Empleado representa un empleado general de una factoría, tiene un constructor que permite crear un objeto con el nombre (string) del empleado recibido como parámetro, y proporciona los siguientes métodos públicos virtuales: clone(): devuelve un puntero a un nuevo objeto creado como copia del objeto actual. sueldo(): calcula y devuelve el sueldo del empleado. En caso de no tener información suficiente para calcular el sueldo, entonces devolverá. nombre(): devuelve el nombre del objeto empleado actual. La clase polimórfica AgVentas representa un agente de ventas general, empleado de una factoría, tiene un constructor que permite crear un objeto con el nombre (string) del empleado recibido como parámetro, y proporciona los siguientes métodos públicos virtuales: clone(): devuelve un puntero a un nuevo objeto creado como copia del objeto actual. borrar_ventas(): reinicia a cero la cantidad total de ventas que acumula este agente de ventas. anyadir_ventas(x): permite añadir una cantidad de euros recibida como parámetro a la cantidad total de ventas que acumula este agente de ventas. ventas(): devuelve la cantidad total de ventas que acumula este agente de ventas. La clase polimórfica AgVentas_A representa un agente de ventas de clase A, empleado de una factoría, tiene un constructor que permite crear un objeto con el nombre (string) del empleado recibido como parámetro, y proporciona los siguientes métodos públicos virtuales: clone(): devuelve un puntero a un nuevo objeto creado como copia del objeto actual. sueldo(): redefine este método para calcular y devolver el sueldo de este tipo de agente de ventas, según la siguiente ecuación: sueldo =. +. total_ventas. La clase polimórfica AgVentas_B representa un agente de ventas de clase B, empleado de una factoría, tiene un constructor que permite crear un objeto con el nombre (string) del empleado recibido como parámetro, y proporciona los siguientes métodos públicos virtuales: clone(): devuelve un puntero a un nuevo objeto creado como copia del objeto actual. sueldo(): redefine este método para calcular y devolver el sueldo de este tipo de agente de ventas, según la siguiente ecuación: sueldo = total_ventas. La clase polimórfica Directivo representa un directivo general, empleado de una factoría, tiene un constructor que permite crear un objeto con el nombre (string) del empleado recibido como parámetro, y proporciona los siguientes métodos públicos virtuales: clone(): devuelve un puntero a un nuevo objeto creado como copia del objeto actual. La clase polimórfica Directivo_A representa un directivo de clase A, empleado de una factoría, tiene un constructor que permite crear un objeto con el nombre (string) del empleado recibido como parámetro, y proporciona los siguientes métodos públicos virtuales: 5

16 clone(): devuelve un puntero a un nuevo objeto creado como copia del objeto actual. sueldo(): redefine este método para calcular y devolver el sueldo de este tipo de directivos, según la siguiente ecuación: sueldo = 5. La clase polimórfica Directivo_B representa un directivo de clase B, empleado de una factoría, tiene un constructor que permite crear un objeto con el nombre (string) del empleado recibido como parámetro, y proporciona los siguientes métodos públicos virtuales: clone(): devuelve un puntero a un nuevo objeto creado como copia del objeto actual. sueldo(): redefine este método para calcular y devolver el sueldo de este tipo de directivos, según la siguiente ecuación: sueldo = 3. La clase polimórfica Factoria representa una factoría con un máximo de empleados, su constructor por defecto permite crear un nuevo objeto de clase Factoria sin ningún empleado, y proporciona los siguientes métodos públicos virtuales: clone(): devuelve un puntero a un nuevo objeto creado como copia del objeto actual. anyadir_empleado(e, ok): intenta añadir el empleado que recibe como primer parámetro (de entrada) a la lista de empleados de la factoría actual. Si la operación es posible o no, entonces devuelve true o false, respectivamente, en el segundo parámetro (de salida). sueldos(): muestra en pantalla tanto el nombre como el sueldo de cada empleado de la factoría. Finalmente, el programa principal creará un objeto de la clase Factoria, le añadirá empleados (Directivo_A, Directivo_B, AgVentas_A y AgVentas_B) y ventas acumuladas a los agentes de ventas, y calculará sus sueldos. Así mismo, tambien probará que la clonación de la factoría funciona adecuadamente.. Se desea simular el comportamiento de una serie de vehículos, por lo que se establece la siguiente jerarquía de clases: Vehiculo Automovil Bicicleta Todo objeto de la clase base polimórfica Vehiculo debe guardar en su estado la siguiente información y definir el siguiente constructor: ident: identificador del vehículo (cadena de caracteres). distancia: la distancia recorrida por el vehículo con respecto al punto de partida (origen) del mismo (unsigned). Vehiculo(i): inicializa el identificador del vehículo con i y su distancia a cero. Además, el comportamiento de los objetos Vehículo queda definido por los siguientes métodos públicos virtuales: id(): devuelve el indentificador del vehículo consultar_dist(): devuelve un unsigned con la distancia recorrida por el vehículo estacionar(): establece la distancia recorrida por el vehículo en (origen) tiene_energia(): indica si el vehículo tiene energía (función lógica). Debe devolver siempre true mover(): incrementa en el valor de la distancia recorrida por el vehículo. clone(): devuelve un puntero a un objeto Vehiculo, copia del vehículo actual Además, la clase Vehículo proporciona a sus clases derivadas los siguientes métodos protected, para poder manipular adecuadamente su estado interno: mover(x): incrementa en x el valor de la distancia recorrida por el vehículo. 6

17 La clase derivada polimórfica Automovil añade los siguientes atributos y define el siguiente constructor: DPL: constante simbólica static, de tipo unsigned, que indica la distancia que el automóvil recorre por litro de combustible (= 5). deposito: atributo unsigned que guarda el número de litros de combustible del depósito del automóvil. Automovil(i): inicializa el identificador del automóvil a i, su distancia a y su deposito a. Además, el comportamiento de los objetos Automovil queda definido por los siguientes métodos públicos virtuales: tiene_energia(): redefine el método de la clase base, devolviendo true si la cantidad almacenada en el deposito es mayor que. mover(): redefine el método de la clase base, de tal forma que si el automóvil tiene energía, entonces se mueve una distancia igual al valor de DPL, es decir, se incrementa la distancia recorrida actual sumándole a la misma el valor almacenado en la constante miembro DPL. repostar(ltr): incrementa la cantidad de combustible almacenada en el deposito del automóvil en ltr litros. clone(): devuelve un puntero a un objeto Automovil, copia del automóvil actual. La clase derivada polimórfica Bicicleta añade los siguientes atributos y define el siguiente constructor: NUM_PLATOS: constante simbólica static, de tipo unsigned, indicando el número de platos que tiene la bicicleta. plato: un unsigned que indica el plato que tiene puesto en este momento la bicicleta (a mayor tamaño de plato, mayor será su desplazamiento cuando la bicicleta se mueva). Bicicleta(i): inicializa el identificador de la bicicleta a i, su distancia a y su plato a. Además, el comportamiento de los objetos Bicicleta queda definido por los siguientes métodos públicos virtuales: mover(): redefine el método de la clase base, de tal forma que la bicicleta se mueve una distancia igual al valor de plato +, es decir, se incrementa la distancia recorrida actual sumándole a la misma el valor de plato +. cambiar(): cambia el valor del plato, sumándole y aplicando posteriormente % NUM_PLATOS (el valor del plato siempre estará entre y NUM_PLATOS - ). clone(): devuelve un puntero a un objeto Bicicleta, copia de la bicicleta actual. El programa principal debe definir el tipo Vehiculos como un tipo array de NUM_VEHICULOS = 4 punteros a objetos de la clase Vehiculo. Implementar el procedimiento viajar(v, d, t), que recibe un puntero a un objeto de la clase Vehiculo, un unsigned con la distancia total a recorrer por el vehículo, y devuelve, a través de un parámetro de salida el tiempo ( minutos ) que el vehículo ha tardado en llegar a su destino (si ha tenido energía suficiente para llegar). Este algoritmo debe proceder de la siguiente manera: a) Estacionar el vehículo (es decir, inicializar la distancia recorrida a ). b) Inicializar el tiempo a. c) Mientras que el vehículo tenga energía y su distancia recorrida sea menor que la distancia solicitada, el vehículo debe moverse (para ello, el procedimiento debe invocar la función miembro mover() del objeto Vehiculo) y tiempo se incrementa en. Implementar el programa principal (main), con las siguientes características: Declara un array mis_vehiculos de tipo Vehiculos. Crea un objeto Automovil, con identificador "5555JJJ" y 5 litros de gasolina y pone mis_vehiculos[] apuntando a él. Crea un objeto Bicicleta, con identificador "6666JJJ" y pone mis_vehiculos[] apuntando a él. Crea un objeto Bicicleta, con identificador "7777JJJ", cambia su plato y pone mis_vehiculos[] apuntando a él. Crea un objeto Bicicleta, con identificador "8888JJJ", cambia su plato dos veces y pone mis_vehiculos[3] apuntando a él. 7

18 Para todos los vehiculos que se encuentran en mis_vehiculos, debe calcular el tiempo de duración del viaje para una distancia recorrida de destino invocando al procedimiento viajar y, en caso de que el vehículo tuviera energía suficiente, escribe ese tiempo por pantalla (en caso contrario, se indica con un mensaje por pantalla: El vehículo x no ha podido llegar a su destino por falta de energía) Un ejemplo de ejecución podría ser: El vehículo 5555JJJ no ha podido llegar a su destino por falta de energía Tiempo vehículo 6666JJJ: minutos Tiempo vehículo 7777JJJ: 5 minutos Tiempo vehículo 8888JJJ: 334 minutos 3. Dada la jerarquía de clases de Vehiculo del ejercicio anterior, se debe desarrollar la clase no-polimórfica Parking para gestionar un parking con un máximo de MAX = vehículos (de cualquier tipo) estacionados en él. Los objetos de la clase Parking deben almacenar en su estado la siguiente información: MAX: constante simbólica static con el máximo (= ) de vehículos que pueden estacionarse en el parking. parking: un array de MAX punteros a objetos de la clase Vehiculo. n_v: número de vehículos estacionados en el parking. Además, la clase Parking debe suministrar los siguientes métodos, constructores, etc. públicos: Parking(): inicializa el número de vehículos estacionados en el parking a. Parking(otro_parking): constructor de copia de la clase: copia (clona) todos los vehículos estacionados en otro_parking al parking actual. ~Parking(): destructor de la clase: libera todos los vehículos almacenados en el parking (los destruye). operator=(otro_parking): operador de asignación para la clase Parking. anyadir(v, ok): recibe como parámetro de entrada v, un puntero a un objeto de la clase Vehiculo. Si hay espacio en el parking para estacionar un nuevo vehículo, entonces v se añade al final de la lista de vehículos estacionados en el parking y el número de vehículos estacionados se incrementa en ; finalmente, se debe invocar al método de estacionar sobre este nuevo vehículo estacionado (para que su distancia recorrida se ponga a ); ok debe ponerse a true en ese caso. Si no hay espacio para estacionar en el parking, se devuelve false a través de ok. mostrar(): muestra por pantalla los identificadores de todos los vehículos estacionados en el parking. extraer(id): busca en la lista de vehículos almacenados en el parking el vehículo con idenfificador id. Si lo encuentra, debe extraer el vehículo del parking y devolver un puntero al objeto vehículo extraído. Si no lo encuentra, entonces devuelve NULL. Se aconseja, además, implementar los siguientes métodos privados de la clase Parking: buscar(id): devuelve la posición del array parking que contiene un puntero apuntando al vehículo con identificador id, si éste está estacionado en el parking. Si no, devuelve una posición fuera de rango (por ejemplo, el n_v). copiar(otro_parking): copia todo el estado de otro_parking (esto es, clona todos los vehículos almacenados en él y copia su n_v) en el objeto actual. Nota: deben clonarse todos los vehículos del objeto otro_parking para que el parking actual trabaje con copias de los mismos. destruir(): destruye todos los vehículos almacenados en el parking. Debe implementarse un programa principal que declare un objeto de la clase Parking y pruebe toda su funcionalidad: añada vehículos de distinto tipo (vehículos genéricos, automóviles y bicicletas) al parking, los muestre, los extraiga, haga una copia completa del parking, etc. 8