Introduction

C provides robust mechanisms for writing data to files. Two fundamental functions for this purpose are fwrite and fprintf. Understanding these functions is crucial for tasks such as data logging, saving program state, creating configuration files, and more. fwrite is primarily used for writing binary data, while fprintf is used for writing formatted text data. This document will provide a detailed explanation and practical examples of how to use these functions effectively.

fwrite: Writing Binary Data

Explanation

The fwrite function writes a block of data to a file stream. It's designed for writing raw binary data and is very efficient for this purpose.

Syntax

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

• ptr: A pointer to the data to be written.
• size: The size of each element to be written, in bytes.
• count: The number of elements to be written.
• stream: A pointer to the FILE object representing the output stream.

Return Value

fwrite returns the number of elements successfully written. This value might be less than count if an error occurred. You should always check the return value to ensure that the write operation was successful.

Example 1: Writing an Integer Array

This example demonstrates how to write an array of integers to a binary file.

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

int main() {
    int data[] = {10, 20, 30, 40, 50};
    int num_elements = sizeof(data) / sizeof(data[0]);
    FILE *fp;

    fp = fopen("integers.bin", "wb"); // Open in binary write mode

    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    size_t elements_written = fwrite(data, sizeof(int), num_elements, fp);

    if (elements_written != num_elements) {
        fprintf(stderr, "Error writing to file.  %zu elements written.\n", elements_written);
    } else {
        printf("Successfully wrote %zu elements to integers.bin\n", elements_written);
    }

    fclose(fp);
    return 0;
} 

Example 2: Writing a Structure

This example shows how to write a structure to a binary file.

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

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

int main() {
    Employee emp = {123, "John Doe", 50000.00};
    FILE *fp;

    fp = fopen("employee.bin", "wb");

    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    size_t elements_written = fwrite(&emp, sizeof(Employee), 1, fp);

    if (elements_written != 1) {
        fprintf(stderr, "Error writing to file.\n");
    } else {
        printf("Successfully wrote employee data to employee.bin\n");
    }

    fclose(fp);
    return 0;
} 

Important Considerations for fwrite

• Binary Mode: Always open the file in binary mode (e.g., "wb") when using fwrite. This prevents unwanted newline character translations, which can corrupt the data.
• Data Alignment: Be aware of potential data alignment issues. Structures may have padding bytes inserted by the compiler to ensure proper alignment. This padding will also be written to the file. When reading the data back, ensure that the structure definition is identical to avoid misinterpretations.
• Portability: Binary file formats created with fwrite may not be portable across different architectures (e.g., different endianness). Consider using a standardized data format or implementing byte swapping if portability is a requirement.
• Error Handling: Always check the return value of fwrite to detect and handle potential write errors. Use ferror(fp) or errno for more detailed error information.

fprintf: Writing Formatted Text Data

Explanation

The fprintf function writes formatted data to a file stream. It's similar to printf but allows you to specify the output stream. It's excellent for creating human-readable text files.

Syntax

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

• stream: A pointer to the FILE object representing the output stream.
• format: A format string that specifies how the data should be formatted.
• ...: A variable number of arguments to be formatted and written.

Return Value

fprintf returns the number of characters written. It returns a negative value if an error occurred. Always check the return value to ensure that the write operation was successful.

Example 1: Writing Simple Text

This example writes a simple string to a file.

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

int main() {
    FILE *fp;

    fp = fopen("greeting.txt", "w"); // Open in write mode (text)

    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    int chars_written = fprintf(fp, "Hello, World!\n");

    if (chars_written < 0) {
        fprintf(stderr, "Error writing to file.\n");
    } else {
        printf("Successfully wrote to greeting.txt\n");
    }

    fclose(fp);
    return 0;
} 

Example 2: Writing Formatted Data

This example demonstrates writing integers, floating-point numbers, and strings to a file with specific formatting.

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

int main() {
    int age = 30;
    float height = 1.75;
    char name[] = "Alice";
    FILE *fp;

    fp = fopen("data.txt", "w");

    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    int chars_written = fprintf(fp, "Name: %s, Age: %d, Height: %.2f\n", name, age, height);

    if (chars_written < 0) {
        fprintf(stderr, "Error writing to file.\n");
    } else {
        printf("Successfully wrote formatted data to data.txt\n");
    }

    fclose(fp);
    return 0;
} 

Example 3: Writing a CSV File

This example shows how to write data to a CSV (Comma Separated Values) file.

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

int main() {
    FILE *fp;
    int data[][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int num_rows = sizeof(data) / sizeof(data[0]);

    fp = fopen("data.csv", "w");

    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    for (int i = 0; i < num_rows; i++) {
        int chars_written = fprintf(fp, "%d,%d,%d\n", data[i][0], data[i][1], data[i][2]);

        if (chars_written < 0) {
            fprintf(stderr, "Error writing to file.\n");
            fclose(fp);
            return 1;
        }
    }

    printf("Successfully wrote CSV data to data.csv\n");
    fclose(fp);
    return 0;
} 

Important Considerations for fprintf

• Text Mode: Open the file in text mode (e.g., "w", "a") when using fprintf.
• Format Specifiers: Understand and use the correct format specifiers (e.g., %d for integers, %f for floating-point numbers, %s for strings). Incorrect format specifiers can lead to undefined behavior.
• Precision and Width: Use precision and width specifiers to control the formatting of output, such as the number of decimal places for floating-point numbers. For example, %.2f limits the output to two decimal places.
• Error Handling: Always check the return value of fprintf to detect and handle potential write errors. Use ferror(fp) or errno for more detailed error information.
• Security: Be mindful of format string vulnerabilities. Avoid using user-supplied data directly as the format string in fprintf, as this can lead to security exploits. Use a fixed format string and pass user data as arguments.

Error Handling and File Closing

In all file operations, it's critical to handle potential errors and close files properly.

• Error Checking: Always check the return values of fopen, fwrite, and fprintf. Use perror to print error messages to the standard error stream.
• File Closing: Always close files using fclose(fp) when you are finished writing to them. This ensures that all buffered data is written to the file and that the file resources are released. Failure to close files can lead to data loss or resource leaks.
• Robustness: Combine error checking with proper resource cleanup in case of errors to maintain a robust and reliable program.

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

int main() {
    FILE *fp;
    int data = 42;

    fp = fopen("example.txt", "w");

    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    int chars_written = fprintf(fp, "%d\n", data);

    if (chars_written < 0) {
        perror("Error writing to file");
    }

    if (fclose(fp) == EOF) {
        perror("Error closing file");
        return 1;
    }

    printf("Successfully wrote to and closed example.txt\n");
    return 0;
} 

Choosing Between fwrite and fprintf

The choice between fwrite and fprintf depends on the type of data you are writing and the desired format of the output.

• fwrite: Use fwrite for writing raw binary data, such as arrays of numbers or structures. It's more efficient for binary data and preserves the exact bit representation of the data.
• fprintf: Use fprintf for writing formatted text data, such as strings, numbers with specific formatting, or CSV files. It allows you to control the appearance of the output and create human-readable files.