Programación 1. Tema V Clase de problemas. Desarrollo de un módulo de biblioteca C++ para trabajar con conjuntos de letras

Transcripción

1 Programación 1 Tema V Clase de problemas Desarrollo de un módulo de biblioteca C++ para trabajar con conjuntos de letras 1

2 1. Representación del tipo Conjunto DebedefinirselarepresentacióndelosdatosdetipoConjunto en el móduloconjunto presentado en la lección 17: Para ello se definirá un registro con uno o más campos: struct Conjunto { aquí se debe definir la estructura interna de un dato de tipo Conjunto y se debe explicar el significado y la forma de gestionar cada campo del registro ; La representación de un dato del tipo Conjunto deberá facilitar el diseño algorítmico de las funciones asociadas al tipo y velar por la eficiencia de éstas. 2

3 Representación de un dato de tipo Conjunto: * Representación de un conjunto de letras del alfabeto (inglés): * elemento[0] <=> la letra A pertenece al conjunto * elemento[1] <=> la letra B pertenece al conjunto *... * elemento['y' 'A'] <=> la letra Y pertenece al conjunto * elemento['z' 'A'] <=> la letra Z pertenece al conjunto struct Conjunto { bool elemento['z' 'A' + 1]; ; 3

4 2. Diseño de las funciones del módulo Ahora deben especificarse cada una de las once funciones del módulo conjunto presentadas en la lección 17 y, a continuación, debe escribirse su código: Cada función se acompaña de una frase orientativa sobre su comportamiento esperado. Se deben sustituir estas frases por una especificación mucho más precisa, con su precondición y su postcondición. Una vez especificada cada función, debe escribirse su código C++. 4

5 // para crear un conjunto vacío de letras Conjunto vacio (); // para comprobar si una letra pertenece a un conjunto // de letras bool pertenece (const Conjunto A, const char elemento); // para incorporar una letra a un conjunto de letras void incluir (Conjunto& A, const char elemento); // para excluir una letra de un conjunto de letras void excluir (Conjunto& A, const char elemento);... 5

6 ... // para conocer cuántas letras pertenecen a un conjunto // de letras int cardinal (const Conjunto A); // para calcular la unión de dos conjuntos de letras Conjunto opunion (const Conjunto A, const Conjunto B); // para calcular la intersección de dos conjuntos de letras Conjunto opinterseccion (const Conjunto A, const Conjunto B); // para calcular la diferencia de dos conjuntos de letras Conjunto opdiferencia (const Conjunto A, const Conjunto B);... 6

7 ... // para mostrar por pantalla los elementos de un conjunto // de letras void mostrar (const Conjunto A); // para almacenar una secuencia de conjuntos de letras // en un fichero, en formato binario void guardar (const char nombrefichero[], const Conjunto T[], const int n); // para leer una secuencia de conjuntos de letras // de un fichero que los almacena en formato binario bool recuperar (const char nombrefichero[], Conjunto T[], int& n); 7

8 La función vacio(): // para crear un conjunto vacío de letras Conjunto vacio (); Escribir la especificación y el código de la función vacio(): * Pre: su precondición * Post: su postcondición Conjunto vacio () { su código 8

9 La función vacio(): // para crear un conjunto vacío de letras Conjunto vacio (); Especificación de la función vacio(): * Pre: * Post: Devuelve un conjunto vacío de letras Conjunto vacio (); 9

10 Código de la función vacio(): * Pre: * Post: Devuelve un conjunto vacío de letras Conjunto vacio () { Conjunto C; for (char letra = 'A'; letra <= 'Z'; ++letra) { C.elemento[letra 'A'] = false; return C; 10

11 La función pertenece(a,elemento): // para comprobar si una letra pertenece a un conjunto // de letras bool pertenece (const Conjunto A, const char elemento); Escribir la especificación y el código de la función pertenece( ): * Pre: su precondición * Post: su postcondición bool pertenece (const Conjunto A, const char elemento) { su código 11

12 La función pertenece(a,elemento): // para comprobar si una letra pertenece a un conjunto // de letras bool pertenece (const Conjunto A, const char elemento); Especificación de la función pertenece(a,elemento): * Pre: elemento >= 'A' y elemento <= 'Z' * Post: Devuelve <true> si y solo si <elemento> * pertenece al conjunto <A> bool pertenece (const Conjunto A, const char elemento); 12

13 Código de la función pertenece(a,elemento): * Pre: elemento >= 'A' y elemento <= 'Z' * Post: Devuelve <true> si y solo si <elemento> * pertenece al conjunto <A> bool pertenece (const Conjunto A, const char elemento) { return A.elemento[elemento 'A']; 13

14 La función incluir(a,elemento): // para incorporar una letra a un conjunto de letras void incluir (Conjunto& A, const char elemento); Escribir la especificación y el código de la función incluir(a,elemento): * Pre: su precondición * Post: su postcondición void incluir (Conjunto& A, const char elemento) { su código 14

15 La función incluir(a,elemento): // para incorporar una letra a un conjunto de letras void incluir (Conjunto& A, const char elemento); Especificación de la función incluir(a,elemento): * Pre: elemento >= 'A' y elemento <= 'Z' * Post: <elemento> pertenece al conjunto A junto a * todas las letras que pertenecían inicialmente * al conjunto <A> void incluir (Conjunto& A, const char elemento); 15

16 Código de la función incluir(a,elemento): * Pre: elemento >= 'A' y elemento <= 'Z' * Post: <elemento> pertenece al conjunto A junto a * todas las letras que pertenecían inicialmente * al conjunto <A> void incluir (Conjunto& A, const char elemento) { A.elemento[elemento 'A'] = true; 16

17 La función excluir(a,elemento): // para excluir una letra de un conjunto de letras void excluir (Conjunto& A, const char elemento); Escribir la especificación y el código de la función excluir(a,elemento): * Pre: su precondición * Post: su postcondición void excluir (Conjunto& A, const char elemento); 17

18 La función excluir(a,elemento): // para excluir una letra de un conjunto de letras void excluir (Conjunto& A, const char elemento); Especificación de la función excluir(a,elemento): * Pre: elemento >= 'A' y elemento <= 'Z' * Post: <elemento> no pertenece al conjunto A mientras * que restantes letras que pertenecían inicial * mente a <A> siguen perteneciendo y solo ellas void excluir (Conjunto& A, char elemento); 18

19 Código de la función excluir(a,elemento): * Pre: elemento >= 'A' y elemento <= 'Z' * Post: <elemento> no pertenece al conjunto A mientras * que restantes letras que pertenecían inicial * mente a <A> siguen perteneciendo y solo ellas void excluir (Conjunto& A, char elemento) { A.elemento[elemento 'A'] = false; 19

20 La función cardinal(a): // para conocer cuántas letras pertenecen a un conjunto // de letras int cardinal (const Conjunto A); Escribir la especificación y el código de la función cardinal(a): * Pre: su precondición * Post: su postcondición int cardinal (const Conjunto A); 20

21 La función cardinal(a): // para conocer cuántas letras pertenecen a un conjunto // de letras int cardinal (const Conjunto A); Especificación de la función cardinal(a): * Pre: * Post: Devuelve el número de elementos del conjunto <A> int cardinal (const Conjunto A); 21

22 Código de la función cardinal(a): * Pre: * Post: Devuelve el número de elementos del conjunto <A> int cardinal (const Conjunto A) { int cuenta = 0; for (char letra = 'A'; letra <= 'Z'; ++letra) { if (A.elemento[letra 'A']) { cuenta = cuenta + 1; return cuenta; 22

23 La función opunion(a,b): // para calcular la unión de dos conjuntos de letras Conjunto opunion (const Conjunto A, const Conjunto B); Escribir la especificación y el código de la función opunion(a,b): * Pre: su precondición * Post: su postcondición Conjunto opunion (const Conjunto A, const Conjunto B) { su código 23

24 La función opunion(a,b): // para calcular la unión de dos conjuntos de letras Conjunto opunion (const Conjunto A, const Conjunto B); Especificación de la función opunion(a,b): * Pre: * Post: Devuelve la unión de los conjuntos <A> y <B> Conjunto opunion (const Conjunto A, const Conjunto B); 24

25 Código de la función opunion(a,b): * Pre: * Post: Devuelve la unión de los conjuntos <A> y <B> Conjunto opunion (const Conjunto A, const Conjunto B) { Conjunto C; for (int i = 0; i <= 'Z' 'A'; ++i) { C.elemento[i] = A.elemento[i] B.elemento[i]; return C; 25

26 La función opinterseccion(a,b): // para calcular la intersección de dos conjuntos de // letras Conjunto opinterseccion (const Conjunto A, const Conjunto B); Escribir la especificación y el código de la función opinterseccion(a,b): * Pre: su precondición * Post: su postcondición Conjunto opinterseccion (const Conjunto A, const Conjunto B) { su código 26

27 La función opinterseccion(a,b): // para calcular la intersección de dos conjuntos de // letras Conjunto opinterseccion (const Conjunto A, const Conjunto B); Especificación de la función opinterseccion(a,b): * Pre: * Post: Devuelve la intersección de los conjuntos <A> y <B> Conjunto opinterseccion (const Conjunto A, const Conjunto B); 27

28 Código de la función opinterseccion(a,b): * Pre: * Post: Devuelve la intersección de los conjuntos <A> * y <B> Conjunto opinterseccion (const Conjunto A, const Conjunto B) { Conjunto C; for (int i = 0; i <= 'Z' 'A'; ++i) { C.elemento[i] = A.elemento[i] && B.elemento[i]; return C; 28

29 La función opdiferencia(a,b): // para calcular la diferencia de dos conjuntos de letras Conjunto opdiferencia (const Conjunto A, const Conjunto B); Escribir la especificación y el código de la función opdiferencia(a,b): * Pre: su precondición * Post: su postcondición Conjunto opdiferencia (const Conjunto A, const Conjunto B) { su código 29

30 La función opdiferencia(a,b): // para calcular la diferencia de dos conjuntos de letras Conjunto opdiferencia (const Conjunto A, const Conjunto B); Especificación de la función opdiferencia(a,b): * Pre: * Post: Devuelve el conjunto diferencia A B Conjunto opdiferencia (const Conjunto A, const Conjunto B); 30

31 Código de la función opdiferencia(a,b): * Pre: * Post: Devuelve el conjunto diferencia A B Conjunto opdiferencia (const Conjunto A, const Conjunto B) { Conjunto C; for (int i = 0; i <= 'Z' 'A'; ++i) { C.elemento[i] = A.elemento[i] &&!B.elemento[i]; return C; 31

32 La función mostrar(a): // para mostrar por pantalla los elementos de un conjunto // de letras void mostrar (const Conjunto A); Escribir la especificación y el código de la función mostrar(a): * Pre: su precondición * Post: su postcondición void mostrar (const Conjunto A) { su código 32

33 La función mostrar(a): // para mostrar por pantalla los elementos de un conjunto // de letras void mostrar (const Conjunto A); Especificación de la función mostrar(a): * Pre: * Post: Presenta por pantalla, en una línea, los * elementos del conjunto <A> con el siguiente * formato: * { D, F, J, M, N, Q, S, Z void mostrar (Conjunto A); 33

34 Código de la función mostrar(a): * Pre: * Post: Presenta por pantalla, en una línea, los elementos * del conjunto <A> con el siguiente formato: * { D, F, J, M, N, Q, S, Z void mostrar (Conjunto A) { int cuenta = 0; for (int i = 0; i <= 'Z' 'A'; ++i) { if (A.elemento[i]) { cuenta = cuenta + 1; if (cuenta == 1) { cout << "{ " << char ('A' + i); else { cout << ", " << char ('A' + i); if (cuenta == 0) { cout << "{" << endl; else { cout << " " << endl; 34

35 La función guardar(nombrefichero,t,n): // para almacenar una secuencia de conjuntos de letras // en un fichero, en formato binario void guardar (const char nombrefichero[], const Conjunto T[], const int n); Escribir la especificación y el código de la función guardar( ): Pre: su precondición * Post: su postcondición void guardar (const char nombrefichero[], const Conjunto T[], const int n) { su código 35

36 La función guardar(nombrefichero,t,n): // para almacenar una secuencia de conjuntos de letras // en un fichero, en formato binario void guardar (const char nombrefichero[], const Conjunto T[], const int n); Especificación de la función guardar(nombrefichero,t,n): * Pre: * Post: Crea un fichero de nombre <nombrefichero> y escribe en * él la secuencia de datos binarios almacenada en T[0,n 1] void guardar (const char nombrefichero[], const Conjunto T[], const int n); 36

37 Código de la función guardar(nombrefichero,t,n): * Pre: * Post: Crea un fichero de nombre <nombrefichero> y escribe en * él la secuencia de datos binarios almacenada en T[0,n 1] void guardar (const char nombrefichero[], const Conjunto T[], const int n) { ofstream f; f.open(nombrefichero, ios::binary); for (int i = 0; i < n; ++i) { // Escribe el conjunto T[i] en el fichero f.write(reinterpret_cast<char *>(&T[i]), sizeof(conjunto)); f.close(); // Libera el fichero y lo disocia del flujo 37

38 La función recuperar(nombrefichero,t,n): // para leer una secuencia de conjuntos de letras // de un fichero que los almacena en formato binario bool recuperar (const char nombrefichero[], Conjunto T[], int& n); Escribir la especificación y el código de la función La función recuperar( ): * Pre: su precondición * Post: su postcondición bool recuperar (const char nombrefichero[], Conjunto T[], int& n) { su código 38

39 La función recuperar(nombrefichero,t,n): // para leer una secuencia de conjuntos de letras // de un fichero que los almacena en formato binario bool recuperar (const char nombrefichero[], Conjunto T[], int& n); Especificación de la función recuperar(nombrefichero,t,n): * Pre: <nombrefichero> es el nombre de un fichero que... * Post: Devuelve <false> si no es posible leer la... bool recuperar (const char nombrefichero[], Conjunto T[], int& n); 39

40 Especificación de la función recuperar(nombrefichero,t,n): * Pre: <nombrefichero> es el nombre de un fichero que almacena * una secuencia de datos binarios de tipo <Conjunto> * Post: Devuelve <false> si no es posible leer la información * del fichero <nombrefichero>. Si es posible, asigna a <n> * el número de conjuntos que almacena el fichero, * asigna a los elementos de T[0,n 1] los <n> datos de tipo * <Conjunto> almacenados en el fichero y devuelve <true>. bool recuperar (const char nombrefichero[], Conjunto T[], int& n); 40

41 Código de la función recuperar(nombrefichero,t,n): * Pre: <nombrefichero> es el nombre de un fichero que almacena... * Post: Devuelve <false> si no es posible leer la información... bool recuperar (const char nombrefichero[], Conjunto T[], int& n) { ifstream f; f.open(nombrefichero, ios::binary); n = 0; if (f.is_open()) { f.read(reinterpret_cast<char *>(&T[n]),sizeof(Conjunto)); while (!f.eof()) { n = n + 1 ; f.read(reinterpret_cast<char *>(&T[n]),sizeof(Conjunto)); f.close(); return true; else { return false; 41

42 42