Ejercicios de la sesión 4 de C resueltos

Transcripción

1 Ejercicios de la sesión 4 de C resueltos 1. Usando el procedimiento del ejercicio 2 del seminario anterior, escribe un programa que multiplique dos matrices A y B leídas de ficheros, la primera de tamaño n m y la segunda de tamaño m p. Las matrices deben leerse cada una de un fichero distinto y el resultado debe estar en otro fichero. El formato del fichero es el siguiente: en la primera línea habrán 2 enteros, indicando el tamaño de la matriz en cada dimensión. A continuación vienen las filas de la matriz, cada una en una misma línea. Los valores son números reales. El resultado debe estar en otro fichero con el mismo formato. Por ejemplo, un fichero de definición de una matríz podría ser el siguiente: Los nombres de los ficheros serán los argumentos del programa o (si no existen) se solicitarán a través del teclado. Solución: Una posible implementación sería ésta: #include <stdlib.h> #include <limits.h> #include <string.h> * * Crea una matriz de doubles de tamaño N x M, reservando la memoria de * forma dinámica. double *creamatriz(int m, int n) { return calloc(m*n, sizeof (double)); * * Multiplica dos matrices A y B, escribiendo el resultado en una tercera C. * Las matrices a multiplicar deben ser de dimensiones compatibles, en otro * caso se devuelve el valor NULL como resultado. Si todo funciona correctamente, * se devuelve como resultado un puntero a C. Si C, que se pasa como parámetro, * tiene como valor NULL, se reserva espacio para una nueva matriz y se devuelve * el puntero como resultado. * Parametros: * - double *A: puntero a la matriz A * - int m: filas de A * - int n: columnas de A * - double *B: puntero a la matriz B * - int r: filas de B * - int s: columnas de B * - double *C: puntero a la matriz C (puede ser NULL si se quiere crear) * - int *t: puntero a filas de C (para poder escribirlo en caso de crearla) * - int *u: puntero a columnas de C (para poder escribirlo en caso de crearla) 1/13

