C File Handling Guide: Basics to Advanced for Beginners

1. Introduction

The Importance of File Operations

• Saving log data Record program activity and error information for later analysis.
• Managing configuration files Store user-modifiable settings in an external file and read them when the program starts.
• Database-like usage Use files to store and manage small amounts of data.

Purpose of This Article

Intended Audience

• Beginners who have started learning C
• People who want to understand the basics of file operations
• Those who anticipate needing to save and read/write data in programs

2. Basic Concepts of File Operations

What Is a File?

1. Text File

• A file that records data in a format easy for humans to read.
• Examples: .txt, .csv, etc.
• Text files can store characters, numbers, and symbols line by line.

1. Binary File

• A file that records data in a format that is easy for computers to process.
• Examples: .bin, .dat, image files (e.g., .jpg, .png), etc.
• Binary files can store not only text but also numbers, image data, and various other types of information.

Differences Between Text Files and Binary Files

Preparations Needed for File Operations in C

Standard Header File <stdio.h>

• fopen: Open a file.
• fclose: Close a file.
• fprintf: Write to a file.
• fscanf: Read from a file.
• fread / fwrite: Handle binary data.

File Pointer

FILE *fp;

File Modes

Summary

3. File Opening and Closing

Opening a File: fopen Function

FILE *fopen(const char *filename, const char *mode);

Parameter Description

• filename: Specify the file name as a string. Example: "example.txt"
• mode: The mode that determines how the file is handled. Example: "r" (read‑only), "w" (write‑only), etc.

Return Value

• If the file is opened successfully, a pointer of type FILE is returned.
• If the file cannot be opened, NULL is returned. In this case, you need to handle the error.

Basic Example: Opening a File

#include <stdio.h>

int main() {
    FILE *file;

    // Open the file
    file = fopen("example.txt", "r");

    // Check whether the file was opened successfully
    if (file == NULL) {
        printf("Failed to open the file.\n");
        return 1;
    }

    printf("File opened successfully.\n");

    // Close the file
    fclose(file);

    return 0;
}

• If the file cannot be opened, display an error message and terminate the program.
• When file operations are finished, always close the file with the fclose function.

File Mode Types

Closing a File: fclose Function

• Memory leaks (file pointer not released)
• Data not being fully written
• Wasted system resources

Basic Syntax

int fclose(FILE *stream);

Return Value

• Returns 0 if the file is closed successfully.
• Returns EOF if an error occurs.

Example: Closing a File

#include <stdio.h>

int main() {
    FILE *file;

    // Open the file
    file = fopen("example.txt", "r");
    if (file == NULL) {
        printf("Failed to open the file.\n");
        return 1;
    }

    // File operations (omitted)

    // Close the file
    if (fclose(file) == 0) {
        printf("File closed successfully.\n");
    } else {
        printf("An error occurred while closing the file.\n");
    }

    return 0;
}

• By checking the return value of fclose, you can determine whether the file was closed successfully.

Importance of Error Checking

Common Error Causes

• The specified file does not exist (in "r" mode)
• Lack of write permission
• Incorrect file name

Example of Error Handling

if (file == NULL) {
    perror("File open error");
    return 1;
}

Summary

• Use the fopen function to open a file and the fclose function to close it.
• Specify the correct file mode and choose the mode appropriate for the intended operations.
• Adding error handling improves the safety and reliability of file operations.

4. Writing to Files

Basics of File Writing

1. Open the file (using the fopen function). When writing, specify the mode "w" (write-only) or "a" (append-only).
2. Use a write function to save data to the file.
3. After writing is finished, close the file using the fclose function.

Types of Write Functions

1. fprintf Function

int fprintf(FILE *stream, const char *format, ...);

• stream: File pointer to write to.
• format: Format string (e.g., %d, %s, etc.).
• Return value: Returns the number of characters successfully written.

#include <stdio.h>

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

    fprintf(file, "Name: %s\nAge: %d", "Yamada Taro", 25);
    fclose(file);

    printf("Data was written successfully.\n");
    return 0;
}

2. fputs Function

int fputs(const char *str, FILE *stream);

• str: String to write.
• stream: File pointer to write to.
• Return value: Returns a non-zero value on success, EOF on failure.

#include <stdio.h>

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

    fputs("Hello, World!\n", file);
    fclose(file);

    printf("String was written successfully.\n");
    return 0;
}

