programación 1 tema v – clase de...
TRANSCRIPT
Programación 1
Tema V – Clase de problemas
Desarrollo de un módulo de biblioteca C++ para trabajar con conjuntos de letras
1
1. Representación del tipo ConjuntoDebe definirse la representación de los datos de tipo Conjuntoen el módulo conjunto 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 eldiseño algorítmico de las funciones asociadas al tipo y velar por laeficiencia de éstas.
2
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
2. Diseño de las funciones del módulo Ahora deben especificarse cada una de las once funciones delmódulo conjunto presentadas en la lección 17 y, acontinuación, debe escribirse su código:
• Cada función se acompaña de una frase orientativa sobre sucomportamiento esperado. Se deben sustituir estas frases poruna especificación mucho más precisa, con su precondición ysu postcondición.
• Una vez especificada cada función, debe escribirse su códigoC++.
4
// para crear un conjunto vacío de letrasConjunto vacio ();
// para comprobar si una letra pertenece a un conjunto // de letrasbool pertenece (const Conjunto A, const char elemento);
// para incorporar una letra a un conjunto de letrasvoid incluir (Conjunto& A, const char elemento);
// para excluir una letra de un conjunto de letrasvoid excluir (Conjunto& A, const char elemento);
. . .
5
. . .
// para conocer cuántas letras pertenecen a un conjunto// de letrasint 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
. . .
// 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 binariovoid 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 binariobool recuperar (const char nombreFichero[],
Conjunto T[], int& n);
7
La función vacio():
// para crear un conjunto vacío de letrasConjunto 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
La función vacio():
// para crear un conjunto vacío de letrasConjunto vacio ();
Especificación de la función vacio():
/** Pre: ‐‐‐* Post: Devuelve un conjunto vacío de letras */Conjunto vacio ();
9
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
La función pertenece(A,elemento):
// para comprobar si una letra pertenece a un conjunto // de letrasbool 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
La función pertenece(A,elemento):
// para comprobar si una letra pertenece a un conjunto // de letrasbool 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
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
La función incluir(A,elemento):
// para incorporar una letra a un conjunto de letrasvoid incluir (Conjunto& A, const char elemento);
Escribir la especificación y el código de la funciónincluir(A,elemento):
/** Pre: … su precondición …* Post: … su postcondición …*/void incluir (Conjunto& A, const char elemento) {
… su código … }
14
La función incluir(A,elemento):
// para incorporar una letra a un conjunto de letrasvoid 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
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
La función excluir(A,elemento):
// para excluir una letra de un conjunto de letrasvoid excluir (Conjunto& A, const char elemento);
Escribir la especificación y el código de la funciónexcluir(A,elemento):
/** Pre: … su precondición …* Post: … su postcondición …*/void excluir (Conjunto& A, const char elemento);
17
La función excluir(A,elemento):
// para excluir una letra de un conjunto de letrasvoid 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
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
La función cardinal(A):
// para conocer cuántas letras pertenecen a un conjunto// de letrasint 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
La función cardinal(A):
// para conocer cuántas letras pertenecen a un conjunto// de letrasint 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
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
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
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
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
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ónopInterseccion(A,B):
/** Pre: … su precondición …* Post: … su postcondición …*/Conjunto opInterseccion (const Conjunto A,
const Conjunto B) { su código }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);
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
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
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ónopDiferencia(A,B):
/** Pre: … su precondición …* Post: … su postcondición …*/Conjunto opDiferencia (const Conjunto A, const Conjunto B) {
… su código … }
29
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
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
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
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
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
La función guardar(nombreFichero,T,n):
// para almacenar una secuencia de conjuntos de letras// en un fichero, en formato binariovoid 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
La función guardar(nombreFichero,T,n):
// para almacenar una secuencia de conjuntos de letras// en un fichero, en formato binariovoid 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
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 ficherof.write(reinterpret_cast<char *>(&T[i]), sizeof(Conjunto));
}f.close(); // Libera el fichero y lo disocia del flujo
}
37
La función recuperar(nombreFichero,T,n):
// para leer una secuencia de conjuntos de letras// de un fichero que los almacena en formato binariobool recuperar (const char nombreFichero[],
Conjunto T[], int& n);
Escribir la especificación y el código de la función La funciónrecuperar(…):
/** Pre: … su precondición …* Post: … su postcondición …*/bool recuperar (const char nombreFichero[],
Conjunto T[], int& n) { … su código … }38
La función recuperar(nombreFichero,T,n):
// para leer una secuencia de conjuntos de letras// de un fichero que los almacena en formato binariobool 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
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
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