C lee el archivo línea por línea

Escribí esta función para leer una línea de un archivo:

const char *readLine(FILE *file) {

    if (file == NULL) {
        printf("Error: file pointer is null.");
        exit(1);
    }

    int maximumLineLength = 128;
    char *lineBuffer = (char *)malloc(sizeof(char) * maximumLineLength);

    if (lineBuffer == NULL) {
        printf("Error allocating memory for line buffer.");
        exit(1);
    }

    char ch = getc(file);
    int count = 0;

    while ((ch != '\n') && (ch != EOF)) {
        if (count == maximumLineLength) {
            maximumLineLength += 128;
            lineBuffer = realloc(lineBuffer, maximumLineLength);
            if (lineBuffer == NULL) {
                printf("Error reallocating space for line buffer.");
                exit(1);
            }
        }
        lineBuffer[count] = ch;
        count++;

        ch = getc(file);
    }

    lineBuffer[count] = '\0';
    char line[count + 1];
    strncpy(line, lineBuffer, (count + 1));
    free(lineBuffer);
    const char *constLine = line;
    return constLine;
}

La función lee el archivo correctamente, y usando printf veo que la cadena constLine también se leyó correctamente.

Sin embargo, si uso la función, por ejemplo, así:

while (!feof(myFile)) {
    const char *line = readLine(myFile);
    printf("%s\n", line);
}

printf produce galimatías. ¿Por qué?

Si su tarea no es inventar la función de lectura línea por línea, sino solo leer el archivo línea por línea, puede usar un fragmento de código típico que involucre la getline()función (consulte la página del manual aquí ):

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    FILE * fp;
    char * line = NULL;
    size_t len = 0;
    ssize_t read;

    fp = fopen("/etc/motd", "r");
    if (fp == NULL)
        exit(EXIT_FAILURE);

    while ((read = getline(&line, &len, fp)) != -1) {
        printf("Retrieved line of length %zu:\n", read);
        printf("%s", line);
    }

    fclose(fp);
    if (line)
        free(line);
    exit(EXIT_SUCCESS);
}

FILE* filePointer;
int bufferLength = 255;
char buffer[bufferLength];

filePointer = fopen("file.txt", "r");

while(fgets(buffer, bufferLength, filePointer)) {
    printf("%s\n", buffer);
}

fclose(filePointer);

En su readLinefunción, devuelve un puntero a la linematriz (en sentido estricto, un puntero a su primer carácter, pero la diferencia es irrelevante aquí). Como es una variable automática (es decir, está "en la pila"), la memoria se recupera cuando la función regresa. Ves galimatías porque printfha puesto sus propias cosas en la pila.

Debe devolver un búfer asignado dinámicamente desde la función. Ya tienes uno, es lineBuffer; todo lo que tiene que hacer es truncarlo a la longitud deseada.

    lineBuffer[count] = '\0';
    realloc(lineBuffer, count + 1);
    return lineBuffer;
}

AGREGADO (respuesta a la pregunta de seguimiento en el comentario): readLinedevuelve un puntero a los caracteres que forman la línea. Este puntero es lo que necesita para trabajar con el contenido de la línea. También es a lo que debe pasar freecuando haya terminado de usar la memoria tomada por estos personajes. Así es como puede usar la readLinefunción:

char *line = readLine(file);
printf("LOG: read a line: %s\n", line);
if (strchr(line, 'a')) { puts("The line contains an a"); }
/* etc. */
free(line);
/* After this point, the memory allocated for the line has been reclaimed.
   You can't use the value of `line` again (though you can assign a new value
   to the `line` variable if you want). */

//open and get the file handle
FILE* fh;
fopen_s(&fh, filename, "r");

//check if file exists
if (fh == NULL){
    printf("file does not exists %s", filename);
    return 0;
}