3. fputc Function

int fputc(int char, FILE *stream);

• char: Character to write (specified as an ASCII value).
• stream: File pointer to write to.
• Return value: Returns the written character on success, EOF on failure.

#include <stdio.h>

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

    fputc('H', file);
    fputc('e', file);
    fputc('l', file);
    fputc('l', file);
    fputc('o', file);
    fclose(file);

    printf("Character(s) were written successfully.\n");
    return 0;
}

File Modes and Writing

1. "w" mode

• If the file does not exist, it is created.
• If the file exists, existing data is overwritten.

1. "a" mode

• If the file does not exist, it is created.
• If the file exists, existing data is retained and new data is appended at the end.

Note: Handling Write Errors

if (fprintf(file, "Test data\n") < 0) {
    printf("An error occurred while writing.\n");
}

Practical Example: Simple Log File Creation Program

#include <stdio.h>
#include <time.h>

int main() {
    FILE *file = fopen("log.txt", "a");
    if (file == NULL) {
        printf("Failed to open the log file.\n");
        return 1;
    }

    time_t now = time(NULL);
    fprintf(file, "Log entry: %s", ctime(&now));

    fclose(file);
    printf("Log was recorded successfully.\n");
    return 0;
}

Summary

• To write to files, use functions such as fprintf, fputs, and fputc.
• Specify the file mode ("w" or "a") appropriately to achieve the desired behavior.
• Add error handling to improve the safety of file operations.

5. Reading from Files

Basic File Reading

1. Open the file (using the fopen function) For reading, specify the mode "r" (read‑only).
2. Use a reading function to obtain the data.
3. When reading is finished, close the file with the fclose function.

Types of Reading Functions

1. fscanf function

int fscanf(FILE *stream, const char *format, ...);

• stream: the file pointer to read from.
• format: the input format (e.g., %d, %s).
• Return value: the number of items successfully read; on failure, EOF is returned.

#include <stdio.h>

int main() {
    FILE *file = fopen("data.txt", "r");
    if (file == NULL) {
        printf("Failed to open file.\n");
        return 1;
    }

    char name[50];
    int age;

    fscanf(file, "%s %d", name, &age);
    printf("Name: %s, Age: %d\n", name, age);

    fclose(file);
    return 0;
}

2. fgets function

char *fgets(char *str, int n, FILE *stream);

• str: array to store the read data.
• n: maximum number of characters to read (no more than the size of str).
• stream: the file pointer to read from.
• Return value: returns str on success; returns NULL on failure or EOF.

#include <stdio.h>

int main() {
    FILE *file = fopen("data.txt", "r");
    if (file == NULL) {
        printf("Failed to open file.\n");
        return 1;
    }

    char line[100];

    while (fgets(line, sizeof(line), file) != NULL) {
        printf("%s", line);
    }

    fclose(file);
    return 0;
}

3. fgetc function

int fgetc(FILE *stream);

• stream: the file pointer to read from.
• Return value: returns the read character (its ASCII value); on failure or EOF, EOF is returned.

#include <stdio.h>

int main() {
    FILE *file = fopen("data.txt", "r");
    if (file == NULL) {
        printf("Failed to open file.\n");
        return 1;
    }

    int c;
    while ((c = fgetc(file)) != EOF) {
        putchar(c);
    }

    fclose(file);
    return 0;
}

Handling EOF (End Of File)

int c;
while ((c = fgetc(file)) != EOF) {
    putchar(c);
}

• EOF is typically defined as -1, but you should compare against EOF in your code.

Practical Example: Reading a Configuration File

username admin
password 12345

#include <stdio.h>

int main() {
    FILE *file = fopen("config.txt", "r");
    if (file == NULL) {
        printf("Failed to open config file.\n");
        return 1;
    }

    char key[50], value[50];
    while (fscanf(file, "%s %s", key, value) != EOF) {
        printf("%s: %s\n", key, value);
    }

    fclose(file);
    return 0;
}

username: admin
password: 12345

Summary

• Use fscanf, fgets, fgetc, and other functions as appropriate for the type of file reading you need.
• When reading a file, checking EOF is essential for correct data processing.
• These techniques can be applied to reading configuration files, log files, and other practical uses.

6. Binary File Operations

