How to Read One Line at a Time 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 April iii, 2019 by Paul
In this article, I will bear witness you lot how to read a text file line by line in C using the standard C function fgets and the POSIX getline function. At the end of the commodity, I will write a portable implementation of the getline function that can be used with any standard C compiler.
Reading a file line by line is a niggling problem in many programming languages, but not in C. The standard way of reading a line of text in C is to utilize the fgets function, which is fine if you know in accelerate how long a line of text could exist.
You lot can discover all the code examples and the input file at the GitHub repo for this article.
Allow's start with a simple instance of using fgets to read chunks from a text file. :
1 #include <stdio.h> two #include <stdlib.h> iii 4 int master ( void ) { v FILE * fp = fopen ( "lorem.txt" , "r" ); 6 if ( fp == NULL ) { 7 perror ( "Unable to open up file!" ); eight get out ( one ); 9 } x 11 char clamper [ 128 ]; 12 13 while ( fgets ( chunk , sizeof ( chunk ), fp ) != NULL ) { 14 fputs ( chunk , stdout ); 15 fputs ( "|* \n " , stdout ); // marker string used to show where the content of the clamper assortment has ended 16 } 17 18 fclose ( fp ); 19 } For testing the code I've used a uncomplicated dummy file, lorem.txt. This is a piece from the output of the above program on my machine:
one ~ $ clang -std=c17 -Wall -Wextra -pedantic t0.c -o t0 2 ~ $ ./t0 3 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 cond|* 6 imentum. 7 |* eight 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 assortment, equally filled afterwards every telephone call to fgets, and a marking string.
If y'all picket carefully, past scrolling the to a higher place 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 lawmaking tin store an unabridged line from the original text file just if the line can fit inside our clamper array.
What if you need to take the entire line of text available for further processing and not a piece of line ? A possible solution is to re-create or concatenate chunks of text in a split up line buffer until we notice the end of line character.
Let'due south start by creating a line buffer that volition shop the chunks of text, initially this will accept the same length equally the chunk array:
i #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 int main ( void ) { six FILE * fp = fopen ( "lorem.txt" , "r" ); 7 // ... 8 9 char chunk [ 128 ]; 10 eleven // Store the chunks of text into a line buffer 12 size_t len = sizeof ( chunk ); 13 char * line = malloc ( len ); xiv if ( line == Zilch ) { 15 perror ( "Unable to allocate retentiveness for the line buffer." ); 16 exit ( i ); 17 } 18 19 // "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 finish of the line cord, until we find the cease of line graphic symbol. If necessary, we'll resize the line buffer:
1 #include <stdio.h> ii #include <stdlib.h> 3 #include <string.h> four 5 int main ( void ) { 6 // ... 7 viii // "Empty" the string 9 line [ 0 ] = '\0' ; 10 11 while ( fgets ( chunk , sizeof ( chunk ), fp ) != NULL ) { 12 // Resize the line buffer if necessary thirteen size_t len_used = strlen ( line ); 14 size_t chunk_used = strlen ( chunk ); 15 sixteen if ( len - len_used < chunk_used ) { 17 len *= 2 ; 18 if (( line = realloc ( line , len )) == Nada ) { 19 perror ( "Unable to reallocate memory for the line buffer." ); xx free ( line ); 21 exit ( 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 '\northward', if yes process the line of text 30 if ( line [ len_used - ane ] == '\due north' ) { 31 fputs ( line , stdout ); 32 fputs ( "|* \due north " , 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 \north " , len ); 42 } Please annotation, that in the higher up code, every fourth dimension the line buffer needs to be resized its chapters is doubled.
This is the result of running the above code on my automobile. For brevity, I kept only the first 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 |* five Fusce dignissim facilisis ligula consectetur hendrerit. Vestibulum porttitor aliquam luctus. Nam pharetra lorem vel ornare condimentum. 6 |* 7 Praesent et nunc at libero vulputate convallis. Cras egestas nunc vitae eros vehicula hendrerit. Pellentesque in est et sapien dignissim molestie. eight |* ix Aliquam erat volutpat. Mauris dignissim augue air-conditioning purus placerat scelerisque. Donec eleifend ut nibh eu elementum. ten |* Y'all can see that, this time, we tin can impress full lines of text and not fixed length chunks like in the initial approach.
Permit's modify the higher up lawmaking in guild to print the line length instead of the bodily text:
ane // ... two iii int main ( void ) { 4 // ... five 6 while ( fgets ( chunk , sizeof ( chunk ), fp ) != Aught ) { vii viii // ... 9 10 // Cheque if line contains '\northward', if yes procedure the line of text xi if ( line [ len_used - 1 ] == '\n' ) { 12 printf ( "line length: %zd \n " , len_used ); thirteen // "Empty" the line buffer 14 line [ 0 ] = '\0' ; 15 } xvi } 17 18 fclose ( fp ); 19 free ( line ); 20 21 printf ( " \northward\due north Max line size: %zd \n " , len ); 22 } This is the result of running the modified lawmaking on my automobile:
1 ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1 2 ~ $ ./t1 3 line length: 57 4 line length: 136 v 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: ane 13 line length: 460 14 line length: 1 15 line length: 834 xvi line length: i 17 line length: 821 18 nineteen 20 Max line size: 1024 In the next example, I will show you how to use the getline function bachelor on POSIX systems like Linux, Unix and macOS. Microsoft Visual Studio doesn't have an equivalent part, then yous won't exist able to easily examination this example on a Windows system. However, you should exist able to test it if y'all are using Cygwin or Windows Subsystem for Linux.
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 five int chief ( void ) { 6 FILE * fp = fopen ( "lorem.txt" , "r" ); seven if ( fp == NULL ) { 8 perror ( "Unable to open file!" ); 9 exit ( 1 ); ten } eleven 12 // Read lines using POSIX function getline 13 // This code won't work on Windows 14 char * line = Naught ; xv size_t len = 0 ; 16 17 while ( getline ( & line , & len , fp ) != - one ) { eighteen printf ( "line length: %zd \northward " , strlen ( line )); 19 } 20 21 printf ( " \north\n 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 memory when not needed! 26 } Please note, how simple is to employ POSIX's getline versus manually buffering chunks of line like in my previous instance. It is unfortunate that the standard C library doesn't include an equivalent function.
When you use getline, don't forget to free the line buffer when you don't need information technology anymore. Also, calling getline more than once will overwrite the line buffer, make a copy of the line content if y'all demand to keep it for further processing.
This is the issue of running the above 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 vi line length: 114 seven line length: 112 viii line length: 95 9 line length: 62 x line length: one 11 line length: 428 12 line length: 1 13 line length: 460 14 line length: i 15 line length: 834 xvi line length: 1 17 line length: 821 18 nineteen xx Max line size: 960 It is interesting to annotation, that for this particular case the getline function on Linux resizes the line buffer to a max of 960 bytes. If yous 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 different Unix similar systems.
As mentioned before, getline is not present in the C standard library. It could be an interesting practice to implement a portable version of this function. The idea hither is not to implement the most performant version of getline, but rather to implement a uncomplicated replacement for not POSIX systems.
Nosotros are going to have the to a higher place example and replace the POSIX's getline version with our own implementation, say my_getline. Evidently, if yous are on a POSIX arrangement, you should use the version provided by the operating system, which was tested by endless users and tuned for optimal performance.
The POSIX getline function has this signature:
1 ssize_t getline ( char ** restrict lineptr , size_t * restrict n , FILE * restrict stream ); Since ssize_t is likewise a POSIX defined type, ordinarily 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 office using the same approach as in i of the above examples, where I've defined a line buffer and kept copying chunks of text in the buffer until we found the finish of line grapheme:
ane // This will merely accept effect on Windows with MSVC 2 #ifdef _MSC_VER three #ascertain _CRT_SECURE_NO_WARNINGS 1 4 #define restrict __restrict 5
0 Response to "How to Read One Line at a Time in C"
Post a Comment