Read in Lines From Text File 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 3, 2019 by Paul
In this article, I will evidence yous how to read a text file line by line in C using the standard C part fgets and the POSIX getline function. At the end of the article, I will write a portable implementation of the getline function that can be used with whatsoever standard C compiler.
Reading a file line by line is a trivial problem in many programming languages, but not in C. The standard fashion of reading a line of text in C is to use the fgets office, which is fine if you know in accelerate how long a line of text could be.
Y'all can detect 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> two #include <stdlib.h> 3 four int main ( void ) { 5 FILE * fp = fopen ( "lorem.txt" , "r" ); half-dozen if ( fp == Zip ) { seven perror ( "Unable to open file!" ); 8 exit ( i ); 9 } 10 eleven char clamper [ 128 ]; 12 thirteen while ( fgets ( chunk , sizeof ( chunk ), fp ) != Goose egg ) { 14 fputs ( chunk , stdout ); fifteen fputs ( "|* \due north " , stdout ); // marker cord used to prove where the content of the chunk array has ended 16 } 17 eighteen fclose ( fp ); nineteen } For testing the code I've used a simple dummy file, lorem.txt. This is a slice from the output of the above programme on my machine:
1 ~ $ clang -std=c17 -Wall -Wextra -pedantic t0.c -o t0 ii ~ $ ./t0 three 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 cond|* half-dozen imentum. vii |* viii 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 array, as filled after every call to fgets, and a marker string.
If you watch carefully, by scrolling the above text snippet to the right, yous tin 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 tin can fit inside our chunk assortment.
What if y'all demand to accept 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 terminate of line character.
Allow'south beginning past creating a line buffer that will store the chunks of text, initially this will accept the same length as the chunk array:
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <cord.h> four five 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 == Aught ) { 15 perror ( "Unable to classify retentiveness for the line buffer." ); 16 exit ( 1 ); 17 } xviii 19 // "Empty" the string twenty line [ 0 ] = '\0' ; 21 22 // ... 23 24 } Adjacent, nosotros are going to suspend the content of the chunk array to the finish of the line string, until we find the end of line character. If necessary, nosotros'll resize the line buffer:
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> four 5 int main ( void ) { 6 // ... seven 8 // "Empty" the cord 9 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 xvi if ( len - len_used < chunk_used ) { 17 len *= 2 ; 18 if (( line = realloc ( line , len )) == Zilch ) { 19 perror ( "Unable to reallocate retentiveness for the line buffer." ); xx free ( line ); 21 exit ( 1 ); 22 } 23 } 24 25 // Re-create 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 '\due north', if yes procedure the line of text 30 if ( line [ len_used - 1 ] == '\due north' ) { 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 ); 40 41 printf ( " \n\n Max line size: %zd \northward " , len ); 42 } Please notation, that in the to a higher place code, every time the line buffer needs to exist resized its capacity is doubled.
This is the result of running the above code on my machine. For brevity, I kept only the first lines of output:
1 ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1 ii ~ $ ./t1 three Lorem ipsum dolor sit amet, consectetur adipiscing elit. 4 |* v Fusce dignissim facilisis ligula consectetur hendrerit. Vestibulum porttitor aliquam luctus. Nam pharetra lorem vel ornare condimentum. half-dozen |* vii Praesent et nunc at libero vulputate convallis. Cras egestas nunc vitae eros vehicula hendrerit. Pellentesque in est et sapien dignissim molestie. viii |* ix Aliquam erat volutpat. Mauris dignissim augue air conditioning purus placerat scelerisque. Donec eleifend ut nibh european union elementum. 10 |* You can meet that, this time, nosotros tin can print full lines of text and not fixed length chunks like in the initial approach.
Let's modify the above code in order to print the line length instead of the actual text:
1 // ... 2 3 int main ( void ) { 4 // ... 5 6 while ( fgets ( clamper , sizeof ( chunk ), fp ) != Goose egg ) { 7 8 // ... nine x // Check if line contains '\n', if aye process the line of text eleven if ( line [ len_used - i ] == '\n' ) { 12 printf ( "line length: %zd \northward " , len_used ); thirteen // "Empty" the line buffer xiv line [ 0 ] = '\0' ; 15 } sixteen } 17 eighteen fclose ( fp ); nineteen free ( line ); xx 21 printf ( " \northward\n Max line size: %zd \n " , len ); 22 } This is the result of running the modified code on my machine:
1 ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1 2 ~ $ ./t1 three line length: 57 four line length: 136 v line length: 147 half dozen line length: 114 7 line length: 112 eight line length: 95 9 line length: 62 ten line length: 1 xi line length: 428 12 line length: 1 thirteen line length: 460 14 line length: one xv line length: 834 xvi line length: 1 17 line length: 821 xviii 19 20 Max line size: 1024 In the next example, I will evidence you how to utilise the getline part available on POSIX systems like Linux, Unix and macOS. Microsoft Visual Studio doesn't have an equivalent part, then yous won't be able to hands test this instance on a Windows system. However, y'all should be able to exam it if you are using Cygwin or Windows Subsystem for Linux.
1 #include <stdio.h> ii #include <stdlib.h> iii #include <cord.h> iv 5 int main ( void ) { vi FILE * fp = fopen ( "lorem.txt" , "r" ); seven if ( fp == Null ) { 8 perror ( "Unable to open up file!" ); nine exit ( 1 ); 10 } 11 12 // Read lines using POSIX function getline 13 // This lawmaking won't piece of work on Windows 14 char * line = Nada ; xv size_t len = 0 ; xvi 17 while ( getline ( & line , & len , fp ) != - 1 ) { 18 printf ( "line length: %zd \n " , strlen ( line )); xix } xx 21 printf ( " \north\n Max line size: %zd \n " , len ); 22 23 fclose ( fp ); 24 gratis ( line ); // getline volition resize the input buffer as necessary 25 // the user needs to free the retentivity when non needed! 26 } Please note, how uncomplicated is to utilize POSIX'south getline versus manually buffering chunks of line similar in my previous case. 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 it anymore. Likewise, calling getline more than once will overwrite the line buffer, brand a copy of the line content if you need to go along it for farther processing.
This is the result 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 four 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: 1 11 line length: 428 12 line length: 1 13 line length: 460 14 line length: one 15 line length: 834 16 line length: 1 17 line length: 821 eighteen 19 xx Max line size: 960 It 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 code 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 like systems.
Equally mentioned earlier, getline is non present in the C standard library. It could be an interesting exercise to implement a portable version of this function. The idea hither is not to implement the most performant version of getline, only rather to implement a simple replacement for non POSIX systems.
We are going to take the above example and replace the POSIX's 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 office has this signature:
1 ssize_t getline ( char ** restrict lineptr , size_t * restrict n , FILE * restrict stream ); Since ssize_t is likewise a POSIX divers type, normally a 64 $.25 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 same approach as in one of the above examples, where I've defined a line buffer and kept copying chunks of text in the buffer until nosotros plant the end of line character:
1 // This will only have result on Windows with MSVC ii #ifdef _MSC_VER 3 #define _CRT_SECURE_NO_WARNINGS one 4 #define restrict __restrict v
0 Response to "Read in Lines From Text File C"
Post a Comment