C ler arquivo linha por linha

Eu escrevi esta função para ler uma linha de um arquivo:

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;
}

A função lê o arquivo corretamente e, usando printf, vejo que a string constLine também foi lida corretamente.

No entanto, se eu usar a função, por exemplo:

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

printf produz sem sentido. Por quê?

Se sua tarefa não é inventar a função de leitura linha a linha, mas apenas para ler o arquivo linha por linha, você pode usar um trecho de código típico envolvendo a getline()função (consulte a página do manual aqui ):

#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);

Em sua readLinefunção, você retorna um ponteiro para a linematriz (Estritamente falando, um ponteiro para seu primeiro caractere, mas a diferença é irrelevante aqui). Como é uma variável automática (ou seja, está “na pilha”), a memória é recuperada quando a função retorna. Você vê bobagens porque printfcolocou suas próprias coisas na pilha.

Você precisa retornar um buffer alocado dinamicamente da função Você já tem um, é lineBuffer; tudo o que você precisa fazer é truncá-lo no comprimento desejado.

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

ADICIONADO (resposta à pergunta de acompanhamento no comentário): readLineretorna um ponteiro para os caracteres que compõem a linha. Esse ponteiro é o que você precisa para trabalhar com o conteúdo da linha. É também para isso que você deve passar freequando terminar de usar a memória usada por esses caracteres. Veja como você pode usar a readLinefunção:

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() retorna o ponteiro para a variável local, o que causa um comportamento indefinido.

Para se locomover, você pode:

1. Crie uma variável na função de chamada e passe seu endereço para readLine()
2. Alocar memória para lineuso malloc()- neste caso line, será persistente
3. Use variável global, embora geralmente seja uma má prática

Use fgets()para ler uma linha de um identificador de arquivo.

Algumas coisas estão erradas com o exemplo:

• você esqueceu de adicionar \ n aos seus printfs. As mensagens de erro também devem ir para stderrfprintf(stderr, ....
• (não é nada demais) considere usar fgetc()e não getc(). getc()é uma macro, fgetc()é uma função adequada
• getc()retorna um intso chdeve ser declarado como um int. Isso é importante, pois a comparação com EOFserá tratada corretamente. Alguns conjuntos de caracteres de 8 bits usam 0xFFcomo um caractere válido (ISO-LATIN-1 seria um exemplo) e EOFque é -1, será 0xFFse atribuído a a char.

• Existe um potencial estouro de buffer na linha

  lineBuffer[count] = '\0';

  Se a linha tiver exatamente 128 caracteres, countserá 128 no ponto que é executado.

• Como outros já apontaram, lineé uma matriz declarada localmente. Você não pode retornar um ponteiro para ele.

• strncpy(count + 1)irá copiar a maioria dos count + 1personagens, mas terminará se bate '\0' Porque você definir lineBuffer[count]para '\0'que você sabe que nunca vai conseguir count + 1. No entanto, se o fizesse, não colocaria uma terminação '\0', então você precisa fazê-lo. Você costuma ver algo como o seguinte:

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

• se você tem malloc()uma linha para retornar (no lugar de sua charmatriz local ), seu tipo de retorno deve ser char*- solte o const.

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);
    }
}

que tal este?

Aqui estão minhas várias horas ... Lendo todo o arquivo linha por linha.

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);
}

note que a variável 'line' é declarada na função de chamada e depois passada, então sua readLinefunção preenche o buffer predefinido e apenas o retorna. É assim que a maioria das bibliotecas C funciona.

Existem outras maneiras pelas quais estou ciente:

• definindo char line[]como estático ( static char line[MAX_LINE_LENGTH] -> manterá seu valor APÓS retornar da função). -> ruim, a função não é reentrada, e a condição de corrida pode ocorrer -> se você chamá-lo duas vezes a partir de dois threads, substituirá seus resultados
• malloc()adicionando a linha char [] e liberando-a nas funções de chamada -> muitos mallocs caros , e delegando a responsabilidade de liberar o buffer para outra função (a solução mais elegante é chamar malloce freeem qualquer buffer na mesma função)

btw, a conversão "explícita" de char*para const char*é redundante.

btw2, não há necessidade malloc()do lineBuffer, apenas defina-o char lineBuffer[128], para que você não precise liberá -lo

btw3 não usa 'matrizes de pilha de tamanho dinâmico' (definindo a matriz como char arrayName[some_nonconstant_variable]), se você não sabe exatamente o que está fazendo, ele funciona apenas no C99.

Você deve usar as funções ANSI para ler uma linha, por exemplo. objetos. Depois de ligar, você precisa de free () no contexto de chamada, por exemplo:

...
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;
}

Implementar método para ler e obter conteúdo de um arquivo (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 esta ajuda. Feliz codificação!

Você comete o erro de retornar um ponteiro para uma variável automática. A linha variável é alocada na pilha e dura apenas enquanto a função durar. Você não tem permissão para retornar um ponteiro para ele, porque assim que ele retornar, a memória será entregue em outro lugar.

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

Para evitar isso, você retorna um ponteiro para a memória que reside na pilha, por exemplo. lineBuffer e deve ser responsabilidade do usuário ligar para free () quando ele terminar. Como alternativa, você pode pedir ao usuário para passar como argumento um endereço de memória no qual escrever o conteúdo da linha.

Eu quero um código do chão 0, então eu fiz isso para ler o conteúdo da palavra do dicionário linha por linha.

char temp_str [20]; // você pode alterar o tamanho do buffer de acordo com seus requisitos E o comprimento de uma única linha em um arquivo.

Nota : Inicializei o buffer Com o caractere Nulo toda vez que leio a linha.

#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;
}

Meu implemento do zero:

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);

Forneça uma getdelimfunção portátil e genérica , teste passado via 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;
}