Fgets Read One Line at a Time

Solarian Programmer

My programming ramblings

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

Posted on April 3, 2019 by Paul

In this article, I will show you how to read a text file line by line in C using the standard C office fgets and the POSIX getline office. At the end of the article, I will write a portable implementation of the getline function that can be 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 way of reading a line of text in C is to utilise the fgets function, which is fine if you lot know in accelerate how long a line of text could exist.

You tin observe all the lawmaking examples and the input file at the GitHub repo for this article.

Permit'south start with a uncomplicated 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"                  );                                      vi                                    if                  (                  fp                  ==                  NULL                  )                  {                                      seven                                    perror                  (                  "Unable to open file!"                  );                                      8                                    go out                  (                  one                  );                                      9                                    }                  x                                    xi                                    char                  chunk                  [                  128                  ];                  12                                    13                                    while                  (                  fgets                  (                  chunk                  ,                  sizeof                  (                  chunk                  ),                  fp                  )                  !=                  Nada                  )                  {                  xiv                                    fputs                  (                  chunk                  ,                  stdout                  );                  15                                    fputs                  (                  "|*                  \northward                  "                  ,                  stdout                  );                  // marking string used to show where the content of the clamper array has concluded                  xvi                                    }                  17                                    18                                    fclose                  (                  fp                  );                  nineteen                                    }                              

For testing the code I've used a elementary dummy file, lorem.txt. This is a slice from the output of the in a higher place programme on my machine:

                                                                        1                                    ~ $ clang -std=c17 -Wall -Wextra -pedantic t0.c -o t0                                      2                                    ~ $ ./t0                                      iii                                    Lorem ipsum dolor sit down amet, consectetur adipiscing elit.                                      4                                    |*                                      5                                    Fusce dignissim facilisis ligula consectetur hendrerit. Vestibulum porttitor aliquam luctus. Nam pharetra lorem vel ornare cond|*                                      6                                    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.                  x                                    |*                              

The code prints the content of the chunk assortment, as filled after every call to fgets, and a marker string.

If yous sentry carefully, by scrolling the above text snippet to the correct, you can see that the output was truncated to 127 characters per line of text. This was expected because our code can shop an unabridged line from the original text file but if the line tin fit within our chunk array.

What if yous 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 separate line buffer until we find the end of line character.

Permit'due south start past creating a line buffer that will store the chunks of text, initially this volition have the same length as the chunk array:

                                                                        1                                    #include                  <stdio.h>                                                        2                                    #include                  <stdlib.h>                                                        3                                    #include                  <string.h>                                                        4                                                        5                                    int                  main                  (                  void                  )                  {                                      half dozen                                    FILE                  *                  fp                  =                  fopen                  (                  "lorem.txt"                  ,                  "r"                  );                                      vii                                    // ...                                      8                                                        9                                    char                  clamper                  [                  128                  ];                  x                                    xi                                    // Store the chunks of text into a line buffer                  12                                    size_t                  len                  =                  sizeof                  (                  chunk                  );                  13                                    char                  *                  line                  =                  malloc                  (                  len                  );                  fourteen                                    if                  (                  line                  ==                  NULL                  )                  {                  15                                    perror                  (                  "Unable to allocate retentiveness for the line buffer."                  );                  16                                    get out                  (                  i                  );                  17                                    }                  18                                    19                                    // "Empty" the string                  xx                                    line                  [                  0                  ]                  =                  '\0'                  ;                  21                                    22                                    // ...                  23                                    24                                    }                              

Next, nosotros are going to append the content of the chunk array to the end of the line string, until we discover the end of line graphic symbol. If necessary, we'll resize the line buffer:

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

Please note, that in the to a higher place lawmaking, every fourth dimension the line buffer needs to be resized its capacity is doubled.

This is the result of running the to a higher place code on my machine. For brevity, I kept only the outset lines of output:

                                                                        1                                    ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1                                      2                                    ~ $ ./t1                                      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 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.                                      8                                    |*                                      ix                                    Aliquam erat volutpat. Mauris dignissim augue ac purus placerat scelerisque. Donec eleifend ut nibh eu elementum.                  10                                    |*                              

You can see that, this fourth dimension, we tin can print full lines of text and non fixed length chunks like in the initial approach.

Let's alter the above lawmaking in club to impress the line length instead of the actual text:

                                                                        i                                    // ...                                      ii                                                        three                                    int                  principal                  (                  void                  )                  {                                      4                                    // ...                                      5                                                        6                                    while                  (                  fgets                  (                  chunk                  ,                  sizeof                  (                  chunk                  ),                  fp                  )                  !=                  NULL                  )                  {                                      seven                                                        8                                    // ...                                      9                                    10                                    // Bank check if line contains '\northward', if aye procedure the line of text                  eleven                                    if                  (                  line                  [                  len_used                  -                  1                  ]                  ==                  '\n'                  )                  {                  12                                    printf                  (                  "line length: %zd                  \due north                  "                  ,                  len_used                  );                  thirteen                                    // "Empty" the line buffer                  14                                    line                  [                  0                  ]                  =                  '\0'                  ;                  15                                    }                  16                                    }                  17                                    18                                    fclose                  (                  fp                  );                  xix                                    free                  (                  line                  );                  20                                    21                                    printf                  (                  "                  \n\northward                  Max line size: %zd                  \northward                  "                  ,                  len                  );                  22                                    }                              

