C Programming File handling

by
Prev Topic: C Unions
Next Topic: C Advanced Topics

File handling in C programming enables programs to read from and write to files, allowing persistent data storage and retrieval. It is essential for applications like data processing, logging, and configuration management. In this article, we’ll explore file handling in depth, covering file operations, modes, reading, writing, error handling, and advanced techniques, with detailed examples for each concept.

Example: Basic File Handling in C

#include <stdio.h>

int main() {
    // Open a file for writing
    FILE *file = fopen("example.txt", "w");
    if (file == NULL) {
        printf("Error opening file!\n");
        return 1;
    }

    // Write to the file
    fprintf(file, "Hello, File Handling!\n");

    // Close the file
    fclose(file);
    printf("Data written to file successfully.\n");

    return 0; // Indicate successful execution
}

Output:

Data written to file successfully.

Note: This creates a file named “example.txt” with the text “Hello, File Handling!”

What Is File Handling in C?

File handling in C allows programs to interact with files on a storage device, such as reading data from a file or writing data to it. Files are managed using the FILE pointer, defined in the stdio.h library, which provides functions like fopen, fclose, fprintf, and fscanf. File handling is crucial for persistent data storage, configuration files, and data exchange.

Key characteristics of file handling include:

  • File Pointer: A FILE* pointer manages file operations.
  • File Modes: Specify the operation type (e.g., read, write, append).
  • Stream-Based: Files are treated as streams of data, processed sequentially or randomly.

File handling integrates with pointers (see C Pointers), structures (see C Structures), and control structures (see C Control Structures).

Core Concepts of File Handling

File handling in C involves several key concepts, each critical for effective file operations. We’ll cover these in detail.

1. Opening and Closing Files

Files are opened using fopen and closed using fclose. The fopen function takes a filename and mode, returning a FILE* pointer.

  • Opening: FILE *file = fopen("data.txt", "r"); – Opens “data.txt” for reading.
  • Closing: fclose(file); – Closes the file, freeing resources.
  • Check for NULL: Always verify fopen returns a valid pointer to avoid errors.
#include <stdio.h>

int main() {
    FILE *file = fopen("test.txt", "w");
    if (file == NULL) {
        printf("Failed to open file.\n");
        return 1;
    }
    fprintf(file, "Test data\n");
    fclose(file);
    printf("File written and closed.\n");

    return 0;
}

Output:

File written and closed.

2. File Modes

File modes specify the operation type when opening a file. Common modes include:

Mode Description
r Read mode (file must exist)
w Write mode (creates or overwrites file)
a Append mode (adds to end of file)
r+ Read and write (file must exist)
w+ Read and write (creates or overwrites file)
a+ Read and append (adds to end, allows reading)
rb, wb, etc. Binary mode variants (e.g., for images or binary data) 
#include <stdio.h>

int main() {
    FILE *file = fopen("append.txt", "a");
    if (file == NULL) {
        printf("Error opening file.\n");
        return 1;
    }
    fprintf(file, "Appended line\n");
    fclose(file);
    printf("Data appended to file.\n");

    return 0;
}

Output:

Data appended to file.

3. Writing to Files

Writing to files is done using functions like fprintf, fputs, or fwrite.

  • Formatted Writing: fprintf(file, "Value: %d", num); – Writes formatted data.
  • String Writing: fputs("text", file); – Writes a string.
  • Binary Writing: fwrite(&data, sizeof(data), 1, file); – Writes binary data.
#include <stdio.h>

int main() {
    FILE *file = fopen("output.txt", "w");
    if (file == NULL) {
        printf("Error opening file.\n");
        return 1;
    }

    int num = 123;
    fputs("Sample text\n", file);
    fprintf(file, "Number: %d\n", num);
    fclose(file);
    printf("Data written to file.\n");

    return 0;
}

Output:

Data written to file.

4. Reading from Files

Reading from files is done using functions like fscanf, fgets, or fread.

  • Formatted Reading: fscanf(file, "%d", &num); – Reads formatted data.
  • String Reading: fgets(buffer, size, file); – Reads a line or specified bytes.
  • Binary Reading: fread(&data, sizeof(data), 1, file); – Reads binary data.
#include <stdio.h>

int main() {
    FILE *file = fopen("output.txt", "r");
    if (file == NULL) {
        printf("Error opening file.\n");
        return 1;
    }

    char buffer[100];
    while (fgets(buffer, sizeof(buffer), file) != NULL) {
        printf("%s", buffer);
    }
    fclose(file);

    return 0;
}

Output (assuming output.txt from previous example):

Sample text
Number: 123

5. Error Handling in File Operations

File operations can fail due to issues like missing files or permissions. Functions like ferror and feof help detect errors and end-of-file conditions.

  • Check fopen: Verify the file pointer is not NULL.
  • End-of-File: Use feof(file) to detect the end of a file.
  • Error Detection: Use ferror(file) to check for errors during operations.
#include <stdio.h>

int main() {
    FILE *file = fopen("nonexistent.txt", "r");
    if (file == NULL) {
        printf("Error: File does not exist.\n");
        return 1;
    }

    int num;
    while (!feof(file)) {
        if (fscanf(file, "%d", &num) == 1) {
            printf("Read: %d\n", num);
        }
        if (ferror(file)) {
            printf("Error reading file.\n");
            break;
        }
    }
    fclose(file);

    return 0;
}

Output:

Error: File does not exist.

6. Binary File Handling

