How to Read an Entire Line From a File in C

Solarian Programmer

My programming ramblings

C Programming - read a file line past line with fgets and getline, implement a portable getline version

Posted on April three, 2019 by Paul

In this commodity, I volition show you how to read a text file line past line in C using the standard C function fgets and the POSIX getline function. At the end of the article, I will write a portable implementation of the getline role that can exist used with any standard C compiler.

Reading a file line past line is a trivial problem in many programming languages, but not in C. The standard mode of reading a line of text in C is to utilize the fgets function, which is fine if you know in advance how long a line of text could be.

You lot can find all the code examples and the input file at the GitHub repo for this article.

Let's starting time with a simple example of using fgets to read chunks from a text file. :

                                                                        1                                    #include                  <stdio.h>                                                        2                                    #include                  <stdlib.h>                                                        3                                                        4                                    int                  main                  (                  void                  )                  {                                      5                                    FILE                  *                  fp                  =                  fopen                  (                  "lorem.txt"                  ,                  "r"                  );                                      six                                    if                  (                  fp                  ==                  Nil                  )                  {                                      7                                    perror                  (                  "Unable to open file!"                  );                                      8                                    exit                  (                  one                  );                                      ix                                    }                  10                                    11                                    char                  clamper                  [                  128                  ];                  12                                    13                                    while                  (                  fgets                  (                  chunk                  ,                  sizeof                  (                  chunk                  ),                  fp                  )                  !=                  Cipher                  )                  {                  14                                    fputs                  (                  chunk                  ,                  stdout                  );                  15                                    fputs                  (                  "|*                  \n                  "                  ,                  stdout                  );                  // marker cord used to prove where the content of the chunk array has ended                  16                                    }                  17                                    18                                    fclose                  (                  fp                  );                  19                                    }                              

For testing the code I've used a simple dummy file, lorem.txt. This is a piece from the output of the higher up plan on my automobile:

                                                                        ane                                    ~ $ clang -std=c17 -Wall -Wextra -pedantic t0.c -o t0                                      two                                    ~ $ ./t0                                      3                                    Lorem ipsum dolor sit amet, consectetur adipiscing elit.                                      4                                    |*                                      5                                    Fusce dignissim facilisis ligula consectetur hendrerit. Vestibulum porttitor aliquam luctus. Nam pharetra lorem vel ornare cond|*                                      half-dozen                                    imentum.                                      7                                    |*                                      8                                    Praesent et nunc at libero vulputate convallis. Cras egestas nunc vitae eros vehicula hendrerit. Pellentesque in est et sapien |*                                      9                                    dignissim molestie.                  10                                    |*                              

The code prints the content of the chunk array, equally filled subsequently every call to fgets, and a mark cord.

If you picket carefully, by scrolling the above text snippet to the correct, you lot tin can run into that the output was truncated to 127 characters per line of text. This was expected considering our code can store an entire line from the original text file only if the line tin can fit inside our clamper assortment.

What if you need to have the entire line of text available for further processing and not a piece of line ? A possible solution is to copy or concatenate chunks of text in a split line buffer until we find the end of line grapheme.

Permit'south beginning by creating a line buffer that volition store the chunks of text, initially this volition have the same length equally the clamper array:

                                                                        1                                    #include                  <stdio.h>                                                        2                                    #include                  <stdlib.h>                                                        3                                    #include                  <string.h>                                                        iv                                                        v                                    int                  principal                  (                  void                  )                  {                                      vi                                    FILE                  *                  fp                  =                  fopen                  (                  "lorem.txt"                  ,                  "r"                  );                                      7                                    // ...                                      8                                                        nine                                    char                  clamper                  [                  128                  ];                  10                                    11                                    // Shop the chunks of text into a line buffer                  12                                    size_t                  len                  =                  sizeof                  (                  chunk                  );                  13                                    char                  *                  line                  =                  malloc                  (                  len                  );                  14                                    if                  (                  line                  ==                  Zip                  )                  {                  fifteen                                    perror                  (                  "Unable to classify memory for the line buffer."                  );                  xvi                                    leave                  (                  1                  );                  17                                    }                  xviii                                    19                                    // "Empty" the string                  twenty                                    line                  [                  0                  ]                  =                  '\0'                  ;                  21                                    22                                    // ...                  23                                    24                                    }                              

Next, nosotros are going to suspend the content of the chunk array to the end of the line string, until we observe the terminate of line character. If necessary, we'll resize the line buffer:

                                                                        1                                    #include                  <stdio.h>                                                        2                                    #include                  <stdlib.h>                                                        3                                    #include                  <string.h>                                                        4                                                        5                                    int                  main                  (                  void                  )                  {                                      6                                    // ...                                      7                                                        eight                                    // "Empty" the string                                      9                                    line                  [                  0                  ]                  =                  '\0'                  ;                  10                                    11                                    while                  (                  fgets                  (                  clamper                  ,                  sizeof                  (                  clamper                  ),                  fp                  )                  !=                  Naught                  )                  {                  12                                    // Resize the line buffer if necessary                  13                                    size_t                  len_used                  =                  strlen                  (                  line                  );                  14                                    size_t                  chunk_used                  =                  strlen                  (                  clamper                  );                  fifteen                                    16                                    if                  (                  len                  -                  len_used                  <                  chunk_used                  )                  {                  17                                    len                  *=                  2                  ;                  18                                    if                  ((                  line                  =                  realloc                  (                  line                  ,                  len                  ))                  ==                  NULL                  )                  {                  19                                    perror                  (                  "Unable to reallocate retentivity for the line buffer."                  );                  xx                                    free                  (                  line                  );                  21                                    leave                  (                  ane                  );                  22                                    }                  23                                    }                  24                                    25                                    // Copy the chunk to the end of the line buffer                  26                                    strncpy                  (                  line                  +                  len_used                  ,                  clamper                  ,                  len                  -                  len_used                  );                  27                                    len_used                  +=                  chunk_used                  ;                  28                                    29                                    // Check if line contains '\n', if yes procedure the line of text                  xxx                                    if                  (                  line                  [                  len_used                  -                  1                  ]                  ==                  '\n'                  )                  {                  31                                    fputs                  (                  line                  ,                  stdout                  );                  32                                    fputs                  (                  "|*                  \n                  "                  ,                  stdout                  );                  33                                    // "Empty" the line buffer                  34                                    line                  [                  0                  ]                  =                  '\0'                  ;                  35                                    }                  36                                    }                  37                                    38                                    fclose                  (                  fp                  );                  39                                    gratis                  (                  line                  );                  forty                                    41                                    printf                  (                  "                  \north\n                  Max line size: %zd                  \n                  "                  ,                  len                  );                  42                                    }                              

Please annotation, that in the in a higher place code, every fourth dimension the line buffer needs to be resized its chapters is doubled.

This is the result of running the in a higher place code on my auto. For brevity, I kept only the beginning lines of output:

                                                                        1                                    ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1                                      two                                    ~ $ ./t1                                      iii                                    Lorem ipsum dolor sit amet, consectetur adipiscing elit.                                      iv                                    |*                                      5                                    Fusce dignissim facilisis ligula consectetur hendrerit. Vestibulum porttitor aliquam luctus. Nam pharetra lorem vel ornare condimentum.                                      half dozen                                    |*                                      7                                    Praesent et nunc at libero vulputate convallis. Cras egestas nunc vitae eros vehicula hendrerit. Pellentesque in est et sapien dignissim molestie.                                      viii                                    |*                                      9                                    Aliquam erat volutpat. Mauris dignissim augue air conditioning purus placerat scelerisque. Donec eleifend ut nibh eu elementum.                  10                                    |*                              

Y'all can see that, this time, we tin can print full lines of text and not stock-still length chunks like in the initial arroyo.

Let's modify the to a higher place code in order to impress the line length instead of the bodily text:

                                                                        ane                                    // ...                                      2                                                        three                                    int                  primary                  (                  void                  )                  {                                      4                                    // ...                                      5                                                        half dozen                                    while                  (                  fgets                  (                  chunk                  ,                  sizeof                  (                  clamper                  ),                  fp                  )                  !=                  NULL                  )                  {                                      7                                                        viii                                    // ...                                      9                                    10                                    // Check if line contains '\northward', if yes process the line of text                  eleven                                    if                  (                  line                  [                  len_used                  -                  1                  ]                  ==                  '\north'                  )                  {                  12                                    printf                  (                  "line length: %zd                  \n                  "                  ,                  len_used                  );                  xiii                                    // "Empty" the line buffer                  14                                    line                  [                  0                  ]                  =                  '\0'                  ;                  15                                    }                  16                                    }                  17                                    18                                    fclose                  (                  fp                  );                  19                                    free                  (                  line                  );                  twenty                                    21                                    printf                  (                  "                  \due north\due north                  Max line size: %zd                  \n                  "                  ,                  len                  );                  22                                    }                              

This is the issue of running the modified code on my car:

                                                                        1                                    ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1                                      two                                    ~ $ ./t1                                      iii                                    line length: 57                                      four                                    line length: 136                                      5                                    line length: 147                                      half dozen                                    line length: 114                                      7                                    line length: 112                                      8                                    line length: 95                                      9                                    line length: 62                  10                                    line length: 1                  eleven                                    line length: 428                  12                                    line length: 1                  xiii                                    line length: 460                  14                                    line length: 1                  15                                    line length: 834                  xvi                                    line length: ane                  17                                    line length: 821                  eighteen                                    nineteen                                    20                                    Max line size: 1024                              

