C Read Character Length of Line From File
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 past Paul
In this article, I volition evidence you 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 commodity, I will write a portable implementation of the getline part that can be used with any standard C compiler.
Reading a file line by line is a trivial problem in many programming languages, simply not in C. The standard style of reading a line of text in C is to use the fgets role, which is fine if you know in advance how long a line of text could exist.
You can detect all the code examples and the input file at the GitHub repo for this article.
Let's kickoff with a elementary case of using fgets to read chunks from a text file. :
1 #include <stdio.h> 2 #include <stdlib.h> 3 4 int master ( void ) { five FILE * fp = fopen ( "lorem.txt" , "r" ); 6 if ( fp == NULL ) { 7 perror ( "Unable to open file!" ); eight exit ( 1 ); ix } 10 11 char chunk [ 128 ]; 12 13 while ( fgets ( chunk , sizeof ( chunk ), fp ) != NULL ) { 14 fputs ( clamper , stdout ); 15 fputs ( "|* \north " , stdout ); // marker cord used to bear witness where the content of the chunk array has ended 16 } 17 xviii fclose ( fp ); nineteen } For testing the code I've used a simple dummy file, lorem.txt. This is a piece from the output of the above programme on my machine:
1 ~ $ clang -std=c17 -Wall -Wextra -pedantic t0.c -o t0 2 ~ $ ./t0 iii Lorem ipsum dolor sit amet, consectetur adipiscing elit. 4 |* 5 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. ten |* The code prints the content of the chunk array, equally filled after every call to fgets, and a mark string.
If you lookout man carefully, past scrolling the above text snippet to the right, you can see that the output was truncated to 127 characters per line of text. This was expected because our code tin can store an entire line from the original text file simply if the line can fit within our chunk assortment.
What if you need to have the unabridged 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 carve up line buffer until nosotros find the end of line character.
Let's start past creating a line buffer that will store the chunks of text, initially this volition have the same length as the chunk array:
1 #include <stdio.h> 2 #include <stdlib.h> iii #include <string.h> 4 5 int main ( void ) { 6 FILE * fp = fopen ( "lorem.txt" , "r" ); 7 // ... viii 9 char clamper [ 128 ]; x xi // Shop 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 memory for the line buffer." ); 16 exit ( 1 ); 17 } eighteen 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 string, until we find the cease of line graphic symbol. If necessary, we'll resize the line buffer:
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> iv v int main ( void ) { 6 // ... 7 eight // "Empty" the string 9 line [ 0 ] = '\0' ; ten 11 while ( fgets ( clamper , sizeof ( chunk ), fp ) != NULL ) { 12 // Resize the line buffer if necessary xiii size_t len_used = strlen ( line ); 14 size_t chunk_used = strlen ( clamper ); 15 xvi if ( len - len_used < chunk_used ) { 17 len *= two ; 18 if (( line = realloc ( line , len )) == Null ) { nineteen perror ( "Unable to reallocate memory for the line buffer." ); 20 costless ( line ); 21 exit ( 1 ); 22 } 23 } 24 25 // Copy the clamper to the terminate of the line buffer 26 strncpy ( line + len_used , chunk , len - len_used ); 27 len_used += chunk_used ; 28 29 // Cheque if line contains '\n', if yes procedure the line of text 30 if ( line [ len_used - 1 ] == '\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 complimentary ( line ); twoscore 41 printf ( " \due north\north Max line size: %zd \due north " , len ); 42 } Please annotation, that in the above code, every time the line buffer needs to be resized its capacity is doubled.
This is the consequence of running the above code on my machine. For brevity, I kept only the beginning 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. iv |* 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. 8 |* nine Aliquam erat volutpat. Mauris dignissim augue ac purus placerat scelerisque. Donec eleifend ut nibh eu elementum. 10 |* You lot can run across that, this time, we can print full lines of text and not fixed length chunks similar in the initial approach.
Allow's change the to a higher place code in order to print the line length instead of the bodily text:
1 // ... ii three int chief ( void ) { iv // ... 5 6 while ( fgets ( clamper , sizeof ( clamper ), fp ) != Nil ) { 7 8 // ... nine 10 // Check if line contains '\n', if yep procedure the line of text eleven if ( line [ len_used - i ] == '\n' ) { 12 printf ( "line length: %zd \n " , len_used ); 13 // "Empty" the line buffer 14 line [ 0 ] = '\0' ; 15 } 16 } 17 eighteen fclose ( fp ); 19 free ( line ); 20 21 printf ( " \northward\n Max line size: %zd \n " , len ); 22 } This is the issue of running the modified code on my machine:
1 ~ $ clang -std=c17 -Wall -Wextra -pedantic t1.c -o t1 2 ~ $ ./t1 iii line length: 57 4 line length: 136 5 line length: 147 6 line length: 114 seven line length: 112 8 line length: 95 9 line length: 62 10 line length: i eleven line length: 428 12 line length: i 13 line length: 460 xiv line length: 1 15 line length: 834 16 line length: 1 17 line length: 821 18 xix 20 Max line size: 1024 In the side by side example, I will prove you how to use the getline function available on POSIX systems like Linux, Unix and macOS. Microsoft Visual Studio doesn't have an equivalent office, and so you won't exist able to easily test this case on a Windows system. Withal, y'all should be able to test information technology if y'all are using Cygwin or Windows Subsystem for Linux.
one #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> four 5 int main ( void ) { half dozen FILE * fp = fopen ( "lorem.txt" , "r" ); 7 if ( fp == Aught ) { eight perror ( "Unable to open file!" ); ix go out ( ane ); 10 } 11 12 // Read lines using POSIX part getline 13 // This code won't work on Windows 14 char * line = Aught ; 15 size_t len = 0 ; xvi 17 while ( getline ( & line , & len , fp ) != - 1 ) { 18 printf ( "line length: %zd \n " , strlen ( line )); 19 } 20 21 printf ( " \northward\n Max line size: %zd \n " , len ); 22 23 fclose ( fp ); 24 free ( line ); // getline will resize the input buffer every bit necessary 25 // the user needs to free the retention when non needed! 26 } Please note, how unproblematic is to utilise POSIX's 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 function.
When you use getline, don't forget to gratuitous the line buffer when you don't need information technology anymore. Also, calling getline more than one time will overwrite the line buffer, make a copy of the line content if yous need to keep it for further processing.
This is the outcome of running the to a higher place getline example on a Linux machine:
1 ~ $ clang -std=gnu17 -Wall -Wextra -pedantic t2.c -o t2 2 ~ $ ./t2 three line length: 57 4 line length: 136 v line length: 147 vi line length: 114 vii line length: 112 8 line length: 95 9 line length: 62 10 line length: one 11 line length: 428 12 line length: 1 thirteen line length: 460 14 line length: ane xv line length: 834 sixteen line length: 1 17 line length: 821 eighteen xix 20 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 y'all run the same lawmaking on macOS the line buffer is resized to 1024 bytes. This is due to the different means in which getline is implemented on dissimilar Unix like systems.
Every bit mentioned before, getline is non present in the C standard library. It could be an interesting do to implement a portable version of this part. The thought here is non to implement the virtually performant version of getline, but rather to implement a simple replacement for non POSIX systems.
We are going to take the to a higher place instance and supervene upon the POSIX'due south getline version with our ain implementation, say my_getline. Apparently, if y'all are on a POSIX organization, you should utilize the version provided by the operating organisation, which was tested past countless users and tuned for optimal functioning.
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 also a POSIX defined blazon, usually 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 role using the same arroyo as in one of the in a higher place examples, where I've defined a line buffer and kept copying chunks of text in the buffer until we found the end of line graphic symbol:
1 // This will simply have event on Windows with MSVC 2 #ifdef _MSC_VER 3 #define _CRT_SECURE_NO_WARNINGS i four #define restrict __restrict 5
0 Response to "C Read Character Length of Line From File"
Post a Comment