What is a Binary File?

1. Efficient data storage In binary format, data is stored as‑is, allowing more efficient storage than text formats.
2. High versatility Used for image files, audio files, compressed files, and many other formats.
3. Not human‑readable Opening the saved data directly in a text editor often results in garbled characters.

Main Functions for Manipulating Binary Files

1. fread Function

size_t fread(void *ptr, size_t size, size_t count, FILE *stream);

• ptr: pointer to store the data read.
• size: size of each element (in bytes).
• count: number of elements to read.
• stream: file pointer to read from.

2. fwrite Function

size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream);

• ptr: pointer to the data to write.
• size: size of each element (in bytes).
• count: number of elements to write.
• stream: file pointer to write to.

Opening Files in Binary Mode

• "rb": binary read‑only.
• "wb": binary write‑only.
• "ab": binary append‑only.

Example: Saving Numeric Data in Binary Format

Program to Write Data

#include <stdio.h>

int main() {
    FILE *file = fopen("data.bin", "wb");
    if (file == NULL) {
        printf("Failed to open file.\n");
        return 1;
    }

    int numbers[] = {1, 2, 3, 4, 5};
    size_t size = sizeof(numbers) / sizeof(numbers[0]);

    fwrite(numbers, sizeof(int), size, file);

    fclose(file);
    printf("Data saved in binary format.\n");
    return 0;
}

Program to Read Data

#include <stdio.h>