In the adjacent example, I will show y'all how to use the getline office available on POSIX systems like Linux, Unix and macOS. Microsoft Visual Studio doesn't have an equivalent role, so you won't exist able to easily test this example on a Windows system. Nevertheless, you should exist able to test information technology if you are using Cygwin or Windows Subsystem for Linux.

                                                                        ane                                    #include                  <stdio.h>                                                        2                                    #include                  <stdlib.h>                                                        3                                    #include                  <string.h>                                                        four                                                        five                                    int                  main                  (                  void                  )                  {                                      vi                                    FILE                  *                  fp                  =                  fopen                  (                  "lorem.txt"                  ,                  "r"                  );                                      7                                    if                  (                  fp                  ==                  Aught                  )                  {                                      8                                    perror                  (                  "Unable to open file!"                  );                                      9                                    exit                  (                  ane                  );                  10                                    }                  11                                    12                                    // Read lines using POSIX function getline                  13                                    // This code won't work on Windows                  14                                    char                  *                  line                  =                  Naught                  ;                  15                                    size_t                  len                  =                  0                  ;                  16                                    17                                    while                  (                  getline                  (                  &                  line                  ,                  &                  len                  ,                  fp                  )                  !=                  -                  1                  )                  {                  18                                    printf                  (                  "line length: %zd                  \north                  "                  ,                  strlen                  (                  line                  ));                  19                                    }                  20                                    21                                    printf                  (                  "                  \north\north                  Max line size: %zd                  \n                  "                  ,                  len                  );                  22                                    23                                    fclose                  (                  fp                  );                  24                                    free                  (                  line                  );                  // getline will resize the input buffer as necessary                  25                                    // the user needs to free the retentivity when not needed!                  26                                    }                              

Please notation, how uncomplicated is to use POSIX'southward getline versus manually buffering chunks of line like in my previous instance. Information technology is unfortunate that the standard C library doesn't include an equivalent function.

When you apply getline, don't forget to costless the line buffer when you don't need it anymore. Also, calling getline more than than one time will overwrite the line buffer, brand a copy of the line content if you lot need to proceed it for farther processing.

This is the event of running the higher up getline example on a Linux automobile:

                                                                        i                                    ~ $ clang -std=gnu17 -Wall -Wextra -pedantic t2.c -o t2                                      two                                    ~ $ ./t2                                      3                                    line length: 57                                      4                                    line length: 136                                      5                                    line length: 147                                      6                                    line length: 114                                      7                                    line length: 112                                      eight                                    line length: 95                                      9                                    line length: 62                  x                                    line length: 1                  11                                    line length: 428                  12                                    line length: 1                  13                                    line length: 460                  14                                    line length: 1                  xv                                    line length: 834                  16                                    line length: i                  17                                    line length: 821                  eighteen                                    xix                                    20                                    Max line size: 960                              

Information technology is interesting to note, that for this particular case the getline role on Linux resizes the line buffer to a max of 960 bytes. If yous run the same code on macOS the line buffer is resized to 1024 bytes. This is due to the unlike ways in which getline is implemented on different Unix like systems.

As mentioned before, getline is not present in the C standard library. It could be an interesting exercise to implement a portable version of this role. The thought hither is not to implement the well-nigh performant version of getline, merely rather to implement a simple replacement for non POSIX systems.

We are going to take the above example and supersede the POSIX'due south getline version with our own implementation, say my_getline. Obviously, if you are on a POSIX system, you should use the version provided by the operating system, which was tested by countless users and tuned for optimal performance.

The POSIX getline function has this signature:

                                                    1                                    ssize_t                  getline                  (                  char                  **                  restrict                  lineptr                  ,                  size_t                  *                  restrict                  due north                  ,                  FILE                  *                  restrict                  stream                  );                              

Since ssize_t is also a POSIX defined type, usually a 64 bits signed integer, this is how we are going to declare our version:

                                                    ane                                    int64_t                  my_getline                  (                  char                  **                  restrict                  line                  ,                  size_t                  *                  restrict                  len                  ,                  FILE                  *                  restrict                  fp                  );                              

In principle nosotros are going to implement the function using the aforementioned approach as in one of the higher up examples, where I've defined a line buffer and kept copying chunks of text in the buffer until we plant the end of line character:

                                                                        i                                    // This will only have effect on Windows with MSVC                                      ii                                    #ifdef _MSC_VER                                      three                                    #define _CRT_SECURE_NO_WARNINGS 1                                      four                                    #define restrict __restrict                                      v                                    

Share this post