Soluciones profe del Cat: Flujos de Información, malloc y free

Solucion 1 del profe:
Es la mas fiable...
#include <stdio.h>

int main(int argc, char **argv) {
    FILE *pf;
    char caracter;
    int errores = 0;
    int c = 0;
   
    // Recorre los argumentos (nombres de fichero) saltándose el 0
    for(c = 1; c < argc; c++) {
        // el objetivo de este bucle es el que se puedan mostrar mas de un archivo
        // Abrimos el archivo de lectura
        if((pf = fopen(argv[c], "r")) == NULL) {
            // Si hay fallo, mostramos el mensaje usando stderr como salida
           // fijaros que el error lo mando mediante fprintf a stderr
            fprintf(stderr, "%s: %s: No se puede abrir el fichero\n", argv[0], argv[c]);
            errores++;
        } else {
            // Lee el primer caracter del archivo ¡porque es posible que el archivo este vacio!
            caracter = fgetc(pf);
            // Mientras no sea fin de fechero
            while(!feof(pf)) {
                // Escribe el caracter leido en stdout y lee el siguiente
                fputc(caracter, stdout); // lo muestro en la salida estandar, que coincide ahora en la pantalla
                caracter = fgetc(pf);
            }
            // Cierra el archivo
            fclose(pf);
        }
    // se repite el proceso de mostrar el siguiente archivo (argumento siguiente)
    }
   
    // Devuelve la cantidad de errores. 0 si no hay errores.
    return errores;
}

Notas:
Existen en C hay 3 clases flujos de información (también llamaos cauces de datos), que son 3 ficheros que estan siempre abiertos:
    stdin:  entrada standard teclado, pero podemos rederigirlo a otro lado
    stdout; salida estandar pantalla inicial,( " " )
    stderr: Error salida a pantalla

Los ficheros .log, contienen un registro de sucesos, que cada programa puede ir manteniendo informando de lo que hace el programa, errores, situaciones erroneas, ataques desde internet, etc.




Solucion 2 del profe:
Con una pequeña diferencia, en lugar de leer caracter por caracter,leemos lineas (tamaño de linea TAM_BUF, tabla buf)

#include <stdio.h>

#define TAM_BUF 1024 // 1 kbyte

int main(int argc, char **argv) {
    FILE *pf;
    char buf[TAM_BUF];
    int errores = 0;
    int c = 0;
   
    // Recorre los argumentos (nombres de fichero) saltándose el 0
    for(c = 1; c < argc; c++) {
        // Abrimos el archivo de lectura
        if((pf = fopen(argv[c], "r")) == NULL) {
            // Si hay fallo, mostramos el mensaje usando stderr como salida
            fprintf(stderr, "%s: %s: No se puede abrir el fichero\n", argv[0], argv[c]);
            errores++;
        } else {
            // Lee la primera cadena del archivo (si lee una linea de menos caracteres de 1024, lee los que hay)
            fgets(buf, TAM_BUF, pf);
            // Mientras no sea fin de fechero
            while(!feof(pf)) {
                // Escribe el linea cadena en stdout y lee el siguiente
                fputs(buf, stdout);
                fgets(buf, TAM_BUF, pf);
            }
            // Cierra el archivo
            fclose(pf);
        }
    }
   
    // Devuelve la cantidad de errores. 0 si no hay errores.
    return errores;
}



Solucion 3: malloc y free
#include <stdio.h>
#include <stdlib.h>

#define TAM_BUF 32768 //

int main(int argc, char **argv) {
    FILE *pf;
    char *buf; // para manejar una tabla de caracteres lo mejor es usar puntero a cadena de caracteres.
    int errores = 0;
    int c = 0;
   
    // Asigna memoria al buffer
    // malloc: memory a locate
    buf = malloc(TAM_BUF);
    // Recorre los argumentos (nombres de fichero) saltándose el 0
    for(c = 1; c < argc; c++) {
        // Abrimos el archivo de lectura
        if((pf = fopen(argv[c], "r")) == NULL) {
            // Si hay fallo, mostramos el mensaje usando stderr como salida
            fprintf(stderr, "%s: %s: No se puede abrir el fichero\n", argv[0], argv[c]);
            errores++;
        } else {
            // Lee el primer caracter del archivo
            fread(buf, 1, TAM_BUF, pf);
            // Mientras no sea fin de fechero
            while(!feof(pf)) {
                // Escribe el buffer de TAM_BUF  en stdout y lee el siguiente
                fwrite(buf, 1, TAM_BUF, stdout);
                fread(buf, 1, TAM_BUF, pf);
            }
            // Cierra el archivo
            fclose(pf);
        }
    }
   
    free(buf);
   
    // Devuelve la cantidad de errores. 0 si no hay errores.
    return errores;
}


Nota:
malloc: