C Read Each Line in a File
Solarian Developer
My programming ramblings
C Programming - read a file line past line with fgets and getline, implement a portable getline version
Posted on April 3, 2019 past Paul
In this commodity, I will testify you how to read a text file line by line in C using the standard C function fgets and the POSIX getline function. At the stop of the article, I will write a portable implementation of the getline office that tin be used with whatsoever standard C compiler.
Reading a file line past line is a lilliputian trouble in many programming languages, but not in C. The standard fashion of reading a line of text in C is to apply the fgets function, which is fine if you know in advance how long a line of text could be.
You can find all the code examples and the input file at the GitHub repo for this commodity.
Permit's start 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" ); 6 if ( fp == NULL ) { 7 perror ( "Unable to open file!" ); 8 exit ( ane ); 9 } 10 eleven char chunk [ 128 ]; 12 13 while ( fgets ( chunk , sizeof ( clamper ), fp ) != NULL ) { 14 fputs ( clamper , stdout ); 15 fputs ( "|* \n " , stdout ); // marker string used to show where the content of the clamper array has ended xvi } 17 18 fclose ( fp ); 19 } For testing the code I've used a elementary dummy file, lorem.txt. This is a piece from the output of the higher up plan on my automobile:
one ~ $ clang -std=c17 -Wall -Wextra -pedantic t0.c -o t0 2 ~ $ ./t0 3 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|* vi imentum. seven |* 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 lawmaking prints the content of the chunk assortment, as filled after every telephone call to fgets, and a marker cord.
If you watch carefully, by scrolling the above text snippet to the correct, y'all tin run into that the output was truncated to 127 characters per line of text. This was expected because our lawmaking can store an entire line from the original text file just if the line can fit inside our clamper array.
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 nosotros detect the end of line character.
Let's start by creating a line buffer that will store the chunks of text, initially this will accept the aforementioned length equally the chunk assortment:
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> four 5 int main ( void ) { 6 FILE * fp = fopen ( "lorem.txt" , "r" ); 7 // ... 8 9 char clamper [ 128 ]; 10 11 // Store the chunks of text into a line buffer 12 size_t len = sizeof ( chunk ); thirteen char * line = malloc ( len ); 14 if ( line == NULL ) { 15 perror ( "Unable to allocate retention for the line buffer." ); 16 exit ( 1 ); 17 } eighteen nineteen // "Empty" the string 20 line [ 0 ] = '\0' ; 21 22 // ... 23 24 } Next, we are going to append the content of the chunk array to the terminate of the line string, until nosotros observe the cease of line grapheme. If necessary, we'll resize the line buffer:
1 #include <stdio.h> two #include <stdlib.h> 3 #include <string.h> 4 5 int main ( void ) { six // ... 7 8 // "Empty" the string nine line [ 0 ] = '\0' ; x 11 while ( fgets ( chunk , sizeof ( clamper ), fp ) != NULL ) { 12 // Resize the line buffer if necessary 13 size_t len_used = strlen ( line ); 14 size_t chunk_used = strlen ( chunk ); xv xvi if ( len - len_used < chunk_used ) { 17 len *= 2 ; xviii if (( line = realloc ( line , len )) == NULL ) { 19 perror ( "Unable to reallocate memory for the line buffer." ); twenty gratis ( line ); 21 exit ( 1 ); 22 } 23 } 24 25 // Re-create the clamper to the cease 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 ); xl 41 printf ( " \n\n Max line size: %zd \n " , len ); 42 } Please note, that in the above code, every time the line buffer needs to be resized its capacity is doubled.
This is the result of running the above code on my car. For brevity, I kept only the first lines of output:
1 ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1 ii ~ $ ./t1 3 Lorem ipsum dolor sit amet, consectetur adipiscing elit. four |* 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. eight |* 9 Aliquam erat volutpat. Mauris dignissim augue ac purus placerat scelerisque. Donec eleifend ut nibh eu elementum. 10 |* You can meet that, this time, nosotros can print full lines of text and not stock-still length chunks similar in the initial approach.
Let'south modify the above code in order to impress the line length instead of the actual text:
1 // ... 2 three int main ( void ) { 4 // ... 5 half-dozen while ( fgets ( chunk , sizeof ( chunk ), fp ) != NULL ) { seven viii // ... ix 10 // Check if line contains '\n', if yes process the line of text xi if ( line [ len_used - i ] == '\north' ) { 12 printf ( "line length: %zd \north " , len_used ); 13 // "Empty" the line buffer xiv line [ 0 ] = '\0' ; 15 } 16 } 17 18 fclose ( fp ); 19 free ( line ); 20 21 printf ( " \north\n Max line size: %zd \n " , len ); 22 } This is the result of running the modified code on my machine:
one ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1 2 ~ $ ./t1 3 line length: 57 4 line length: 136 v line length: 147 vi line length: 114 7 line length: 112 8 line length: 95 ix line length: 62 10 line length: ane eleven line length: 428 12 line length: 1 13 line length: 460 14 line length: ane 15 line length: 834 16 line length: i 17 line length: 821 xviii 19 xx Max line size: 1024 In the next example, I volition testify yous how to use the getline function bachelor on POSIX systems similar Linux, Unix and macOS. Microsoft Visual Studio doesn't accept an equivalent function, so you won't be able to easily test this example on a Windows organization. However, you should be able to test it if yous are using Cygwin or Windows Subsystem for Linux.
1 #include <stdio.h> 2 #include <stdlib.h> iii #include <string.h> four 5 int main ( void ) { half dozen FILE * fp = fopen ( "lorem.txt" , "r" ); 7 if ( fp == Zero ) { viii 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 = Cipher ; xv size_t len = 0 ; sixteen 17 while ( getline ( & line , & len , fp ) != - 1 ) { 18 printf ( "line length: %zd \due north " , strlen ( line )); 19 } 20 21 printf ( " \northward\northward Max line size: %zd \n " , len ); 22 23 fclose ( fp ); 24 gratis ( line ); // getline volition resize the input buffer every bit necessary 25 // the user needs to free the memory when not needed! 26 } Delight annotation, how simple is to use POSIX'south getline versus manually buffering chunks of line like in my previous example. It is unfortunate that the standard C library doesn't include an equivalent role.
When you use getline, don't forget to costless the line buffer when you don't demand it anymore. Also, calling getline more than once volition overwrite the line buffer, make a copy of the line content if you need to keep it for farther processing.
This is the result of running the higher up getline example on a Linux car:
i ~ $ clang -std=gnu17 -Wall -Wextra -pedantic t2.c -o t2 ii ~ $ ./t2 iii line length: 57 iv line length: 136 5 line length: 147 half dozen line length: 114 7 line length: 112 8 line length: 95 9 line length: 62 ten line length: 1 11 line length: 428 12 line length: 1 xiii line length: 460 14 line length: one fifteen line length: 834 16 line length: 1 17 line length: 821 eighteen 19 twenty Max line size: 960 It is interesting to note, that for this detail case the getline office on Linux resizes the line buffer to a max of 960 bytes. If yous run the aforementioned code on macOS the line buffer is resized to 1024 bytes. This is due to the different means in which getline is implemented on different Unix like systems.
Every bit mentioned before, getline is non present in the C standard library. It could be an interesting practise to implement a portable version of this role. The thought here is not to implement the about performant version of getline, but rather to implement a unproblematic replacement for non POSIX systems.
We are going to take the above example and replace the POSIX'southward getline version with our own implementation, say my_getline. Apparently, if you are on a POSIX system, you lot 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:
i ssize_t getline ( char ** restrict lineptr , size_t * restrict n , FILE * restrict stream ); Since ssize_t is also a POSIX divers type, unremarkably a 64 $.25 signed integer, this is how we are going to declare our version:
1 int64_t my_getline ( char ** restrict line , size_t * restrict len , FILE * restrict fp ); In principle we are going to implement the function using the same arroyo every bit in ane of the above examples, where I've defined a line buffer and kept copying chunks of text in the buffer until we found the end of line character:
1 // This will only have effect on Windows with MSVC 2 #ifdef _MSC_VER 3 #define _CRT_SECURE_NO_WARNINGS 1 4 #define restrict __restrict five
0 Response to "C Read Each Line in a File"
Post a Comment