How to write a file with C in Linux?

Writing Files in C on Linux: A Comprehensive Guide

Learn how to create, open, write to, and close files using standard C library functions in a Linux environment. This guide covers basic file I/O operations and error handling.

File I/O (Input/Output) is a fundamental aspect of programming, allowing applications to persist data beyond their execution lifetime. In C, especially within a Linux environment, file operations are performed using a set of standard library functions. This article will guide you through the process of writing data to a file, covering essential functions, error handling, and best practices.

Understanding File Pointers and Modes

Before you can write to a file, you need to open it. The fopen() function is used for this purpose, returning a FILE pointer, which acts as a handle to the opened file. This pointer is crucial for all subsequent file operations. When opening a file, you must specify a mode that dictates how the file will be accessed. For writing, common modes include:

• "w": Write mode. Creates an empty file for writing. If a file with the same name already exists, its contents are truncated (deleted). If the file does not exist, it is created.
• "a": Append mode. Opens a file for writing at the end of the file. If the file does not exist, it is created. Existing content is preserved.
• "w+": Write/Read mode. Creates an empty file for both writing and reading. If a file with the same name exists, its contents are truncated.
• "a+": Append/Read mode. Opens a file for both writing (at the end) and reading. If the file does not exist, it is created.

flowchart TD
    A[Start: Open File] --> B{File Exists?}
    B -->|Yes| C{Mode is 'w' or 'w+'?}
    C -->|Yes| D[Truncate File]
    C -->|No| E[Seek to End (for 'a' or 'a+')]
    B -->|No| F[Create New File]
    D --> G[Return FILE*]
    E --> G
    F --> G
    G --> H[Write Data]
    H --> I[Close File]
    I --> J[End]

File Opening and Writing Process Flow

Basic File Writing Operations

Once a file is successfully opened, you can use various functions to write data to it. The most common functions are fputc() for single characters, fputs() for strings, and fprintf() for formatted output, similar to printf().

It's vital to always check if fopen() returns NULL, which indicates an error (e.g., permission denied, invalid path). After all write operations are complete, the file must be closed using fclose() to flush any buffered data and release system resources.

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

int main() {
    FILE *filePointer;
    char *filename = "example.txt";
    char *textToWrite = "Hello, C file I/O on Linux!\n";
    char singleChar = 'A';

    // Open the file in write mode ("w")
    // If example.txt exists, its content will be truncated.
    // If it doesn't exist, it will be created.
    filePointer = fopen(filename, "w");

    // Check if file was opened successfully
    if (filePointer == NULL) {
        perror("Error opening file"); // Prints a system error message
        return EXIT_FAILURE;
    }

    // Write a string to the file
    if (fputs(textToWrite, filePointer) == EOF) {
        perror("Error writing string to file");
        fclose(filePointer);
        return EXIT_FAILURE;
    }

    // Write a single character to the file
    if (fputc(singleChar, filePointer) == EOF) {
        perror("Error writing character to file");
        fclose(filePointer);
        return EXIT_FAILURE;
    }

    // Write formatted data to the file
    int number = 123;
    double pi = 3.14159;
    if (fprintf(filePointer, "Number: %d, PI: %.2f\n", number, pi) < 0) {
        perror("Error writing formatted data to file");
        fclose(filePointer);
        return EXIT_FAILURE;
    }

    // Close the file
    if (fclose(filePointer) == EOF) {
        perror("Error closing file");
        return EXIT_FAILURE;
    }

    printf("Successfully wrote to %s\n", filename);

    return EXIT_SUCCESS;
}

Example C program demonstrating basic file writing with fputs(), fputc(), and fprintf().

Writing Binary Data with fwrite()

For writing raw binary data (e.g., structures, arrays of numbers) to a file, the fwrite() function is the most suitable. It writes a specified number of elements, each of a specified size, from a block of memory to the file. This is particularly useful when you need to store data in a format that can be directly read back into memory without parsing.

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

// Define a simple structure
typedef struct {
    int id;
    char name[20];
    float value;
} DataRecord;

int main() {
    FILE *filePointer;
    char *filename = "data.bin";
    DataRecord records[2] = {
        {1, "Record One", 10.5f},
        {2, "Record Two", 20.75f}
    };

    // Open the file in binary write mode ("wb")
    filePointer = fopen(filename, "wb");

    if (filePointer == NULL) {
        perror("Error opening binary file");
        return EXIT_FAILURE;
    }

    // Write the array of structures to the file
    // fwrite(ptr, size, count, stream)
    // ptr: Pointer to the array of structures
    // size: Size of each structure (sizeof(DataRecord))
    // count: Number of structures to write (2 in this case)
    // stream: The FILE pointer
    size_t elementsWritten = fwrite(records, sizeof(DataRecord), 2, filePointer);

    if (elementsWritten != 2) {
        perror("Error writing binary data");
        fclose(filePointer);
        return EXIT_FAILURE;
    }

    // Close the file
    if (fclose(filePointer) == EOF) {
        perror("Error closing binary file");
        return EXIT_FAILURE;
    }

    printf("Successfully wrote %zu records to %s\n", elementsWritten, filename);

    return EXIT_SUCCESS;
}

Example C program demonstrating writing binary data using fwrite().

Permissions and Error Handling

In Linux, file operations are heavily influenced by user permissions. If your program attempts to write to a file in a directory where the user does not have write permissions, fopen() will fail and return NULL. It's crucial to handle these errors gracefully.

Always check the return values of file I/O functions. fopen() returns NULL on failure. fputc() returns EOF on error. fputs() returns EOF on error. fprintf() returns a negative value on error. fwrite() returns the number of items successfully written, which should be compared against the expected count. fclose() returns EOF on error. Proper error handling prevents crashes and provides meaningful feedback to the user or system logs.

1. Include Headers

Start by including the necessary header files: <stdio.h> for file I/O functions and <stdlib.h> for EXIT_SUCCESS/EXIT_FAILURE and perror().

2. Declare File Pointer

Declare a FILE * variable to hold the file pointer returned by fopen().

3. Open the File

Use fopen("filename", "mode") to open the file. Choose the appropriate mode ("w", "a", "wb", etc.) based on your requirements. Always check if the returned pointer is NULL.

4. Write Data

Use fputc(), fputs(), fprintf(), or fwrite() to write your data. Remember to check their return values for errors.

5. Close the File

Call fclose(filePointer) to close the file, ensuring all buffered data is written and resources are released. Check for EOF on close.

6. Handle Errors

Implement robust error handling using perror() or strerror() to diagnose and report issues effectively.