C читать файл построчно

Если ваша задача - не изобрести функцию построчного чтения, а просто построчно прочитать файл, вы можете использовать типичный фрагмент кода, включающий функцию getline() (см. Страницу руководства здесь):

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

В своей функции readLine вы возвращаете указатель на массив line (строго говоря, указатель на его первый символ, но здесь разница не имеет значения). Поскольку это автоматическая переменная (т.е. она находится «в стеке»), память освобождается при возврате функции. Вы видите тарабарщину, потому что printf положил в стек свой собственный материал.

Вам необходимо вернуть из функции динамически выделенный буфер. Он у вас уже есть, это lineBuffer; все, что вам нужно сделать, это обрезать его до желаемой длины.

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

ДОБАВЛЕНО (ответ на последующий вопрос в комментарии): readLine возвращает указатель на символы, составляющие строку. Этот указатель - то, что вам нужно для работы с содержимым строки. Это также то, что вы должны передать free, когда закончите использовать память, занятую этими символами. Вот как можно использовать функцию readLine:

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). */

readLine() возвращает указатель на локальную переменную, что вызывает неопределенное поведение.

Чтобы передвигаться, вы можете:

1. Создайте переменную в вызывающей функции и передайте ее адрес readLine()
2. Выделите память для line с помощью malloc() - в этом случае line будет постоянным
3. Используйте глобальную переменную, хотя, как правило, это плохая практика.

Используйте fgets(), чтобы прочитать строку из дескриптора файла.

Полное решение fgets():

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

#define MAX_LEN 256

int main(void)
{
    FILE* fp;
    fp = fopen("file.txt", "r");
    if (fp == NULL) {
      perror("Failed: ");
      return 1;
    }

    char buffer[MAX_LEN];
    // -1 to allow room for NULL terminator for really long string
    while (fgets(buffer, MAX_LEN - 1, fp))
    {
        // Remove trailing newline
        buffer[strcspn(buffer, "\n")] = 0;
        printf("%s\n", buffer);
    }

    fclose(fp);
    return 0;
}

Вывод:

First line of file
Second line of file
Third (and also last) line of file

Помните, что если вы хотите читать из стандартного ввода (а не из файла, как в этом случае), все, что вам нужно сделать, это передать stdin в качестве третьего параметра метода fgets(), например:

while(fgets(buffer, MAX_LEN - 1, stdin))

_{Приложение}

Удаление завершающего символа новой строки из ввода fgets ()

как определить, открыт файл или нет в c

Некоторые ошибки в примере:

• вы забыли добавить \ n в свой printfs. Также сообщения об ошибках должны отправляться в stderr, т.е. fprintf(stderr, ....
• (не очень важно, но) подумайте об использовании fgetc(), а не getc(). getc() - макрос, fgetc() - правильная функция
• getc() возвращает int, поэтому ch следует объявить как int. Это важно, поскольку сравнение с EOF будет выполнено правильно. Некоторые 8-битные наборы символов используют 0xFF в качестве допустимого символа (примером может служить ISO-LATIN-1), а EOF, который равен -1, будет 0xFF, если он назначен char.

• Возможное переполнение буфера в строке

  lineBuffer[count] = '\0';
  

  Если длина строки ровно 128 символов, count будет 128 в момент выполнения.

• Как указывали другие, line - это локально объявленный массив. Вы не можете вернуть на него указатель.

• strncpy(count + 1) скопирует не более count + 1 символов, но завершится, если попадет в '\0'. Поскольку вы установили lineBuffer[count] на '\0', вы знаете, что он никогда не дойдет до count + 1. Однако, если бы это было так, это не привело бы к включению завершающего '\0', поэтому вам нужно это сделать. Часто можно увидеть что-то вроде следующего:

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

• если вы malloc() строку, которую нужно вернуть (вместо вашего локального char массива), ваш тип возврата должен быть char* - отбросьте const.

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

обратите внимание, что переменная line объявляется в вызывающей функции и затем передается, поэтому ваша функция readLine заполняет предопределенный буфер и просто возвращает его. Так работает большинство библиотек C.

Есть и другие способы, о которых я знаю:

• определение char line[] как статического (static char line[MAX_LINE_LENGTH] -> он будет удерживать свое значение ПОСЛЕ возврата из функции). -> плохо, функция не является реентерабельной, и может возникнуть состояние гонки -> если вы вызовете ее дважды из двух потоков, она перезапишет ее результаты
• malloc() освобождение строки char [] и ее освобождение при вызове функций -> слишком много дорогостоящих malloc и делегирование ответственности за освобождение буфера другой функции (наиболее элегантным решением является вызов malloc и free для любых буферов в той же функции)

кстати, «явное» приведение от char* к const char* является избыточным.

btw2, нет необходимости malloc() lineBuffer, просто определите его char lineBuffer[128], поэтому вам не нужно его освобождать

btw3 не использует «массивы стека динамического размера» (определяя массив как char arrayName[some_nonconstant_variable]), если вы точно не знаете, что делаете, это работает только в C99.

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

что насчет этого?

Реализовать метод для чтения и получения содержимого из файла (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);
}

Надеюсь на эту помощь. Удачного кодирования!

Вот мои несколько часов ... Чтение всего файла построчно.

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

Вы должны использовать функции ANSI для чтения строки, например. fgets. После вызова вам понадобится free () в контексте вызова, например:

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

Моя реализация с нуля:

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

Предоставьте переносимую универсальную функцию getdelim, тест пройден через 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;
}

Вы делаете ошибку, возвращая указатель на автоматическую переменную. Строка переменной размещается в стеке и живет только до тех пор, пока живет функция. Вам не разрешено возвращать указатель на него, потому что, как только он вернется, память будет передана в другое место.

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

Чтобы избежать этого, вы либо возвращаете указатель на память, которая находится в куче, например. lineBuffer, и пользователь должен будет вызвать free (), когда он закончит с ним. В качестве альтернативы вы можете попросить пользователя передать вам в качестве аргумента адрес памяти, в который будет записано содержимое строки.

Мне нужен код с нуля, поэтому я сделал это, чтобы прочитать содержимое словаря построчно.

char temp_str [20]; // вы можете изменить размер буфера в соответствии с вашими требованиями. И длина одной строки в файле.

Примечание. Я инициализирую буфер с нулевым символом каждый раз, когда читаю строку. Эту функцию можно автоматизировать, но поскольку мне нужно подтверждение концепции и я хочу разработать программу Байт за байтом

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