//read line by line
const size_t line_size = 300;
char* line = malloc(line_size);
while (fgets(line, line_size, fh) != NULL)  {
    printf(line);
}
free(line);    // dont forget to free heap memory

readLine() devuelve el puntero a la variable local, lo que provoca un comportamiento indefinido.

Para moverte puedes:

1. Crear variable en la función de llamante y pasar su dirección a readLine()
2. Asignar memoria para lineusar malloc(), en este casoline será persistente
3. Utilice la variable global, aunque generalmente es una mala práctica.

Se usa fgets()para leer una línea desde un identificador de archivo.

Algunas cosas están mal con el ejemplo:

• olvidó agregar \ n a sus printfs. También los mensajes de error deben ir a stderr, es decirfprintf(stderr, ....
• (No es un biggy pero) considere usar en fgetc()lugar de getc(). getc()es una macrofgetc() es una función adecuada
• getc()devuelve un intso chdebe declararse como un int. Esto es importante ya que la comparación con EOFse manejará correctamente. Algunos juegos de caracteres de 8 bits se usan 0xFFcomo caracteres válidos (ISO-LATIN-1 sería un ejemplo) y EOFque es -1, se 0xFFasignará a a char.

• Hay un potencial desbordamiento del búfer en la línea

  lineBuffer[count] = '\0';

  Si la línea tiene exactamente 128 caracteres, countes 128 en el punto que se ejecuta.

• Como otros han señalado, linees una matriz declarada localmente. No puede devolverle un puntero.

• strncpy(count + 1)copiará a la mayoría de los count + 1caracteres pero terminará si golpea'\0' Debido configura lineBuffer[count]a '\0'que sabe que nunca va a llegar a count + 1. Sin embargo, si lo hiciera, no pondría una terminación '\0', por lo que debe hacerlo. A menudo ves algo como lo siguiente:

  char buffer [BUFFER_SIZE];
  strncpy(buffer, sourceString, BUFFER_SIZE - 1);
  buffer[BUFFER_SIZE - 1] = '\0';

• si tiene malloc()una línea para devolver (en lugar de su charmatriz local ), su tipo de retorno debería ser char*: suelte elconst .

void readLine(FILE* file, char* line, int limit)
{
    int i;
    int read;

    read = fread(line, sizeof(char), limit, file);
    line[read] = '\0';

    for(i = 0; i <= read;i++)
    {
        if('\0' == line[i] || '\n' == line[i] || '\r' == line[i])
        {
            line[i] = '\0';
            break;
        }
    }

    if(i != read)
    {
        fseek(file, i - read + 1, SEEK_CUR);
    }
}

¿Qué hay de este?

Aquí están mis varias horas ... Leyendo todo el archivo línea por línea.

char * readline(FILE *fp, char *buffer)
{
    int ch;
    int i = 0;
    size_t buff_len = 0;

    buffer = malloc(buff_len + 1);
    if (!buffer) return NULL;  // Out of memory

    while ((ch = fgetc(fp)) != '\n' && ch != EOF)
    {
        buff_len++;
        void *tmp = realloc(buffer, buff_len + 1);
        if (tmp == NULL)
        {
            free(buffer);
            return NULL; // Out of memory
        }
        buffer = tmp;

        buffer[i] = (char) ch;
        i++;
    }
    buffer[i] = '\0';

    // Detect end
    if (ch == EOF && (i == 0 || ferror(fp)))
    {
        free(buffer);
        return NULL;
    }
    return buffer;
}

void lineByline(FILE * file){
char *s;
while ((s = readline(file, 0)) != NULL)
{
    puts(s);
    free(s);
    printf("\n");
}
}

int main()
{
    char *fileName = "input-1.txt";
    FILE* file = fopen(fileName, "r");
    lineByline(file);
    return 0;
}

const char *readLine(FILE *file, char* line) {

    if (file == NULL) {
        printf("Error: file pointer is null.");
        exit(1);
    }

    int maximumLineLength = 128;
    char *lineBuffer = (char *)malloc(sizeof(char) * maximumLineLength);

    if (lineBuffer == NULL) {
        printf("Error allocating memory for line buffer.");
        exit(1);
    }

    char ch = getc(file);
    int count = 0;

    while ((ch != '\n') && (ch != EOF)) {
        if (count == maximumLineLength) {
            maximumLineLength += 128;
            lineBuffer = realloc(lineBuffer, maximumLineLength);
            if (lineBuffer == NULL) {
                printf("Error reallocating space for line buffer.");
                exit(1);
            }
        }
        lineBuffer[count] = ch;
        count++;

        ch = getc(file);
    }

    lineBuffer[count] = '\0';
    char line[count + 1];
    strncpy(line, lineBuffer, (count + 1));
    free(lineBuffer);
    return line;

}


char linebuffer[256];
while (!feof(myFile)) {
    const char *line = readLine(myFile, linebuffer);
    printf("%s\n", line);
}

tenga en cuenta que la variable 'línea' se declara en la función de llamada y luego se pasa, por lo que su readLinefunción llena el búfer predefinido y simplemente lo devuelve. Esta es la forma en que funcionan la mayoría de las bibliotecas de C.

Hay otras formas, de las cuales soy consciente:

• definiendo el char line[]como estático (static char line[MAX_LINE_LENGTH] -> mantendrá su valor DESPUÉS de regresar de la función). -> mal, la función no es reentrante y puede producirse una condición de carrera -> si lo llama dos veces desde dos hilos, sobrescribirá sus resultados
• malloc()ing la línea char [], y liberándola en funciones de llamada -> demasiados correos caros malloc, y delegando la responsabilidad de liberar el buffer a otra función (la solución más elegante es llamar mallocy freeen cualquier buffer en la misma función)

por cierto, la conversión 'explícita' de char*a const char*es redundante.

por cierto, no hay necesidad de malloc()lineBuffer, solo defínalo, por char lineBuffer[128]lo que no es necesario liberarlo

por cierto, no use 'matrices de pila de tamaño dinámico' (definiendo la matriz como char arrayName[some_nonconstant_variable]), si no sabe exactamente qué está haciendo, solo funciona en C99.

Debe usar las funciones ANSI para leer una línea, por ejemplo. Fgets. Después de llamar, necesita free () en el contexto de la llamada, por ejemplo:

...
const char *entirecontent=readLine(myFile);
puts(entirecontent);
free(entirecontent);
...

const char *readLine(FILE *file)
{
  char *lineBuffer=calloc(1,1), line[128];

  if ( !file || !lineBuffer )
  {
    fprintf(stderr,"an ErrorNo 1: ...");
    exit(1);
  }

  for(; fgets(line,sizeof line,file) ; strcat(lineBuffer,line) )
  {
    if( strchr(line,'\n') ) *strchr(line,'\n')=0;
    lineBuffer=realloc(lineBuffer,strlen(lineBuffer)+strlen(line)+1);
    if( !lineBuffer )
    {
      fprintf(stderr,"an ErrorNo 2: ...");
      exit(2);
    }
  }
  return lineBuffer;
}

Implemente un método para leer y obtener contenido de un archivo (input1.txt)

#include <stdio.h>
#include <stdlib.h>

void testGetFile() {
    // open file
    FILE *fp = fopen("input1.txt", "r");
    size_t len = 255;
    // need malloc memory for line, if not, segmentation fault error will occurred.
    char *line = malloc(sizeof(char) * len);
    // check if file exist (and you can open it) or not
    if (fp == NULL) {
        printf("can open file input1.txt!");
        return;
    }
    while(fgets(line, len, fp) != NULL) {
        printf("%s\n", line);
    }
    free(line);
}

Espero que esto ayude. ¡Feliz codificación!

Comete el error de devolver un puntero a una variable automática. La línea variable se asigna en la pila y solo vive mientras viva la función. No está permitido devolverle un puntero, porque tan pronto como regrese, la memoria se dará en otro lugar.

const char* func x(){
    char line[100];
    return (const char*) line; //illegal
}

Para evitar esto, puede devolver un puntero a la memoria que reside en el montón, por ejemplo. lineBuffer y debería ser responsabilidad del usuario llamar a free () cuando haya terminado con él. Alternativamente, puede pedirle al usuario que le pase como argumento una dirección de memoria en la que escribir el contenido de la línea.

Quiero un código de la base 0, así que hice esto para leer el contenido de la palabra del diccionario línea por línea.

char temp_str [20]; // puede cambiar el tamaño del búfer de acuerdo con sus requisitos y la longitud de una sola línea en un archivo.

Tenga en cuenta que he inicializado el búfer con carácter nulo cada vez que leo la línea. Esta función se puede automatizar pero ya que necesito una prueba de concepto y quiero diseñar un programa Byte By Byte

#include<stdio.h>

int main()
{
int i;
char temp_ch;
FILE *fp=fopen("data.txt","r");
while(temp_ch!=EOF)
{
 i=0;
  char temp_str[20]={'\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0'};
while(temp_ch!='\n')
{
  temp_ch=fgetc(fp);
  temp_str[i]=temp_ch;
  i++;
}
if(temp_ch=='\n')
{
temp_ch=fgetc(fp);
temp_str[i]=temp_ch;
}
printf("%s",temp_str);
}
return 0;
}

Mi implemento desde cero:

FILE *pFile = fopen(your_file_path, "r");
int nbytes = 1024;
char *line = (char *) malloc(nbytes);
char *buf = (char *) malloc(nbytes);

size_t bytes_read;
int linesize = 0;
while (fgets(buf, nbytes, pFile) != NULL) {
    bytes_read = strlen(buf);
    // if line length larger than size of line buffer
    if (linesize + bytes_read > nbytes) {
        char *tmp = line;
        nbytes += nbytes / 2;
        line = (char *) malloc(nbytes);
        memcpy(line, tmp, linesize);
        free(tmp);
    }
    memcpy(line + linesize, buf, bytes_read);
    linesize += bytes_read;

    if (feof(pFile) || buf[bytes_read-1] == '\n') {
        handle_line(line);
        linesize = 0;
        memset(line, '\0', nbytes);
    }
}

free(buf);
free(line);

Proporcione una función portátil y genérica getdelim, prueba aprobada a través de msvc, clang, gcc.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

ssize_t
portabl_getdelim(char ** restrict linep,
                 size_t * restrict linecapp,
                 int delimiter,
                 FILE * restrict stream) {
    if (0 == *linep) {
        *linecapp = 8;
        *linep = malloc(*linecapp);
        if (0 == *linep) {
            return EOF;
        }
    }

    ssize_t linelen = 0;
    int c = 0;
    char *p = *linep;

    while (EOF != (c = fgetc(stream))) {
        if (linelen == (ssize_t) *linecapp - 1) {
            *linecapp <<= 1;
            char *p1 = realloc(*linep, *linecapp);
            if (0 == *p1) {
                return EOF;
            }
            p = p1 + linelen;
        }
        *p++ = c;
        linelen++;

        if (delimiter == c) {
            *p = 0;
            return linelen;
        }
    }
    return EOF == c ? EOF : linelen;
}


int
main(int argc, char **argv) {
    const char *filename = "/a/b/c.c";
    FILE *file = fopen(filename, "r");
    if (!file) {
        perror(filename);
        return 1;
    }

    char *line = 0;
    size_t linecap = 0;
    ssize_t linelen;

    while (0 < (linelen = portabl_getdelim(&line, &linecap, '\n', file))) {
        fwrite(line, linelen, 1, stdout);
    }
    if (line) {
        free(line);
    }
    fclose(file);   

    return 0;
}