Binary files store data in raw format, suitable for structures, images, or custom data. Use rb, wb, or r+b modes with fread and fwrite.

#include <stdio.h>

struct Record {
    int id;
    char name[20];
};

int main() {
    struct Record rec = {1, "Alice"};
    FILE *file = fopen("records.bin", "wb");
    if (file == NULL) {
        printf("Error opening file.\n");
        return 1;
    }

    fwrite(&rec, sizeof(struct Record), 1, file);
    fclose(file);
    printf("Binary data written.\n");

    return 0;
}

Output:

Binary data written.

7. Random Access in Files

Random access allows reading or writing at specific positions using fseek, ftell, and rewind.

  • Move Position: fseek(file, offset, origin); – Sets file position.
  • Get Position: ftell(file); – Returns current position.
  • Reset Position: rewind(file); – Moves to the beginning.
#include <stdio.h>

int main() {
    FILE *file = fopen("random.txt", "w+");
    if (file == NULL) {
        printf("Error opening file.\n");
        return 1;
    }

    fprintf(file, "Random Access Example");
    fseek(file, 7, SEEK_SET); // Move to "Access"
    char buffer[20];
    fgets(buffer, sizeof(buffer), file);
    printf("Read from position 7: %s\n", buffer);
    fclose(file);

    return 0;
}

Output:

Read from position 7: Access Example

8. File Handling with Structures

Structures can be stored in and read from files, often in binary format, to manage complex data like records.

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

struct Student {
    int id;
    char name[20];
};

int main() {
    struct Student s1 = {101, "Bob"};
    FILE *file = fopen("students.bin", "wb");
    if (file == NULL) {
        printf("Error opening file.\n");
        return 1;
    }

    fwrite(&s1, sizeof(struct Student), 1, file);
    fclose(file);

    file = fopen("students.bin", "rb");
    if (file == NULL) {
        printf("Error opening file.\n");
        return 1;
    }

    struct Student s2;
    fread(&s2, sizeof(struct Student), 1, file);
    printf("Read: ID=%d, Name=%s\n", s2.id, s2.name);
    fclose(file);

    return 0;
}

Output:

Read: ID=101, Name=Bob

9. File Position and EOF Handling

Properly handling the end-of-file (EOF) and file position ensures robust file operations.

#include <stdio.h>

int main() {
    FILE *file = fopen("output.txt", "r");
    if (file == NULL) {
        printf("Error opening file.\n");
        return 1;
    }

    printf("File position: %ld\n", ftell(file));
    char ch;
    while ((ch = fgetc(file)) != EOF) {
        putchar(ch);
    }
    printf("\nEnd of file reached: %d\n", feof(file));
    fclose(file);

    return 0;
}

Output (assuming output.txt from earlier):

File position: 0
Sample text
Number: 123
End of file reached: 1

Why Is File Handling Important?

File handling is critical for the following reasons:

  1. Data Persistence: Enables storing data beyond program execution.
  2. Data Processing: Supports reading and processing large datasets.
  3. Configuration Management: Allows reading settings from files.
  4. Interoperability: Facilitates data exchange between programs via files.

Tips for File Handling

  • Check File Pointer: Always verify fopen returns a non-NULL pointer.
  • Close Files: Use fclose to free resources and avoid memory leaks.
  • Use Appropriate Modes: Choose the correct file mode (e.g., r, w, rb) for the task.
  • Handle Errors: Use ferror and feof to detect issues during file operations.
  • Add Comments: Document file operations with comments (see C Comments).
  • Use Binary for Structures: Prefer binary mode for storing structures to maintain data integrity.

Example: Comprehensive File Handling Program

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

typedef struct {
    int id;
    char name[20];
    float gpa;
} Student;

// Function to write student records to a binary file
void write_student(FILE *file, Student *s) {
    fwrite(s, sizeof(Student), 1, file);
}

// Function to read and print student records from a binary file
void read_students(FILE *file, int num_records) {
    Student s;
    rewind(file);
    for (int i = 0; i < num_records; i++) {
        if (fread(&s, sizeof(Student), 1, file) == 1) {
            printf("Student %d: ID=%d, Name=%s, GPA=%.2f\n",
                   i + 1, s.id, s.name, s.gpa);
        }
    }
}

int main() {
    Student students[] = {
        {101, "Alice", 3.9},
        {102, "Bob", 3.7}
    };
    int num_students = 2;

    // Write to binary file
    FILE *file = fopen("students.bin", "wb");
    if (file == NULL) {
        printf("Error opening file for writing.\n");
        return 1;
    }

    for (int i = 0; i < num_students; i++) {
        write_student(file, &students[i]);
    }
    fclose(file);

    // Read from binary file
    file = fopen("students.bin", "rb");
    if (file == NULL) {
        printf("Error opening file for reading.\n");
        return 1;
    }

    read_students(file, num_students);
    fclose(file);

    return 0;
}

Output:

Student 1: ID=101, Name=Alice, GPA=3.90
Student 2: ID=102, Name=Bob, GPA=3.70

This example demonstrates writing and reading an array of structures to/from a binary file, using functions, error handling, and proper file management.

Did You Know?

  • File handling in C is built on the standard I/O library (stdio.h), introduced in early C standards.
  • Binary files are platform-dependent, so structures written on one system may not be portable to another due to padding or endianness.
  • File handling is critical for applications like databases, where records are stored and retrieved efficiently.
Prev Topic: C Unions
Next Topic: C Advanced Topics

Leave a comment