c - C逐行读取文件

Question

我编写了这个函数来从文件中读取一行：

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

该函数正确读取文件，并且使用 printf 我看到 constLine 字符串也被正确读取。

但是，如果我使用该功能，例如：

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

printf 输出乱码。为什么？

score 365 · Accepted Answer

如果您的任务不是发明逐行读取功能，而只是逐行读取文件，则可以使用涉及该功能的典型代码片段（请参阅此处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);
}

score 64 · Accepted Answer

FILE* filePointer;
int bufferLength = 255;
char buffer[bufferLength]; /* not ISO 90 compatible */

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

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

fclose(filePointer);

score 23 · Accepted Answer

在你的readLine函数中，你返回一个指向line数组的指针（严格来说，一个指向它的第一个字符的指针，但这里的区别是无关紧要的）。因为它是一个自动变量（即，它“在堆栈上”），所以当函数返回时，内存会被回收。你看到胡言乱语是因为printf已经把自己的东西放在了堆栈上。

您需要从函数返回一个动态分配的缓冲区。你已经有一个了，它是lineBuffer；您所要做的就是将其截断为所需的长度。

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

ADDED（回应评论中的后续问题）：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). */

score 17 · Accepted Answer

//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

score 11 · Accepted Answer

readLine()返回指向局部变量的指针，这会导致未定义的行为。

要四处走动，您可以：

在调用函数中创建变量并将其地址传递给readLine()
分配内存以供line使用malloc()- 在这种情况下line将是持久的
使用全局变量，尽管这通常是一种不好的做法

score 11 · Accepted Answer

一个完整的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];
    while (fgets(buffer, MAX_LEN, 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, stdin))

_附录

从 fgets() 输入中删除尾随换行符

如何在c中检测文件是否打开

score 9 · Accepted Answer

9

用于fgets()从文件句柄中读取一行。

于 2016-05-11T02:32:37.763 回答

score 4 · Accepted Answer

这个例子有一些问题：

您忘记将 \n 添加到您的 printfs 中。错误消息也应该发送到stderr，即fprintf(stderr, ....
（不是很大，但是）考虑使用fgetc()而不是getc(). getc()是一个宏，fgetc()是一个适当的功能
getc()返回一个intsoch应该被声明为一个int. 这很重要，因为与的比较EOF将被正确处理。一些 8 位字符集0xFF用作有效字符（例如 ISO-LATIN-1）EOF，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.

score 3 · Accepted Answer

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 line[]，并在调用函数时释放它 -> 太多昂贵malloc的 s，并将释放缓冲区的责任委托给另一个函数（最优雅的解决方案是在同一函数中调用任何缓冲区malloc）free

顺便说一句，从char*to的“显式”转换const char*是多余的。

btw2，不需要malloc()lineBuffer，只需定义它char lineBuffer[128]，所以你不需要释放它

btw3 不要使用“动态大小的堆栈数组”（将数组定义为char arrayName[some_nonconstant_variable]），如果您不完全知道自己在做什么，它仅适用于 C99。

score 3 · Accepted Answer

这是我的几个小时......逐行读取整个文件。

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

score 2 · Accepted Answer

实现从文件中读取和获取内容的方法 (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);
}

希望这有帮助。快乐编码！

score 2 · Accepted Answer

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

这个如何？

score 1 · Accepted Answer

您应该使用 ANSI 函数来读取一行，例如。得到。调用后，您需要在调用上下文中使用 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;
}

score 1 · Accepted Answer

提供可移植和通用的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;
}

score 1 · Accepted Answer

我从头开始的工具：

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

score 0 · Accepted Answer

我想要一个来自ground 0的代码，所以我这样做是为了逐行读取字典中的单词内容。

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

score 0 · Accepted Answer

您犯了返回指向自动变量的指针的错误。变量 line 分配在堆栈中，并且仅在函数存在时才存在。不允许返回指向它的指针，因为一旦它返回，内存就会在别处提供。

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

为避免这种情况，您可以返回一个指向位于堆上的内存的指针，例如。lineBuffer 并且应该是用户在完成后调用 free() 的责任。或者，您可以要求用户将一个内存地址作为参数传递给您，在该地址上写入行内容。

c - C逐行读取文件

17 回答 17

Related

Reference