How to Use Getline to Read Integers
Solarian Programmer
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 by Paul
In this article, I will show you how to read a text file line past line in C using the standard C role 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 any standard C compiler.
Reading a file line by line is a picayune problem in many programming languages, merely not in C. The standard style of reading a line of text in C is to use the fgets function, which is fine if you know in advance how long a line of text could be.
You can detect all the code examples and the input file at the GitHub repo for this article.
Let'southward commencement with a uncomplicated example of using fgets to read chunks from a text file. :
one #include <stdio.h> 2 #include <stdlib.h> 3 4 int main ( void ) { 5 FILE * fp = fopen ( "lorem.txt" , "r" ); 6 if ( fp == NULL ) { seven perror ( "Unable to open up file!" ); 8 exit ( i ); ix } 10 11 char chunk [ 128 ]; 12 13 while ( fgets ( chunk , sizeof ( chunk ), fp ) != NULL ) { fourteen fputs ( chunk , stdout ); fifteen fputs ( "|* \n " , stdout ); // marker string used to show where the content of the clamper array has ended 16 } 17 xviii fclose ( fp ); 19 } For testing the code I've used a simple dummy file, lorem.txt. This is a piece from the output of the above program on my car:
ane ~ $ 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. vii |* 8 Praesent et nunc at libero vulputate convallis. Cras egestas nunc vitae eros vehicula hendrerit. Pellentesque in est et sapien |* 9 dignissim molestie. ten |* The code prints the content of the chunk array, as filled after every call to fgets, and a marker string.
If yous watch carefully, by scrolling the above text snippet to the right, you tin can see that the output was truncated to 127 characters per line of text. This was expected because our lawmaking tin can store an entire line from the original text file merely if the line can fit inside our clamper array.
What if yous need 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 separate line buffer until we find the terminate of line character.
Let's start by creating a line buffer that will shop the chunks of text, initially this volition take the same length as the chunk array:
one #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 int primary ( void ) { six FILE * fp = fopen ( "lorem.txt" , "r" ); 7 // ... eight 9 char chunk [ 128 ]; 10 xi // 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 exit ( 1 ); 17 } 18 19 // "Empty" the string 20 line [ 0 ] = '\0' ; 21 22 // ... 23 24 } Side by side, we are going to append the content of the clamper array to the cease of the line string, until we find the end of line graphic symbol. If necessary, we'll resize the line buffer:
i #include <stdio.h> two #include <stdlib.h> 3 #include <string.h> 4 5 int chief ( void ) { six // ... 7 eight // "Empty" the string nine line [ 0 ] = '\0' ; 10 eleven while ( fgets ( chunk , sizeof ( chunk ), fp ) != Nada ) { 12 // Resize the line buffer if necessary 13 size_t len_used = strlen ( line ); 14 size_t chunk_used = strlen ( chunk ); 15 16 if ( len - len_used < chunk_used ) { 17 len *= 2 ; eighteen if (( line = realloc ( line , len )) == NULL ) { xix perror ( "Unable to reallocate memory for the line buffer." ); twenty free ( line ); 21 exit ( ane ); 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 // Bank check if line contains '\n', if yes process the line of text xxx if ( line [ len_used - 1 ] == '\n' ) { 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 ); 40 41 printf ( " \n\due north Max line size: %zd \n " , len ); 42 } Please annotation, that in the higher up code, every fourth dimension 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 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. four |* 5 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. 8 |* nine Aliquam erat volutpat. Mauris dignissim augue air conditioning purus placerat scelerisque. Donec eleifend ut nibh european union elementum. 10 |* Y'all can see that, this fourth dimension, nosotros can impress full lines of text and not stock-still length chunks similar in the initial approach.
Let's change the above code in order to print the line length instead of the actual text:
1 // ... ii 3 int chief ( void ) { 4 // ... 5 6 while ( fgets ( chunk , sizeof ( chunk ), fp ) != Zippo ) { 7 8 // ... 9 10 // Bank check if line contains '\northward', if yes process the line of text 11 if ( line [ len_used - 1 ] == '\northward' ) { 12 printf ( "line length: %zd \due north " , len_used ); 13 // "Empty" the line buffer 14 line [ 0 ] = '\0' ; fifteen } 16 } 17 xviii fclose ( fp ); 19 costless ( line ); 20 21 printf ( " \n\north Max line size: %zd \n " , len ); 22 } This is the result of running the modified lawmaking on my machine:
1 ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1 ii ~ $ ./t1 three line length: 57 4 line length: 136 five line length: 147 6 line length: 114 7 line length: 112 8 line length: 95 9 line length: 62 10 line length: 1 xi line length: 428 12 line length: 1 13 line length: 460 14 line length: one 15 line length: 834 16 line length: one 17 line length: 821 eighteen 19 20 Max line size: 1024 In the next example, I will testify you how to use the getline function available on POSIX systems similar Linux, Unix and macOS. Microsoft Visual Studio doesn't have an equivalent part, so yous won't be able to easily test this example on a Windows organization. However, you should exist able to exam it if yous are using Cygwin or Windows Subsystem for Linux.
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> iv 5 int main ( void ) { 6 FILE * fp = fopen ( "lorem.txt" , "r" ); seven if ( fp == Zippo ) { 8 perror ( "Unable to open up file!" ); nine exit ( 1 ); ten } 11 12 // Read lines using POSIX function getline 13 // This lawmaking won't work on Windows 14 char * line = Cypher ; xv size_t len = 0 ; 16 17 while ( getline ( & line , & len , fp ) != - 1 ) { 18 printf ( "line length: %zd \n " , strlen ( line )); 19 } xx 21 printf ( " \n\n Max line size: %zd \due north " , len ); 22 23 fclose ( fp ); 24 free ( line ); // getline will resize the input buffer as necessary 25 // the user needs to free the retentiveness when not needed! 26 } Please notation, how unproblematic is to use POSIX'due south getline versus manually buffering chunks of line like in my previous example. Information technology is unfortunate that the standard C library doesn't include an equivalent part.
When y'all use getline, don't forget to free the line buffer when you don't demand it anymore. Also, calling getline more than once will overwrite the line buffer, brand a copy of the line content if you need to keep it for further processing.
This is the result of running the above getline example on a Linux machine:
i ~ $ clang -std=gnu17 -Wall -Wextra -pedantic t2.c -o t2 2 ~ $ ./t2 3 line length: 57 4 line length: 136 5 line length: 147 half dozen line length: 114 7 line length: 112 8 line length: 95 nine line length: 62 10 line length: one 11 line length: 428 12 line length: 1 13 line length: 460 fourteen line length: 1 fifteen line length: 834 16 line length: 1 17 line length: 821 eighteen 19 20 Max line size: 960 It is interesting to note, that for this particular instance the getline function on Linux resizes the line buffer to a max of 960 bytes. If you lot run the same code on macOS the line buffer is resized to 1024 bytes. This is due to the dissimilar ways in which getline is implemented on different Unix like systems.
As mentioned earlier, getline is not present in the C standard library. It could be an interesting practice to implement a portable version of this office. The thought here is not to implement the most performant version of getline, but rather to implement a elementary replacement for non POSIX systems.
Nosotros are going to take the higher up example and supercede the POSIX's getline version with our own implementation, say my_getline. Apparently, if y'all are on a POSIX system, you should utilize the version provided by the operating organization, which was tested by countless 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 also a POSIX divers type, usually a 64 bits 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 nosotros are going to implement the function using the same arroyo as in one of the above examples, where I've defined a line buffer and kept copying chunks of text in the buffer until we establish the cease of line character:
1 // This will only have outcome on Windows with MSVC 2 #ifdef _MSC_VER 3 #define _CRT_SECURE_NO_WARNINGS 1 4 #define restrict __restrict 5
0 Response to "How to Use Getline to Read Integers"
Postar um comentário