Using Getline to Read a File in C
Solarian Programmer
My programming ramblings
C Programming - read a file line by line with fgets and getline, implement a portable getline version
Posted on Apr 3, 2022 by Paul
In this commodity, I will bear witness y'all how to read a text file line by line in C using the standard C function fgets and the POSIX getline office. At the end of the commodity, I volition write a portable implementation of the getline function that tin be used with any standard C compiler.
Reading a file line by line is a piddling problem in many programming languages, only non in C. The standard way of reading a line of text in C is to use the fgets function, which is fine if y'all know in accelerate 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 article.
Let's outset 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 chief ( void ) { 5 FILE * fp = fopen ( "lorem.txt" , "r" ); 6 if ( fp == Goose egg ) { 7 perror ( "Unable to open up file!" ); 8 leave ( 1 ); 9 } 10 xi char chunk [ 128 ]; 12 xiii while ( fgets ( clamper , sizeof ( chunk ), fp ) != Nada ) { 14 fputs ( chunk , stdout ); fifteen fputs ( "|* \due north " , stdout ); // mark string used to show where the content of the chunk array has ended sixteen } 17 xviii fclose ( fp ); 19 } For testing the lawmaking I've used a simple dummy file, lorem.txt. This is a piece from the output of the in a higher place program on my auto:
ane ~ $ clang -std=c17 -Wall -Wextra -pedantic t0.c -o t0 2 ~ $ ./t0 3 Lorem ipsum dolor sit amet, consectetur adipiscing elit. iv |* v 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. 10 |* The code prints the content of the chunk array, equally filled later every phone call to fgets, and a mark string.
If you sentinel carefully, by scrolling the higher up text snippet to the right, y'all can see that the output was truncated to 127 characters per line of text. This was expected because our code can store an entire line from the original text file merely if the line can fit inside our chunk array.
What if you demand to have the entire line of text bachelor 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 character.
Let's start by creating a line buffer that will store the chunks of text, initially this volition have the same length as the chunk assortment:
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 chunk [ 128 ]; 10 11 // Store the chunks of text into a line buffer 12 size_t len = sizeof ( chunk ); 13 char * line = malloc ( len ); 14 if ( line == NULL ) { 15 perror ( "Unable to allocate memory for the line buffer." ); 16 leave ( 1 ); 17 } 18 19 // "Empty" the string xx line [ 0 ] = '\0' ; 21 22 // ... 23 24 } Next, we are going to append the content of the chunk array to the stop of the line string, until nosotros find the terminate of line character. If necessary, we'll resize the line buffer:
1 #include <stdio.h> ii #include <stdlib.h> 3 #include <string.h> 4 5 int main ( void ) { 6 // ... 7 8 // "Empty" the string 9 line [ 0 ] = '\0' ; ten xi while ( fgets ( chunk , sizeof ( chunk ), fp ) != NULL ) { 12 // Resize the line buffer if necessary 13 size_t len_used = strlen ( line ); fourteen size_t chunk_used = strlen ( chunk ); 15 xvi if ( len - len_used < chunk_used ) { 17 len *= two ; 18 if (( line = realloc ( line , len )) == NULL ) { 19 perror ( "Unable to reallocate retention for the line buffer." ); 20 complimentary ( 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 // Bank check if line contains '\n', if aye process the line of text 30 if ( line [ len_used - ane ] == '\north' ) { 31 fputs ( line , stdout ); 32 fputs ( "|* \north " , stdout ); 33 // "Empty" the line buffer 34 line [ 0 ] = '\0' ; 35 } 36 } 37 38 fclose ( fp ); 39 free ( line ); xl 41 printf ( " \n\northward Max line size: %zd \n " , len ); 42 } Please note, that in the above code, every fourth dimension the line buffer needs to be resized its chapters is doubled.
This is the upshot of running the above code on my machine. For brevity, I kept simply the first lines of output:
1 ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1 2 ~ $ ./t1 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 condimentum. six |* 7 Praesent et nunc at libero vulputate convallis. Cras egestas nunc vitae eros vehicula hendrerit. Pellentesque in est et sapien dignissim molestie. 8 |* 9 Aliquam erat volutpat. Mauris dignissim augue ac purus placerat scelerisque. Donec eleifend ut nibh eu elementum. 10 |* Y'all can see that, this time, nosotros can print full lines of text and non fixed length chunks like in the initial approach.
Let's alter the above code in guild to print the line length instead of the actual text:
i // ... two iii int main ( void ) { four // ... 5 6 while ( fgets ( chunk , sizeof ( chunk ), fp ) != Aught ) { 7 viii // ... ix 10 // Check if line contains '\due north', if yes process the line of text 11 if ( line [ len_used - 1 ] == '\north' ) { 12 printf ( "line length: %zd \n " , len_used ); 13 // "Empty" the line buffer 14 line [ 0 ] = '\0' ; 15 } 16 } 17 18 fclose ( fp ); 19 free ( line ); 20 21 printf ( " \n\north Max line size: %zd \due north " , len ); 22 } This is the result of running the modified lawmaking on my machine:
one ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1 2 ~ $ ./t1 3 line length: 57 4 line length: 136 5 line length: 147 6 line length: 114 7 line length: 112 8 line length: 95 9 line length: 62 10 line length: one 11 line length: 428 12 line length: 1 13 line length: 460 14 line length: 1 15 line length: 834 16 line length: i 17 line length: 821 18 nineteen 20 Max line size: 1024 In the side by side case, I volition show you lot how to apply the getline office available on POSIX systems like Linux, Unix and macOS. Microsoft Visual Studio doesn't take an equivalent function, so you won't be able to easily test this instance on a Windows arrangement. Even so, you should be able to exam it if you are using Cygwin or Windows Subsystem for Linux.
ane #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> four 5 int primary ( void ) { 6 FILE * fp = fopen ( "lorem.txt" , "r" ); seven if ( fp == Naught ) { 8 perror ( "Unable to open file!" ); 9 exit ( 1 ); 10 } xi 12 // Read lines using POSIX function getline 13 // This lawmaking won't work on Windows 14 char * line = NULL ; 15 size_t len = 0 ; sixteen 17 while ( getline ( & line , & len , fp ) != - 1 ) { 18 printf ( "line length: %zd \north " , strlen ( line )); 19 } xx 21 printf ( " \due north\north 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 retentivity when not needed! 26 } Please note, how unproblematic is to utilize POSIX'due south getline versus manually buffering chunks of line similar in my previous example. It is unfortunate that the standard C library doesn't include an equivalent function.
When y'all apply getline, don't forget to free the line buffer when you don't need it anymore. Also, calling getline more than than one time will overwrite the line buffer, make a copy of the line content if yous demand to keep it for further processing.
This is the result of running the above getline case 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 v line length: 147 vi line length: 114 7 line length: 112 8 line length: 95 9 line length: 62 10 line length: 1 11 line length: 428 12 line length: 1 13 line length: 460 14 line length: i 15 line length: 834 16 line length: 1 17 line length: 821 18 19 xx Max line size: 960 Information technology is interesting to note, that for this particular case the getline function on Linux resizes the line buffer to a max of 960 bytes. If you run the same lawmaking on macOS the line buffer is resized to 1024 bytes. This is due to the different ways in which getline is implemented on unlike Unix similar systems.
As mentioned before, getline is not present in the C standard library. It could exist an interesting exercise to implement a portable version of this function. The thought hither is non to implement the virtually performant version of getline, but rather to implement a uncomplicated replacement for non POSIX systems.
Nosotros are going to accept the in a higher place example and supercede the POSIX'south getline version with our ain implementation, say my_getline. Obviously, if you are on a POSIX organisation, you lot should apply the version provided past the operating organization, which was tested past countless users and tuned for optimal operation.
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 we are going to implement the function using the aforementioned approach 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 nosotros found the end of line graphic symbol:
ane // This will only have issue on Windows with MSVC 2 #ifdef _MSC_VER 3 #define _CRT_SECURE_NO_WARNINGS 1 four #define restrict __restrict v
0 Response to "Using Getline to Read a File in C"
Post a Comment