2 * * Devuelve: NULL en caso de error. Un puntero a la matriz resultante en otro * caso. Si C era NULL, se creará una nueva matriz. En *t y *u se escribiran * las dimensiones de la nueva matriz. double *multiplicamatrices(double *A, int m, int n, double *B, int r, int s, double *C, int *t, int *u) { int i, j, k; if (n!= r) return NULL; //Dimensiones incompatibles if (C && (m>*t s>*u)) return NULL; //Dimensiones del C existente incorrectas if (!C) { // Si C es NULL, creamos la matriz resultado C = creamatriz(m, s); *t = m; *u = s; for (i = 0; i < m; i++) { //Recorremos filas for (j = 0; j < s; j++) { //Recorremos columnas C[i * s + j] = 0; //Inicializamos el valor para la posicion i,j for (k = 0; k < n; k++) { C[i * s + j] += A[i * n + k] * B[k * s + j]; return C; * Lee una matriz del fichero indicado nombrefichero, reservando la memoria * en M e indicando las dimensiones en m y n. Devuelve M=NULL en caso de * error, indicando el codigo de error en n. void leematriz(char *nombrefichero, double **M, int *m, int *n) { FILE *f; f = fopen(nombrefichero, "r"); if (!f) { *M = NULL; *m = 0; *n = 1; // El fichero no se ha podido abrir return; if (fscanf(f, "%d %d\n", m, n)!= 2) { *M = NULL; *m = 0; *n = 2; // Las dimensiones no se han podido leer return; *M = creamatriz(*m, *n); if (!*M) { *M = NULL; *m = 0; 2/13

3 *n = 3; //Imposible reservar la memoria return; int i, j; float v; for (i = 0; i<*m; i++) { for (j = 0; j<*n; j++) { fscanf(f, "%f", &v); (*M)[i * (*n) + j] = v; * Escribe la matriz M con dimensiones m X n en el fichero indicado * nombrefichero. Devuelve 0 en caso de ejecución correcta. int escribematriz(char *nombrefichero, double *M, int m, int n) { FILE *f; int i, j; f = fopen(nombrefichero, "w"); if (!f) { return 1; //No se puede crear el fichero fprintf(f, "%d %d\n", m, n); for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { fprintf(f, "%g ", M[i * n + j]); putc('\n', f); return 0; * Imprime una matriz por la salida estándar void imprimematriz(double *M, int m, int n) { int i, j; for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { printf("%g ", M[i * n + j]); putchar('\n'); Principal int main(int argc, char *argv[]) { double *A, *B, *C = NULL; int am, an, bm, bn, cm, cn; // Dimensiones char *matriza, *matrizb, *matrizc; int sz; if (argc < 2) { 3/13

4 printf("indique el nombre del fichero con la matriz A: "); matriza = malloc(path_max + 1); fgets(matriza, PATH_MAX, stdin); if (!(sz = strlen(matriza))) { return EXIT_SUCCESS; if (matriza[sz - 1] == '\n') matriza[sz - 1] = '\0'; else { matriza = argv[1]; leematriz(matriza, &A, &am, &an); if (!A) { printf(" Imposible leer A de %s, código de error %d!\n", matriza, an); printf("leido A =\n"); imprimematriz(a, am, an); if (argc < 3) { printf("indique el nombre del fichero con la matriz B: "); matrizb = malloc(path_max + 1); fgets(matrizb, PATH_MAX, stdin); if (!(sz = strlen(matrizb))) { return EXIT_SUCCESS; if (matrizb[sz - 1] == '\n') matrizb[sz - 1] = '\0'; else { matrizb = argv[2]; leematriz(matrizb, &B, &bm, &bn); if (!B) { printf(" Imposible leer B de %s, código de error %d!\n", matrizb, bn); printf("leido B =\n"); imprimematriz(b, bm, bn); C = multiplicamatrices(a, am, an, B, bm, bn, C, &cm, &cn); if (!C) { printf(" Imposible multiplicar AxB!\n"); printf("\nc = AxB =\n"); imprimematriz(c, cm, cn); if (argc < 4) { printf("indique el nombre del fichero donde guardar la matriz C: "); matrizc = malloc(path_max + 1); fgets(matrizc, PATH_MAX, stdin); if (!(sz = strlen(matrizc))) { return EXIT_SUCCESS; if (matrizc[sz - 1] == '\n') matrizc[sz - 1] = '\0'; 4/13

5 else { matrizc = argv[3]; if (escribematriz(matrizc, C, cm, cn)) { printf(" Imposible escribir C en %s!\n", matrizc); Liberamos la memoria free(a); free(b); free(c); if (argc < 2) free(matriza); if (argc < 3) free(matrizb); if (argc < 4) free(matrizc); return (EXIT_SUCCESS); 2. Dado el programa escrito en el ejercicio anterior (cálculo del producto de dos matrices) dividir el código en tres módulos: Ficheros (funciones de entrada salida), Matematico (tipo de datos matriz y producto de matrices) y Principal (programa principal). Crea un fichero makefile para generar automáticamente el programa ejecutable. Solución: Una posible implementación sería ésta: * Fichero: matematico.h #ifndef _MATEMATICO_H #define _MATEMATICO_H * * Crea una matriz de doubles de tamaño N x M, reservando la memoria de * forma dinámica. double *creamatriz(int m, int n); * * Multiplica dos matrices A y B, escribiendo el resultado en una tercera C. * Las matrices a multiplicar deben ser de dimensiones compatibles, en otro * caso se devuelve el valor NULL como resultado. Si funciona correctamente, * se devuelve como resultado un puntero a C. Si C tiene como valor NULL, * se reserva espacio para una nueva matriz y se devuelve el puntero. * Parametros: * - double *A: puntero a la matriz A * - int m: filas de A * - int n: columnas de A * - double *B: puntero a la matriz B * - int r: filas de B * - int s: columnas de B 5/13

6 * - double *C: puntero a la matriz C (puede ser NULL si se quiere crear) * - int *t: puntero a filas de C (para poder escribirlo en caso de crearla) * - int *u: puntero a columnas de C (para poder escribirlo) * * Devuelve: NULL en caso de error. Un puntero a la matriz resultante en otro * caso. Si C era NULL, se creará una nueva matriz. En *t y *u se escribiran * las dimensiones de la nueva matriz. double *multiplicamatrices(double *A, int m, int n, double *B, int r, int s, double *C, int *t, int *u); #endif _MATEMATICO_H * Fichero: matematico.c #include "matematico.h" #include <stdlib.h> * * Crea una matriz de doubles de tamaño N x M, reservando la memoria de * forma dinámica. double *creamatriz(int m, int n) { return calloc(m*n, sizeof (double)); * * Multiplica dos matrices A y B, escribiendo el resultado en una tercera C. * Las matrices a multiplicar deben ser de dimensiones compatibles, en otro * caso se devuelve el valor NULL como resultado. Si todo funciona correctamente, * se devuelve como resultado un puntero a C. Si C, que se pasa como parámetro, * tiene como valor NULL, se reserva espacio para una nueva matriz y se devuelve * el puntero como resultado. * Parametros: * - double *A: puntero a la matriz A * - int m: filas de A * - int n: columnas de A * - double *B: puntero a la matriz B * - int r: filas de B * - int s: columnas de B * - double *C: puntero a la matriz C (puede ser NULL si se quiere crear) * - int *t: puntero a filas de C (para poder escribirlo en caso de crearla) * - int *u: puntero a columnas de C (para poder escribirlo en caso de crearla) * * Devuelve: NULL en caso de error. Un puntero a la matriz resultante en otro * caso. Si C era NULL, se creará una nueva matriz. En *t y *u se escribiran * las dimensiones de la nueva matriz. double *multiplicamatrices(double *A, int m, int n, double *B, int r, int s, 6/13

7 double *C, int *t, int *u) { int i, j, k; if (n!= r) return NULL; //Dimensiones incompatibles if (C && (m>*t s>*u)) return NULL; //Dimensiones del C existente incorrectas if (!C) { // Si C es NULL, creamos la matriz resultado C = creamatriz(m, s); *t = m; *u = s; for (i = 0; i < m; i++) { //Recorremos filas for (j = 0; j < s; j++) { //Recorremos columnas C[i * s + j] = 0; //Inicializamos el valor para la posicion i,j for (k = 0; k < n; k++) { C[i * s + j] += A[i * n + k] * B[k * s + j]; return C; * File: ficheros.h #ifndef _FICHEROS_H #define _FICHEROS_H * Lee una matriz del fichero indicado nombrefichero, reservando la memoria * en M e indicando las dimensiones en m y n. Devuelve M=NULL en caso de * error, indicando el código de error en n. void leematriz(char *nombrefichero, double **M, int *m, int *n); * Escribe la matriz M con dimensiones m X n en el fichero indicado * nombrefichero. Devuelve 0 en caso de ejecución correcta. int escribematriz(char *nombrefichero, double *M, int m, int n); #endif _FICHEROS_H * File: ficheros.c #include "ficheros.h" #include <stdio.h> #include "matematico.h" 7/13

8 * Lee una matriz del fichero indicado nombrefichero, reservando la memoria * en M e indicando las dimensiones en m y n. Devuelve M=NULL en caso de * error, indicando el código de error en n. void leematriz(char *nombrefichero, double **M, int *m, int *n) { FILE *f; f = fopen(nombrefichero, "r"); if (!f) { *M = NULL; *n = 1; // El fichero no se ha podido abrir return; if (fscanf(f, "%d %d\n", m, n)!= 2) { *M = NULL; *n = 2; // Las dimensiones no se han podido leer return; *M = creamatriz(*m, *n); if (!*M) { *M = NULL; *n = 3; //Imposible reservar la memoria return; int i, j; float v; for (i = 0; i<*m; i++) { for (j = 0; j<*n; j++) { fscanf(f, "%f", &v); (*M)[i * (*n) + j]=v; * Escribe la matriz M con dimensiones m X n en el fichero indicado * nombrefichero. Devuelve 0 en caso de ejecución correcta. int escribematriz(char *nombrefichero, double *M, int m, int n) { FILE *f; int i, j; f = fopen(nombrefichero, "w"); if (!f) { return 1; //No se puede crear el fichero fprintf(f, "%d %d\n", m, n); for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { fprintf(f, "%g ", M[i * n + j]); putc('\n', f); 8/13

9 return 0; * File: principal.c #include <stdio.h> #include <stdlib.h> #include <limits.h> #include <string.h> #include "matematico.h" #include "ficheros.h" * Imprime una matriz por la salida estándar void imprimematriz(double *M, int m, int n) { int i, j; for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { printf("%g ", M[i * n + j]); putchar('\n'); * Programa de prueba int main(int argc, char *argv[]) { double *A, *B, *C = NULL; int am, an, bm, bn, cm, cn; // Dimensiones char *matriza, *matrizb, *matrizc; int sz; if (argc < 2) { printf("indique el nombre del fichero con la matriz A: "); matriza = malloc(path_max + 1); fgets(matriza, PATH_MAX, stdin); if (!(sz = strlen(matriza))) { return EXIT_SUCCESS; if (matriza[sz - 1] == '\n') matriza[sz - 1] = '\0'; else { matriza = argv[1]; leematriz(matriza, &A, &am, &an); if (!A) { printf(" Imposible leer A de %s, código de error %d!\n", matriza, an); printf("leido A =\n"); imprimematriz(a, am, an); 9/13

10 if (argc < 3) { printf("indique el nombre del fichero con la matriz B: "); matrizb = malloc(path_max + 1); fgets(matrizb, PATH_MAX, stdin); if (!(sz = strlen(matrizb))) { return EXIT_SUCCESS; if (matrizb[sz - 1] == '\n') matrizb[sz - 1] = '\0'; else { matrizb = argv[2]; leematriz(matrizb, &B, &bm, &bn); if (!B) { printf(" Imposible leer B de %s, código de error %d!\n", matrizb, bn); printf("leido B =\n"); imprimematriz(b, bm, bn); C = multiplicamatrices(a, am, an, B, bm, bn, C, &cm, &cn); if (!C) { printf(" Imposible multiplicar AxB!\n"); printf("\nc = AxB =\n"); imprimematriz(c, cm, cn); if (argc < 4) { printf("indique el nombre del fichero donde guardar la matriz C: "); matrizc = malloc(path_max + 1); fgets(matrizc, PATH_MAX, stdin); if (!(sz = strlen(matrizc))) { return EXIT_SUCCESS; if (matrizc[sz - 1] == '\n') matrizc[sz - 1] = '\0'; else { matrizc = argv[3]; if (escribematriz(matrizc, C, cm, cn)) { printf(" Imposible escribir C en %s!\n", matrizc); Liberamos la memoria free(a); free(b); free(c); if (argc < 2) free(matriza); if (argc < 3) free(matrizb); if (argc < 4) free(matrizc); 10/13

11 return (EXIT_SUCCESS); ## -*- Makefile -*- CFLAGS = -g -Wall # Enlaza todos los.o en un fichero final ejecutable a.out: principal.o matematico.o ficheros.o gcc $(CFLAGS) -o $@ principal.o matematico.o ficheros.o # Compila ficheros fuente en ficheros.o principal.o: principal.c matematico.h ficheros.h gcc $(CFLAGS) -c principal.c matematico.o: matematico.c matematico.h gcc $(CFLAGS) -c matematico.c ficheros.o: ficheros.c ficheros.h matematico.h gcc $(CFLAGS) -c ficheros.c #### Para limpiar el directorio de ficheros generados #### clean: rm -f a.out *.o 3. Escribe un programa que dado un nombre de fichero, que se pasará como parámetro en la línea de comandos, haga que la primera letra de cada palabra esté en mayúsculas. Se deberá poder compilar en modo debug, mostrando en ese caso los principales pasos de ejecución. Crea un fichero makefile para generar automáticamente el programa ejecutable. Solución: Una posible implementación sería ésta: * File: ponmayusculas.h #ifndef _PONMAYUSCULAS_H #define _PONMAYUSCULAS_H * * Abre el fichero *nombrefichero* en modo lectura escritura y cambia la * primera letra de capa palabra a mayúsculas. * Devuelve 0 si todo va bien, un código de error en otro caso. int ponmayusculas(char *nombrefichero); #endif _PONMAYUSCULAS_H * File: ponmayusculas.c 11/13

12 #include "ponmayusculas.h" #include <stdio.h> #include <ctype.h> int ponmayusculas(char* nombrefichero) { FILE *f; int c; f = fopen(nombrefichero, "r+"); if (!f) { #ifdef DEBUG fprintf(stderr, "El fichero %s no se ha podido abrir correctamente\n", nombrefichero); #endif return 1; #ifdef DEBUG fprintf(stderr, "Fichero %s abierto correctamente\n", nombrefichero); #endif while (!feof(f)) { #ifdef DEBUG fprintf(stderr, "Buscando inicio de palabra... "); #endif while (!isalnum(c = getc(f)) &&!feof(f));//buscamos principio palabra if (feof(f)) break; #ifdef DEBUG fprintf(stderr, "encontrado '%c', convirtiendo en '%c'\n", c, toupper(c)); #endif fseek(f, -1, SEEK_CUR); //Nos movemos uno atrás para sobreescribir putc(toupper(c), f); //Sobreescribimos con la versión en mayúsculas while (isalpha(c = getc(f)) &&!feof(f)); //Saltamos el resto palabra #ifdef DEBUG fprintf(stderr, "\nfichero %s procesado completamente\n", nombrefichero); #endif return 0; * File: principal.c #include <stdio.h> #include <stdlib.h> #include "ponmayusculas.h" void imprimeuso(char *ejecutable) { fprintf(stderr, "Uso del programa:\n\t%s <nombre_fichero_a_procesar>\n", ejecutable); 12/13

13 fputs(" Este programa modifica el 'fichero_a_procesar' convirtiendo", stderr); fputs("cada primera letra de cada palabra a mayusculas.", stderr); int main(int argc, char** argv) { if (argc < 2) { imprimeuso(argv[0]); if (ponmayusculas(argv[1])) { fprintf(stderr, "El fichero %s ha sido imposible de procesar\n", argv[1]); imprimeuso(argv[0]); return (EXIT_SUCCESS); ## -*- Makefile -*- CFLAGS = -g -Wall -DDEBUG #CFLAGS = -g -Wall # Enlaza todos los.o en un fichero final ejecutable a.out: principal.o ponmayusculas.o gcc $(CFLAGS) -o $@ principal.o ponmayusculas.o # Compila ficheros fuente en ficheros.o principal.o: principal.c ponmayusculas.h gcc $(CFLAGS) -c principal.c ponmayusculas.o: ponmayusculas.c ponmayusculas.h gcc $(CFLAGS) -c ponmayusculas.c #### Para limpiar el directorio de ficheros generados #### clean: rm -f a.out *.o 13/13