Programación 1 Desarrollo de proyectos de programación. Desarrollo de un módulo C++ de biblioteca para trabajar con conjuntos de letras

Transcripción

1 Programación 1 Desarrollo de proyectos de programación Desarrollo de un módulo C++ de biblioteca para trabajar con conjuntos de letras

2 Objetivo del proyecto Desarrollo de un módulo C++ de biblioteca para trabajar con conjuntos de letras del alfabeto inglés: Nombre del módulo: conjunto Definición del tipo de datos Conjunto Un dato de tipo Conjunto tendrá como valor un conjunto de letras del alfabeto inglés: A, B, C,, X, Y, Z Colección de operaciones (funciones C++) que faciliten el trabajo con conjuntos de letras del alfabeto, es decir, con datos de tipo Conjunto

3 Análisis Qué es un conjunto? Una colección de elementos distintos Qué es un conjunto de letras del alfabeto inglés? Una colección de letras distintas del alfabeto inglés

4 Análisis. Conjuntos y elementos Conjunto vacío de letras { Conjuntos con un solo elemento { A { K Conjunto con dos elementos { X, H Conjunto con tres elementos { A, Z, G Conjunto de las letras vocales { A, E, I, O, U Conjunto de las letras de la J a la P { J, K, L, M, N, O, P Conjunto de todas las letras (Conjunto universal) { A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z

5 Análisis. Pertenencia Ningún elemento (letra del alfabeto) pertenece al conjunto vacío { A { B { C { Sólo la letra A pertenece al conjunto { A A { A B { A C { A Solo las cinco letras vocales pertenecen al conjunto { A, E, I, O, U A { A, E, I, O, U E { A, E, I, O, U I { A, E, I, O, U O { A, E, I, O, U U { A, E, I, O, U B { A, E, I, O, U C { A, E, I, O, U Y { A, E, I, O, U Z { A, E, I, O, U

6 Análisis. Cardinal El cardinal de un conjunto es el número de elementos que pertenecen a él. El cardinal de { es 0 El cardinal de { A es 1 El cardinal de { A, E, I, O, U es 5 El cardinal de { J, K, L, M, N, O, P es 7 El cardinal de { A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z es 26

7 Análisis. Unión La unión de dos conjuntos A y B es un conjunto A B tal que pertenecen a A B exclusivamente los elementos que pertenecen a A o que pertenecen a B. { { A, E, I, O, U = { A, E, I, O, U { A, B, C, E { A, E, I, O, U = { A, B, C, E, I, O, U { A, B, H { Z, Y, H, B = { A, B, H, Y, Z

8 Análisis. Intersección La intersección de dos conjuntos A y B es un conjunto A B tal que pertenecen a A B exclusivamente los elementos que pertenecen a A y también a B. { { A, E, I, O, U = { { A, B, C, E { A, E, I, O, U = { A, E { A, B, H, Z, E { Z, Y, H, B = { B, H, Z

9 Análisis. Diferencia La diferencia de dos conjuntos A y B es un conjunto A\B tal que pertenecen a A\B exclusivamente los elementos que pertenecen a A y no pertenecen a B. { \ { A, E, I, O, U = { { A, E, I, O, U \ { = { A, E, I, O, U { A, B, C, E \ { A, E, I, O, U = { B, C { A, E, I, O, U \ { A, B, C, E = { I, O, U { A, B, H \ { Z, Y, H, B = { A { Z, Y, H, B \ { A, B, H = { Z, Y

10 Diseño. Representación Definición de los datos de tipo Conjunto que representan un conjunto de letras del alfabeto inglés: Para ello se definirá un registro con uno o más campos: struct Conjunto {... ; La definición del tipo Conjunto deberá facilitar el diseño algorítmico de las operaciones asociadas al tipo y velar por la eficiencia de estas.

11 Diseño. Operaciones Funciones C++ para facilitar el trabajo con datos de tipo Conjunto. Definición de conjuntos con Álgebra de conjuntos valores bien definidos Unión Conjunto vacío Intersección Inclusión de una letra Diferencia Exclusión de una letra Consulta Pertenencia de un elemento Cardinal Persistencia en ficheros binarios Escritura de una tabla de conjuntos Lectura de una tabla de conjuntos Presentar en la pantalla

12 Representación 1. Tabla de booleanos const int MAX_ELEMENTOS = 'Z' - 'A' + 1; * 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[max_elementos - 2] <=> Y pertenece al conjunto * elemento[max_elementos - 1] <=> Z pertenece al conjunto struct Conjunto { bool elementos[max_elementos]; ;

13 Representación 2. Tabla de booleanos con cardinal explícito const int MAX_ELEMENTOS = 'Z' - 'A' + 1; * 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[max_elementos - 2] <=> Y pertenece al conjunto * elemento[max_elementos - 1] <=> Z pertenece al conjunto struct Conjunto { bool elementos[max_elementos]; int cardinal; ;

14 Representación 3. Lista de caracteres const int MAX_ELEMENTOS = 'Z' - 'A' + 1; * Representación de un conjunto de letras del alfabeto inglés: * las cardinal primeras componentes de elementos contienen las letras del * alfabeto inglés que pertenecen al conjunto. struct Conjunto { char elementos[max_elementos]; int cardinal; ;

15 Operaciones. Versión funcional * Pre: --- * Post: Ha devuelto un conjunto * vacío de letras del * alfabeto. Conjunto vacio();

16 Operaciones. Versión procedural * Pre: --- * Post: Ha vaciado el conjunto «A», * haciendo que represente el * conjunto vacío de letras * del alfabeto. void vaciar(conjunto& A);

17 Operaciones. Versión funcional * Pre: «elemento» es una letra del * alfabeto inglés. * Post: Ha devuelto el conjunto * «A» {«elemento». Conjunto incluir(const Conjunto A, const char elemento);

18 Operaciones. Versión procedural * Pre: «elemento» es una letra del * alfabeto inglés. «A» = A 0 * Post: Ha añadido al conjunto «A» la * letra «elemento», haciendo que * represente el conjunto * A 0 U {«elemento». void incluir(conjunto& A, const char elemento);

19 Operaciones. Versión funcional * Pre: --- * Post: Ha devuelto la unión de los * conjuntos «A» y «B». Conjunto unir(const Conjunto A, const Conjunto B);

20 Operaciones. Versión procedural * Pre: «A» = A 0. * Post: «A» = A 0 U «B». void unir(conjunto& A, const Conjunto B);

21 Una solución Representación 1: tabla de booleanos Versión funcional

22 Definición del tipo Conjunto const int MAX_ELEMENTOS = 'Z' - 'A' + 1; * 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 *... struct Conjunto { bool elementos[max_elementos]; ;

23 Conjunto vacío * Pre: --- * Post: Ha devuelto un conjunto * vacío de letras del * alfabeto. Conjunto vacio();

24 Conjunto vacío * Pre: --- * Post: Ha devuelto un conjunto vacío de letras del * alfabeto. Conjunto vacio() { Conjunto resultado; for (int i = 0; i < MAX_ELEMENTOS; i++) { resultado.elementos[i] = false; return resultado;

25 Inclusión y exclusión de elementos * Pre: «elemento» es una letra del alfabeto inglés. * Post: Ha devuelto el conjunto «A» U {«elemento». Conjunto incluir(const Conjunto A, const char elemento); * Pre: «elemento» es una letra del alfabeto inglés. * Post: Ha devuelto el conjunto «A» \ {«elemento». Conjunto excluir(const Conjunto A, const char elemento);

26 Inclusión y exclusión de elementos * Pre: «elemento» es una letra del alfabeto inglés. * Post: Si «incluir» es true, ha devuelto el conjunto «A» U * {«elemento». En caso contrario, ha devuelto el * conjunto «A» \ {«elemento». Conjunto modificar(const Conjunto A, const char elemento, const bool incluir) { Conjunto resultado = A; char letra = toupper(elemento); bool esta = A.elementos[letra - 'A']; resultado.elementos[letra - 'A'] = incluir; return resultado;

27 Inclusión y exclusión de elementos * Pre: «elemento» es una letra del alfabeto inglés. * Post: Ha devuelto el conjunto «A» U {«elemento». Conjunto incluir(const Conjunto A, const char elemento) { return modificar(a, elemento, true); * Pre: «elemento» es una letra del alfabeto inglés. * Post: Ha devuelto el conjunto «A» \ {«elemento». Conjunto excluir(const Conjunto A, const char elemento) { return modificar(a, elemento, false);

28 Función toupper Biblioteca <cctype> int toupper ( int c ); Convert lowercase letter to uppercase Converts c to its uppercase equivalent if c is a lowercase letter and has an uppercase equivalent. If no such conversion is possible, the value returned is c unchanged. [ ] Parameters c: Character to be converted, casted to an int, or EOF. Return Value The uppercase equivalent to c, if such value exists, or c (unchanged) otherwise. The value is returned as an int value that can be implicitly casted to char. See also tolower Convert uppercase letter to lowercase (function ) islower Check if character is lowercase letter (function ) isupper Check if character is uppercase letter (function ) isalpha Check if character is alphabetic (function ) Fuente:

29 Pertenencia * Pre: «elemento» es una letra del * alfabeto inglés. * Post: Ha devuelto true si y solo si * «elemento» pertenece al * conjunto A. bool pertenece(const Conjunto A, const char elemento);

30 Pertenencia * Pre: «elemento» es una letra del * alfabeto inglés. * Post: Ha devuelto true si y solo si * «elemento» pertenece al conjunto A. bool pertenece(const Conjunto A, const char elemento) { char letra = toupper(elemento); return A.elementos[letra - 'A'];

31 Cardinalidad * Pre: --- * Post: Ha devuelto el número de * elementos del conjunto «A». int cardinal(const Conjunto A);

32 Cardinalidad * Pre: --- * Post: Ha devuelto el número de elementos del * conjunto «A». int cardinal(const Conjunto A) { int resultado = 0; for (int i = 0; i < MAX_ELEMENTOS; i++) { if (A.elementos[i]) { resultado++; return resultado;

33 Álgebra de conjuntos * Pre: --- * Post: Ha devuelto la unión de los conjuntos «A» y «B». Conjunto unir(const Conjunto A, const Conjunto B); * Pre: --- * Post: Ha devuelto la intersección de los conjuntos «A» y «B». Conjunto intersectar(const Conjunto A, const Conjunto B); * Pre: --- * Post: Ha devuelto la diferencia de los conjuntos «A» y «B». Conjunto calculardiferencia(const Conjunto A, const Conjunto B);

34 Álgebra de conjuntos Conjunto unir(const Conjunto A, const Conjunto B) { Conjunto resultado; for (int i = 0; i < MAX_ELEMENTOS; i++) { resultado.elementos[i] = A.elementos[i] B.elementos[i]; return resultado; Conjunto intersectar(const Conjunto A, const Conjunto B) { Conjunto resultado; for (int i = 0; i < MAX_ELEMENTOS; i++) { resultado.elementos[i] = A.elementos[i] && B.elementos[i]; return resultado;

35 Álgebra de conjuntos * Pre: --- * Post: Ha devuelto la diferencia de los conjuntos «A» y «B». Conjunto calculardiferencia(const Conjunto A, const Conjunto B) { Conjunto resultado = A; for (int i = 0; i < MAX_ELEMENTOS; i++) { if (B.elementos[i]) { resultado.elementos[i] = false; return resultado;

36 Escribir en pantalla * Pre: --- * Post: Presenta por pantalla, en * una línea, los elementos * del conjunto «A». void mostrar (const Conjunto A);

37 Escribir en pantalla * Pre: --- * Post: Escribe en «s» los elementos del conjunto «c». void escribir (ostream& s, const Conjunto c) { s << '{'; bool separar = false; for (int i = 0; i < MAX_ELEMENTOS; i++) { if (c.elementos[i]) { if (separar) { s << ','; else { separar = true; s << ' ' << char('a' + i); s << " ";

38 Escribir en pantalla * Pre: --- * Post: Presenta por pantalla, en una * línea, los elementos del * conjunto «A». void mostrar (const Conjunto A) { escribir(cout, A); cout << endl;

39 Persistencia * Pre: --- * Post: Ha creado un fichero de nombre «nombrefichero» y ha escrito en él la * secuencia de datos binarios almacenada en T[0, n - 1]. void guardar(const char nombrefichero[], const Conjunto T[], const int n); * Pre: «nombrefichero» es el nombre de un fichero que almacena una * secuencia de datos binarios de tipo Conjunto. * Post: Ha devuelto «false» si no es posible leer la información del fichero * «nombrefichero». Si es posible, ha asignado a «n» el número de * conjuntos que almacena el fichero, ha asignado a los elementos de * T[0, n - 1] los «n» datos de tipo Conjunto almacenados en el fichero * y ha devuelto «true». bool leer(const char nombrefichero[], Conjunto T[], int& n);

40 Persistencia void guardar(const char nombrefichero[], const Conjunto T[], const int n) { ofstream f; f.open(nombrefichero, ios::binary); if (f.is_open()) { for (int i = 0; i < n; i++) { f.write(reinterpret_cast<const char*>(&t[i]), sizeof(t[i])); f.close(); else { cerr << "No se ha podido escribir en \"" << nombrefichero << "\"" << endl;

41 Persistencia bool leer(const char nombrefichero[], Conjunto T[], int& n) { ifstream f; f.open(nombrefichero, ios::binary); if (f.is_open()) { n = 0; f.read(reinterpret_cast<char*>(&t[n]), sizeof(t[n])); while (!f.eof()) { n++; f.read(reinterpret_cast<char*>(&t[n]), sizeof(t[n])); f.close(); return true; else { cerr << "No se ha podido leer del \"" << nombrefichero << "\"" << endl; return false;