int main() {
    FILE *file = fopen("data.bin", "rb");
    if (file == NULL) {
        printf("Failed to open file.\n");
        return 1;
    }

    int numbers[5];
    fread(numbers, sizeof(int), 5, file);

    printf("Read data: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }

    fclose(file);
    return 0;
}

Read data: 1 2 3 4 5

Cautions for Binary File Operations

1. Matching data sizes When using fread or fwrite, it is crucial to specify the correct size. Incorrect sizes cause read/write failures.
2. Error checking If an error occurs during file operations, you can use ferror to check the error state.
3. Data portability Files saved in binary format may not be compatible across different platforms. Pay special attention to endianness (big‑endian vs little‑endian).

Practical Example: Saving and Loading Struct Data

Program to Save a Struct

#include <stdio.h>

typedef struct {
    char name[50];
    int age;
    float salary;
} Employee;

int main() {
    FILE *file = fopen("employee.bin", "wb");
    if (file == NULL) {
        printf("Failed to open file.\n");
        return 1;
    }

    Employee emp = {"John Doe", 30, 450000.0};
    fwrite(&emp, sizeof(Employee), 1, file);

    fclose(file);
    printf("Employee data saved.\n");
    return 0;
}

Program to Read a Struct

#include <stdio.h>

typedef struct {
    char name[50];
    int age;
    float salary;
} Employee;

int main() {
    FILE *file = fopen("employee.bin", "rb");
    if (file == NULL) {
        printf("Failed to open file.\n");
        return 1;
    }

    Employee emp;
    fread(&emp, sizeof(Employee), 1, file);

    printf("Name: %s\nAge: %d\nSalary: %.2f\n", emp.name, emp.age, emp.salary);

    fclose(file);
    return 0;
}

Name: John Doe
Age: 30
Salary: 450000.00

Summary

• Binary files allow efficient data storage and can be manipulated using fread and fwrite.
• Open files in binary mode by specifying "b" in the file mode.
• Pay attention to data sizes and error checking to ensure accurate file operations.

7. Error Handling

Common Errors in File Operations

1. Unable to open file

• Cause: The file does not exist, the path is incorrect, or you lack permissions.
• Solution: Check the return value of fopen and handle the error.

1. Write or read error

• Cause: Insufficient disk space or the file is read‑only.
• Solution: Check for errors after write/read operations.

1. Reached end of file (EOF)

• Cause: The file has been read to the end.
• Solution: Handle EOF correctly.

1. Improper use of file pointer

• Cause: The file pointer is invalid or has been closed.
• Solution: Check whether the pointer is NULL.

Basic Methods for Error Detection

1. Check the return value of fopen

FILE *file = fopen("nonexistent.txt", "r");
if (file == NULL) {
    perror("File open error");
    return 1;
}

• perror prints a detailed description of the most recent error.

2. Checking for write/read errors

size_t written = fwrite(data, sizeof(int), 5, file);
if (written < 5) {
    printf("Data write error occurred.\n");
}

size_t read = fread(data, sizeof(int), 5, file);
if (read < 5) {
    if (feof(file)) {
        printf("Reached end of file.\n");
    } else if (ferror(file)) {
        printf("An error occurred while reading.\n");
    }
}

3. Using feof and ferror functions

• feof function The feof function checks whether the end of the file has been reached. Return value: non‑zero if the end has been reached.
• ferror function The ferror function checks whether an error occurred during a file operation. Return value: non‑zero if an error has occurred.

int c;
while ((c = fgetc(file)) != EOF) {
    putchar(c);
}

if (feof(file)) {
    printf("Reached end of file.\n");
} else if (ferror(file)) {
    printf("An error occurred while reading the file.\n");
}

Best Practices for Error Handling

1. Perform error handling early Detect errors when opening the file so they don’t affect subsequent processing.
2. Display detailed error messages Clearly convey the error so users and developers can identify the problem.
3. Ensure resources are released Even if an error occurs, properly close any open files.

FILE *file = fopen("example.txt", "r");
if (file == NULL) {
    perror("File open error");
    return 1;
}

// File operations (omitted)

if (fclose(file) != 0) {
    printf("File close error occurred.\n");
}

Practical Example: Safe File Reading Program

#include <stdio.h>

int main() {
    FILE *file = fopen("data.txt", "r");
    if (file == NULL) {
        perror("File open error");
        return 1;
    }

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

    if (feof(file)) {
        printf("\nFile read successfully.\n");
    } else if (ferror(file)) {
        printf("\nAn error occurred while reading.\n");
    }

    fclose(file);
    return 0;
}

Summary

• Detect errors during file operations by checking the return values of functions such as fopen, fwrite, and fread.
• Use feof and ferror to examine the file’s state in detail.
• Implementing proper error handling improves the reliability and stability of your program.

8. Advanced

Simultaneous Operations on Multiple Files

Example: Simultaneous Log and Error File Operations

#include <stdio.h>

int main() {
    FILE *logFile = fopen("log.txt", "w");
    FILE *errorFile = fopen("error.txt", "w");

    if (logFile == NULL || errorFile == NULL) {
        printf("Failed to open file.\n");
        return 1;
    }

    fprintf(logFile, "Log: Program executed successfully.\n");
    fprintf(errorFile, "Error: Unexpected input detected.\n");

    fclose(logFile);
    fclose(errorFile);

    printf("Log and error have been recorded.\n");
    return 0;
}

• Use multiple FILE pointers to store data for different purposes in separate files.
• Ensure that all opened files are properly closed.

Using Temporary Files

Creating a Temporary File with the tmpfile Function

#include <stdio.h>

int main() {
    FILE *tempFile = tmpfile();
    if (tempFile == NULL) {
        printf("Failed to create temporary file.\n");
        return 1;
    }

    fprintf(tempFile, "This data is stored temporarily.\n");

    // Read the contents of the temporary file
    rewind(tempFile);
    char buffer[100];
    fgets(buffer, sizeof(buffer), tempFile);
    printf("Temporary file contents: %s", buffer);

    // The temporary file is automatically deleted
    fclose(tempFile);

    return 0;
}

• If you need to reuse the temporary file’s contents, use rewind to reset the file pointer to the beginning.
• The file is automatically deleted when the program ends, so manual deletion is unnecessary.

Renaming and Deleting Files

rename Function: Changing a File Name

int rename(const char *oldname, const char *newname);

• oldname: The original file name.
• <codenewname< code=””>: The new file name.</codenewname<>
• Return value: Returns 0 on success, non‑zero on failure.

#include <stdio.h>

int main() {
    if (rename("oldfile.txt", "newfile.txt") == 0) {
        printf("File name changed successfully.\n");
    } else {
        printf("Failed to change file name.\n");
    }

    return 0;
}

remove Function: Deleting a File

int remove(const char *filename);

• filename: The name of the file to delete.
• Return value: Returns 0 on success, non‑zero on failure.

#include <stdio.h>

int main() {
    if (remove("unnecessary.txt") == 0) {
        printf("File deleted successfully.\n");
    } else {
        printf("Failed to delete file.\n");
    }

    return 0;
}

• It is recommended to verify that the file exists before attempting to rename or delete it.
• If deletion or renaming fails, investigate the cause of the error.

Practical Example: File Management Tool

#include <stdio.h>

int main() {
    // Rename the file
    if (rename("tempfile.txt", "finalfile.txt") == 0) {
        printf("File name changed to 'finalfile.txt'.\n");
    } else {
        printf("Failed to change file name.\n");
    }

    // Delete the file
    if (remove("finalfile.txt") == 0) {
        printf("File 'finalfile.txt' deleted.\n");
    } else {
        printf("Failed to delete file.\n");
    }

    return 0;
}

Summary

• Operating on multiple files simultaneously enables the construction of complex programs.
• Using temporary files improves security and efficiency.
• Using rename and remove makes file management straightforward.

9. FAQ (Frequently Asked Questions)

Q1: What are the reasons the fopen function cannot open a file?

1. The file does not exist (when using "r" mode).
2. The file path is incorrect.
3. Insufficient read or write permissions.
4. Insufficient disk space.

• Check the file name and path.
• If the file does not exist, create it using "w" or "a" mode.
• Verify the file permissions and grant appropriate rights.

Q2: What is the difference between "w" mode and "a" mode?

• "w" mode (write‑only)
• If the file exists, its contents are completely erased.
• If the file does not exist, it is created.
• "a" mode (append‑only)
• If the file exists, existing content is preserved and new data is appended to the end.
• If the file does not exist, it is created.

Q3: What is the difference between text files and binary files?

Q4: How should you handle errors that occur during file operations?

1. Check the file pointer: Ensure that fopen does not return NULL when opening the file.
2. Display error messages: Use the perror function to show detailed error information.
3. Use ferror and feof: When an error occurs during reading or writing, check the status with these functions.

Q5: What happens if you don’t close a file?

• Data may not be saved correctly.
• Leaving an opened file unclosed can cause memory leaks and resource exhaustion.
• Especially when a program opens many files, unclosed files increase system load.

• Always use the fclose function and add error handling.

Q6: What should you watch out for when reading and writing binary files?

• Data size: Accurately specify the data size in fread and fwrite.
• Endian differences: When using binary files across different platforms, be aware of endian differences (big‑endian vs little‑endian).
• Data integrity: Open and close files properly to avoid data loss.

Q7: What is EOF (End Of File)?

• fgetc
• fgets
• fscanf

int c;
while ((c = fgetc(file)) != EOF) {
    putchar(c);
}

Q8: How can you efficiently learn file handling in C?

• Learn the fundamentals thoroughly: Master the basic functions such as fopen, fclose, fprintf, and fscanf.
• Practical projects: Work on small projects like saving log files or creating simple databases to deepen your understanding.

Summary

• The FAQ section comprehensively covered common questions about C file handling.
• Learn practical knowledge from basic operations to error handling.
• If you have questions, first consult the documentation or references.

10. Summary

Recap of Key Points

1. Basic Concepts

• Files are classified as text or binary formats, each serving different purposes.
• When performing file operations in C, you use the <stdio.h> header file.

2. Basics of File Operations

• Use the fopen function to open a file and select an appropriate mode (e.g., "r", "w").
• After opening a file, you must always close it with the fclose function.

3. Writing and Reading

• Writing uses functions such as fprintf or fputs to save data.
• Reading uses fscanf or fgets to retrieve data from a file.

4. Binary File Operations

• For binary files, use fread and fwrite to efficiently read and write data.
• By saving and loading structs, you can handle complex data structures.

5. Error Handling

• Consider the possibility of errors during file operations and add error handling using ferror or feof.

6. Advanced Operations

• By mastering advanced techniques such as simultaneous handling of multiple files, using temporary files, and renaming or deleting files, you can build more practical programs.

Advice for the Next Steps

1. CSV and JSON File Handling

• Create parsers appropriate for the file format and implement data reading and writing.
• Example: Save student grade data to a CSV file, then read and analyze it.

1. Strengthening Error Handling

• Build a logging system to record errors during file operations, improving program reliability.

1. File Handling in Multithreaded Environments

• Learn how to safely manipulate files from multiple threads.

1. Project Development Using File Handling

• Develop practical programs to deepen your file handling skills.
• Examples: simple databases, configuration management tools, log collection programs, etc.

Conclusion