This is the result of running the modified code on my automobile:

                                                                        1                                    ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1                                      ii                                    ~ $ ./t1                                      3                                    line length: 57                                      4                                    line length: 136                                      5                                    line length: 147                                      half dozen                                    line length: 114                                      7                                    line length: 112                                      viii                                    line length: 95                                      9                                    line length: 62                  10                                    line length: 1                  11                                    line length: 428                  12                                    line length: i                  thirteen                                    line length: 460                  14                                    line length: 1                  15                                    line length: 834                  xvi                                    line length: 1                  17                                    line length: 821                  18                                    nineteen                                    20                                    Max line size: 1024                              

In the next instance, I will show yous how to use the getline function available on POSIX systems like Linux, Unix and macOS. Microsoft Visual Studio doesn't have an equivalent role, and then you won't be able to hands test this case on a Windows arrangement. However, you should be able to test information technology if you are using Cygwin or Windows Subsystem for Linux.

                                                                        i                                    #include                  <stdio.h>                                                        2                                    #include                  <stdlib.h>                                                        3                                    #include                  <cord.h>                                                        iv                                                        5                                    int                  principal                  (                  void                  )                  {                                      6                                    FILE                  *                  fp                  =                  fopen                  (                  "lorem.txt"                  ,                  "r"                  );                                      vii                                    if                  (                  fp                  ==                  NULL                  )                  {                                      8                                    perror                  (                  "Unable to open up file!"                  );                                      9                                    exit                  (                  1                  );                  10                                    }                  xi                                    12                                    // Read lines using POSIX function getline                  13                                    // This code won't work on Windows                  xiv                                    char                  *                  line                  =                  NULL                  ;                  15                                    size_t                  len                  =                  0                  ;                  16                                    17                                    while                  (                  getline                  (                  &                  line                  ,                  &                  len                  ,                  fp                  )                  !=                  -                  ane                  )                  {                  18                                    printf                  (                  "line length: %zd                  \n                  "                  ,                  strlen                  (                  line                  ));                  xix                                    }                  twenty                                    21                                    printf                  (                  "                  \north\n                  Max line size: %zd                  \n                  "                  ,                  len                  );                  22                                    23                                    fclose                  (                  fp                  );                  24                                    free                  (                  line                  );                  // getline will resize the input buffer equally necessary                  25                                    // the user needs to free the retention when not needed!                  26                                    }                              

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

When yous utilize getline, don't forget to complimentary the line buffer when you don't need it anymore. Also, calling getline more than once will overwrite the line buffer, brand a copy of the line content if you demand to go on information technology for further processing.

This is the consequence of running the in a higher place getline example on a Linux machine:

                                                                        1                                    ~ $ clang -std=gnu17 -Wall -Wextra -pedantic t2.c -o t2                                      2                                    ~ $ ./t2                                      3                                    line length: 57                                      4                                    line length: 136                                      5                                    line length: 147                                      6                                    line length: 114                                      seven                                    line length: 112                                      8                                    line length: 95                                      9                                    line length: 62                  ten                                    line length: ane                  11                                    line length: 428                  12                                    line length: 1                  13                                    line length: 460                  14                                    line length: ane                  xv                                    line length: 834                  16                                    line length: 1                  17                                    line length: 821                  18                                    19                                    20                                    Max line size: 960                              

It is interesting to notation, that for this item case the getline office on Linux resizes the line buffer to a max of 960 bytes. If you run the aforementioned 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 practise to implement a portable version of this part. The idea here is not to implement the most performant version of getline, but rather to implement a simple replacement for non POSIX systems.

We are going to take the above instance and replace the POSIX's getline version with our own implementation, say my_getline. Plainly, if you are on a POSIX arrangement, you should use the version provided by the operating system, which was tested by countless users and tuned for optimal functioning.

The POSIX getline function has this signature:

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

Since ssize_t is besides a POSIX defined type, usually a 64 $.25 signed integer, this is how we are going to declare our version:

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

In principle we are going to implement the role using the same arroyo as in 1 of the above examples, where I've defined a line buffer and kept copying chunks of text in the buffer until we plant the end of line grapheme:

                                                                        1                                    // This will only take effect on Windows with MSVC                                      ii                                    #ifdef _MSC_VER                                      3                                    #define _CRT_SECURE_NO_WARNINGS 1                                      4                                    #define restrict __restrict                                      5                                    

Share this post