Reading a File Line by Line in C

In this tutorial, we will cover how to read a file line by line in C. This is a fundamental task that many programs need to perform, and it can be achieved using various methods.

Introduction to Reading Files in C

To read a file in C, you first need to open the file using the fopen() function, which returns a FILE pointer. Once the file is open, you can use various functions such as getc(), fgets(), and getline() to read its contents.

Using fgets()

One of the most common methods for reading a file line by line in C is to use the fgets() function. This function reads characters from the stream until it encounters a newline character or reaches the specified buffer size.

Here’s an example code snippet that demonstrates how to use fgets():

#include <stdio.h>
#include <string.h>

#define MAX_LEN 256

int main(void) {
    FILE *fp;
    fp = fopen("file.txt", "r");
    if (fp == NULL) {
        perror("Failed: ");
        return 1;
    }

    char buffer[MAX_LEN];
    while (fgets(buffer, MAX_LEN, fp)) {
        // Remove trailing newline
        buffer[strcspn(buffer, "\n")] = 0;
        printf("%s\n", buffer);
    }

    fclose(fp);
    return 0;
}

Using getline()

Another method for reading a file line by line is to use the getline() function. This function dynamically allocates memory for the input line and allows you to specify the initial size of the buffer.

Here’s an example code snippet that demonstrates how to use getline():

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    FILE *fp;
    char *line = NULL;
    size_t len = 0;
    ssize_t read;

    fp = fopen("/etc/motd", "r");
    if (fp == NULL)
        exit(EXIT_FAILURE);

    while ((read = getline(&line, &len, fp)) != -1) {
        printf("Retrieved line of length %zu:\n", read);
        printf("%s", line);
    }

    fclose(fp);
    if (line)
        free(line);
    exit(EXIT_SUCCESS);
}

Manual Implementation

If you need more control over the reading process or want to implement your own readLine() function, you can use a manual approach with getc(). However, this method requires careful handling of memory allocation and deallocation.

Here’s an example code snippet that demonstrates how to manually read a file line by line:

#include <stdio.h>
#include <stdlib.h>

char *readLine(FILE *file) {
    int maximumLineLength = 128;
    char *lineBuffer = malloc(sizeof(char) * maximumLineLength);

    if (lineBuffer == NULL) {
        printf("Error allocating memory for line buffer.");
        exit(1);
    }

    char ch = getc(file);
    int count = 0;

    while ((ch != '\n') && (ch != EOF)) {
        if (count == maximumLineLength) {
            maximumLineLength += 128;
            lineBuffer = realloc(lineBuffer, maximumLineLength);
            if (lineBuffer == NULL) {
                printf("Error reallocating space for line buffer.");
                exit(1);
            }
        }
        lineBuffer[count] = ch;
        count++;

        ch = getc(file);
    }

    lineBuffer[count] = '\0';
    return lineBuffer;
}

int main(void) {
    FILE *filePointer = fopen("file.txt", "r");
    if (filePointer == NULL) {
        printf("Error opening file.");
        exit(1);
    }

    char *line;
    while ((line = readLine(filePointer)) != NULL) {
        printf("%s\n", line);
        free(line);
    }

    fclose(filePointer);
    return 0;
}

Conclusion

In conclusion, reading a file line by line in C can be achieved using various methods such as fgets(), getline(), or manual implementation. Each method has its own strengths and weaknesses, and the choice of which one to use depends on your specific requirements.

When working with files, it’s essential to remember to check for errors, close the file when you’re done with it, and free any allocated memory to prevent leaks.