Core Differences Between Standard I/O and System I/O

High-Level vs. Low-Level Interfaces

• Standard I/O: Acts as a high-level abstraction layer, offering intuitive functions like fopen(), fprintf(), and fread() for file operatiosn. It hides low-level system call details, simplifying usage and ensuring cross-platform compatibility across different operating systems.
• System I/O: Consists of direct low-level system calls such as open(), read(), and write(). These calls provide granular control over file operations but require a deeper understanding of OS-specific mechanics and typically demand more code to implement.

Buffering Mechanisms

• Standard I/O: Incorporates automatic buffering by default. Data is first transferred to an internal buffer before being committed to disk or read into memory, which significantly boosts performance—especially for frequent, small-sized read/write operations by reducing the number of actual I/O transactions.
• System I/O: Does not include built-in buffering. Developers must implement custom buffer management logic if needed. This direct approach eliminates abstraction overhead but requires careful handling to avoid performance bottlenecks with small data transfers.

Error Handling Approaches

• Standard I/O: Functions indicate failures by returning NULL (for pointer-based operations). You can check for end-of-file or specific errors using feof() and ferror(), and perror() can be used to print human-readable error messages.
• System I/O: System calls return -1 to signal errors. The global errno variable stores the specific error code, which can be converted to a descriptive message using strerror() or displayed directly via perror().

Implementing Standard I/O Operations

Here’s a practical example demonstrating file creation, writing, and reading using Standard I/O functions:

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

int main() {
    // Open file in write mode; create if it doesn't exist, truncate if it does
    FILE *fp = fopen("stdio_demo.txt", "w");
    if (fp == NULL) {
        perror("Failed to open file for writing");
        return EXIT_FAILURE;
    }

    // Write content to the file
    const char *output_text = "Content written via Standard I/O\n";
    fprintf(fp, "%s", output_text);
    
    // Close the file handle
    fclose(fp);

    // Reopen file in read mode
    fp = fopen("stdio_demo.txt", "r");
    if (fp == NULL) {
        perror("Failed to open file for reading");
        return EXIT_FAILURE;
    }

    char read_buf[128];
    // Read line by line until end of file
    while (fgets(read_buf, sizeof(read_buf), fp) != NULL) {
        printf("Standard I/O Read: %s", read_buf);
    }

    // Close the file handle again
    fclose(fp);

    return EXIT_SUCCESS;
}

Output:

Standard I/O Read: Content written via Standard I/O

Implementing System I/O Operations

The following example uses system calls to perform equivalent file operations, demonstrating direct OS-level interaction:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

int main() {
    const char *filename = "sysio_demo.txt";
    // Open file for writing; create if missing, set permissions to 0644
    int file_desc = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (file_desc == -1) {
        fprintf(stderr, "Open for write failed: %s\n", strerror(errno));
        return EXIT_FAILURE;
    }

    // Define content to write
    const char *write_content = "Content written via System I/O\n";
    ssize_t bytes_written = write(file_desc, write_content, strlen(write_content));
    if (bytes_written == -1) {
        fprintf(stderr, "Write operation failed: %s\n", strerror(errno));
        close(file_desc);
        return EXIT_FAILURE;
    }

    // Close the file descriptor
    close(file_desc);

    // Reopen file for reading
    file_desc = open(filename, O_RDONLY);
    if (file_desc == -1) {
        fprintf(stderr, "Open for read failed: %s\n", strerror(errno));
        return EXIT_FAILURE;
    }

    char io_buf[128];
    ssize_t bytes_read;
    // Read file content in chunks until end of file
    while ((bytes_read = read(file_desc, io_buf, sizeof(io_buf))) > 0) {
        // Write read content to standard output
        ssize_t stdout_write = write(STDOUT_FILENO, io_buf, bytes_read);
        if (stdout_write == -1) {
            fprintf(stderr, "Write to stdout failed: %s\n", strerror(errno));
            close(file_desc);
            return EXIT_FAILURE;
        }
    }

    // Handle read errors
    if (bytes_read == -1) {
        fprintf(stderr, "Read operation failed: %s\n", strerror(errno));
        close(file_desc);
        return EXIT_FAILURE;
    }

    // Close the file descriptor
    close(file_desc);

    return EXIT_SUCCESS;
}

Output:

Content written via System I/O