C อ่านไฟล์ทีละบรรทัด

ฉันเขียนฟังก์ชันนี้เพื่ออ่านบรรทัดจากไฟล์:

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 เอาท์พุทซึ่งพูดพล่อยๆ ทำไม?

หากงานของคุณไม่ได้คิดค้นฟังก์ชั่นการอ่านทีละบรรทัด แต่เพียงเพื่ออ่านไฟล์ทีละบรรทัดคุณอาจใช้ข้อมูลโค้ดทั่วไปที่เกี่ยวข้องกับ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);
}

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

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

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

fclose(filePointer);

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

//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() ส่งคืนตัวชี้ไปยังตัวแปรโลคัลซึ่งทำให้เกิดลักษณะการทำงานที่ไม่ได้กำหนด

หากต้องการรับรอบคุณสามารถ:

1. สร้างตัวแปรในฟังก์ชั่นผู้โทรและส่งผ่านที่อยู่ของมัน readLine()
2. จัดสรรหน่วยความจำสำหรับlineใช้malloc()- ในกรณีนี้lineจะคงอยู่
3. ใช้ตัวแปรโกลบอลแม้ว่าโดยทั่วไปจะเป็นแนวปฏิบัติที่ไม่ดี

ใช้fgets()เพื่ออ่านบรรทัดจากตัวจัดการไฟล์

มีบางอย่างผิดปกติกับตัวอย่าง:

• คุณลืมที่จะเพิ่ม \ n ไปยัง printfs ของคุณ นอกจากนี้ข้อความผิดพลาดควรไปที่ stderr เช่นfprintf(stderr, ....
• (ไม่ Biggy แต่) พิจารณาใช้มากกว่า fgetc() เป็นแมโครเป็นฟังก์ชั่นที่เหมาะสมgetc()getc()fgetc()
• getc()ส่งกลับintดังนั้นควรจะประกาศเป็นch intสิ่งนี้มีความสำคัญเนื่องจากการเปรียบเทียบกับEOFจะได้รับการจัดการอย่างถูกต้อง บางชุดตัวอักษร 8 บิตใช้0xFFเป็นตัวละครที่ถูกต้อง (ISO-Latin-1 จะเป็นตัวอย่าง) และEOFซึ่งเป็น -1 จะได้รับหากได้รับมอบหมายให้0xFFchar

• มีบัฟเฟอร์ล้นที่อาจเกิดขึ้นที่บรรทัด

  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วาง

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

แล้วอันนี้หล่ะ?

นี่เป็นเวลาหลายชั่วโมงของฉัน ... อ่านไฟล์ทั้งหมดทีละบรรทัด

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

โปรดทราบว่ามีการประกาศตัวแปร 'line' ในฟังก์ชั่นการโทรแล้วส่งผ่านดังนั้นreadLineฟังก์ชั่นของคุณเติมบัฟเฟอร์ที่กำหนดไว้ล่วงหน้าและเพียงแค่ส่งกลับ นี่เป็นวิธีที่ไลบรารี C ส่วนใหญ่ทำงาน

มีวิธีอื่น ๆ ซึ่งฉันรู้:

• กำหนดchar line[]เป็นแบบคงที่ (static char line[MAX_LINE_LENGTH] -> มันจะถือเป็นมูลค่าหลังจากกลับมาจากฟังก์ชั่น) -> ไม่ดีฟังก์ชั่นไม่ได้เป็น reentrant และสภาพการแข่งขันสามารถเกิดขึ้นได้ -> ถ้าคุณเรียกมันสองครั้งจากสองเธรดมันจะเขียนทับผลลัพธ์ของมัน
• malloc()ไอเอ็นจี char char [] และปลดปล่อยมันในฟังก์ชั่นการโทร -> mallocs แพงเกินไปและมอบหมายความรับผิดชอบในการเพิ่มบัฟเฟอร์ให้กับฟังก์ชั่นอื่น (ทางออกที่ดีที่สุดคือการโทรmallocและfreeบัฟเฟอร์ใด ๆ ในฟังก์ชั่นเดียวกัน)

BTW หล่อ 'อย่างชัดเจนจากchar*การconst char*ซ้ำซ้อน

btw2 ไม่จำเป็นต้องmalloc()มี lineBuffer เพียงแค่กำหนดมันchar lineBuffer[128]ดังนั้นคุณไม่จำเป็นต้องเพิ่มมัน

btw3 ไม่ได้ใช้ 'ไดนามิกขนาดกองอาร์เรย์' (กำหนดอาร์เรย์เป็นchar arrayName[some_nonconstant_variable]) ถ้าคุณไม่ทราบว่าสิ่งที่คุณกำลังทำมันทำงานได้เฉพาะใน C99

คุณควรใช้ฟังก์ชัน ANSI เพื่ออ่านบรรทัดเช่น fgets หลังจากโทรคุณจะต้องว่าง () ในบริบทการโทรเช่น:

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

ใช้วิธีการอ่านและรับเนื้อหาจากไฟล์ (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);
}

หวังว่าความช่วยเหลือนี้ การเข้ารหัสที่มีความสุข!

คุณทำผิดพลาดในการคืนค่าตัวชี้ไปยังตัวแปรอัตโนมัติ บรรทัดตัวแปรถูกจัดสรรในสแต็กและใช้งานได้ตราบเท่าที่ฟังก์ชันยังมีชีวิตอยู่ คุณไม่ได้รับอนุญาตให้ส่งคืนตัวชี้เนื่องจากมันจะส่งคืนหน่วยความจำทันที

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

เพื่อหลีกเลี่ยงปัญหานี้คุณอาจส่งคืนตัวชี้ไปยังหน่วยความจำที่อยู่บนฮีปเช่น lineBuffer และควรเป็นความรับผิดชอบของผู้ใช้ในการโทรฟรี () เมื่อเขาทำเสร็จแล้ว หรือคุณสามารถขอให้ผู้ใช้ส่งคุณเป็นอาร์กิวเมนต์ที่อยู่หน่วยความจำที่จะเขียนเนื้อหารายการที่

ฉันต้องการรหัสจากพื้นดิน 0 ดังนั้นฉันจึงทำสิ่งนี้เพื่ออ่านเนื้อหาของคำศัพท์ต่อบรรทัด

ถ่าน temp_str [20]; // คุณสามารถเปลี่ยนขนาดบัฟเฟอร์ตามความต้องการของคุณและความยาวบรรทัดเดียวในไฟล์

หมายเหตุฉันเริ่มต้นบัฟเฟอร์ด้วยอักขระ Null ทุกครั้งที่ฉันอ่านบรรทัดฟังก์ชั่นนี้สามารถอัตโนมัติ แต่เนื่องจากฉันต้องการหลักฐานการแนวคิดและต้องการออกแบบโปรแกรม 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;
}

การใช้งานของฉันตั้งแต่เริ่มต้น:

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