The Foundation: Standard I/O Streams

At the heart of <stdio.h> are three predefined file streams, available globally in every C program:

• stdin: The standard input stream, typically connected to the keyboard. Functions like scanf() and fgets() read from this stream.
• stdout: The standard output stream, typically connected to the console display. Functions like printf() and puts() write to this stream.
• stderr: The standard error stream, also typically connected to the console display, but intended specifically for error messages and diagnostics. This separation allows users to redirect standard output while still viewing error messages.

These streams are of type FILE*, a pointer to a structure that holds all necessary information to control a stream.

Console I/O Functions: Interacting with the User

These functions are your primary tools for communication between your program and the user via the console.

Formatted Output: printf()

The most versatile output function, printf(), allows you to print formatted data to stdout. It uses format specifiers (e.g., %d for integers, %s for strings, %f for floats) to interpret and display arguments.

#include <stdio.h>

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

    printf("Name: %s, Age: %d, Height: %.2f meters.\n", name, age, height);
    return 0;
}
        

Key point: Always match the format specifiers with the correct data types of the arguments to avoid undefined behavior.

Formatted Input: scanf()

scanf() reads formatted input from stdin. Like printf(), it uses format specifiers. A crucial difference is that for most types (except strings), you must pass the address of the variable using the address-of operator (&).

#include <stdio.h>

int main() {
    int num;
    char str[20]; // Buffer to store string

    printf("Enter an integer: ");
    scanf("%d", &num); // Notice &num for integer

    printf("Enter a string (no spaces): ");
    scanf("%19s", str); // For char arrays, 'str' itself is the address. %19s to prevent overflow.

    printf("You entered: Integer = %d, String = %s\n", num, str);
    return 0;
}
        

Caution: While scanf("%19s", ...) provides some protection, scanf() can still be problematic with mixed input types and error handling. For reading entire lines of text, fgets() is generally safer and more robust.

String Input: fgets() vs. gets()

gets() is deprecated and dangerous; never use it. It offers no way to limit the number of characters read, leading to buffer overflows.

fgets() is the safer alternative for reading strings. It reads up to n-1 characters from a specified stream (or until a newline or EOF) and stores them in a buffer, null-terminating the result.

#include <stdio.h>
#include <string.h> // For strcspn

int main() {
    char buffer[50];

    printf("Enter a line of text: ");
    // Reads from stdin, stores in buffer, max 49 chars + null terminator
    if (fgets(buffer, sizeof(buffer), stdin) != NULL) {
        // fgets includes the newline character if there's space. Remove it for cleaner output.
        buffer[strcspn(buffer, "\n")] = 0; 
        printf("You entered: %s\n", buffer);
    } else {
        printf("Error reading input.\n");
    }
    return 0;
}
        

Character I/O: getchar(), putchar(), getc(), puts()

• getchar() / getc(): Read a single character from stdin (or a specified stream for getc). They return an int to accommodate EOF.
• putchar() / putc(): Write a single character to stdout (or a specified stream for putc).
• puts(): Writes a null-terminated string to stdout, followed by a newline character.

#include <stdio.h>

int main() {
    int ch; // Use int to correctly handle EOF
    printf("Enter a character: ");
    ch = getchar(); // Reads a single character

    printf("You entered: ");
    putchar(ch); // Prints the character

    puts("\nThis is a string printed by puts."); // Prints string and adds newline
    return 0;
}
        

File I/O Functions: Working with Files

Interacting with files on disk is a core requirement for many applications. <stdio.h> provides a comprehensive set of functions for this purpose, treating files as streams similar to stdin, stdout, and stderr.

Opening and Closing Files: fopen() and fclose()

• fopen(const char *filename, const char *mode): Opens the file specified by filename in the given mode. It returns a FILE* pointer if successful, or NULL on failure.

  Common modes include:

  • "r": Read mode. File must exist.
  • "w": Write mode. Creates a new file or truncates an existing one.
  • "a": Append mode. Creates a new file or appends to an existing one.
  • "r+": Read/update mode. File must exist.
  • "w+": Write/update mode. Creates a new file or truncates an existing one.
  • "a+": Append/update mode. Creates a new file or appends to an existing one.
  • Add 'b' for binary mode (e.g., "rb", "wb").
• fclose(FILE *stream): Closes the specified file stream, flushing any buffered data to disk. It returns 0 on success, or EOF on error. Always close files when you're done with them to prevent data loss or resource leaks.

#include <stdio.h>
#include <stdlib.h> // For EXIT_FAILURE

int main() {
    FILE *filePtr;

    // Open a file for writing
    filePtr = fopen("my_file.txt", "w");
    if (filePtr == NULL) {
        perror("Error opening file for writing"); // Prints a system error message
        return EXIT_FAILURE;
    }
    fprintf(filePtr, "Hello from C file I/O!\n");
    fclose(filePtr);
    printf("Data written to my_file.txt\n");

    // Open the same file for reading
    filePtr = fopen("my_file.txt", "r");
    if (filePtr == NULL) {
        perror("Error opening file for reading");
        return EXIT_FAILURE;
    }
    char buffer[100];
    if (fgets(buffer, sizeof(buffer), filePtr) != NULL) {
        printf("Content read from file: %s", buffer);
    } else {
        perror("Error reading from file");
    }
    fclose(filePtr);

    return 0;
}
        

Formatted File I/O: fprintf() and fscanf()

These functions are the file counterparts of printf() and scanf(). They take an additional FILE* argument to specify which file stream to operate on.

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

int main() {
    FILE *fp;
    int value = 123;
    char name[20] = "John Doe";

    fp = fopen("data.txt", "w+"); // Open for read and write, create/truncate
    if (fp == NULL) {
        perror("Error opening data.txt");
        return EXIT_FAILURE;
    }

    // Write formatted data to file
    fprintf(fp, "Name: %s, ID: %d\n", name, value);
    printf("Data written to data.txt\n");

    // Move file pointer to the beginning to read
    rewind(fp); 

    // Read formatted data from file
    char readName[20];
    int readID;
    // Note: Use a dummy string literal for "Name: ", " ID: " to match format
    if (fscanf(fp, "Name: %19[^,], ID: %d", readName, &readID) == 2) { 
        printf("Data read from data.txt: Name = %s, ID = %d\n", readName, readID);
    } else {
        printf("Error reading data or format mismatch.\n");
    }

    fclose(fp);
    return 0;
}
        

Tip for fscanf: The %19[^,] format specifier reads up to 19 characters (leaving space for null terminator) until a comma is encountered. This is safer than plain %s as it prevents buffer overflows and allows reading strings with spaces.

Character-by-Character File I/O: fgetc() and fputc()

These functions read/write a single character at a time from/to a specified file stream.

• fgetc(FILE *stream): Reads the next character from stream. Returns the character as an unsigned char cast to an int, or EOF on end-of-file or error.
• fputc(int character, FILE *stream): Writes the character (converted to unsigned char) to stream. Returns the character written on success, or EOF on error.

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

int main() {
    FILE *fp_read, *fp_write;
    int ch; // Use int for character to handle EOF

    fp_read = fopen("my_file.txt", "r"); // Assuming my_file.txt from earlier example exists
    fp_write = fopen("copy_file.txt", "w");
    if (fp_read == NULL || fp_write == NULL) {
        perror("Error opening files");
        // Ensure both are closed if one opened successfully
        if (fp_read) fclose(fp_read);
        if (fp_write) fclose(fp_write);
        return EXIT_FAILURE;
    }

    // Copy file character by character
    while ((ch = fgetc(fp_read)) != EOF) {
        if (fputc(ch, fp_write) == EOF) {
            perror("Error writing character");
            break;
        }
    }
    printf("Content copied from my_file.txt to copy_file.txt\n");

    fclose(fp_read);
    fclose(fp_write);
    return 0;
}
        

Block I/O: fread() and fwrite()

For binary data or efficient transfer of structured data, fread() and fwrite() are invaluable. They operate on blocks of data rather than individual characters or formatted strings.

• size_t fread(void *ptr, size_t size, size_t count, FILE *stream): Reads up to count items, each of size bytes, from stream into the memory block pointed to by ptr. Returns the number of items successfully read.
• size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream): Writes up to count items, each of size bytes, from the memory block pointed to by ptr to stream. Returns the number of items successfully written.

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

// Define a simple structure
typedef struct {
    int id;
    char name[30];
    float score;
} Student;

int main() {
    FILE *fp;
    Student student1 = {1, "Alice", 95.5};
    Student student2; // To read into

    // Write a student record to a binary file
    fp = fopen("students.dat", "wb"); // "wb" for write binary
    if (fp == NULL) {
        perror("Error opening students.dat for writing");
        return EXIT_FAILURE;
    }
    if (fwrite(&student1, sizeof(Student), 1, fp) != 1) {
        perror("Error writing student record");
    }
    fclose(fp);
    printf("Student record written to students.dat\n");

    // Read a student record from the binary file
    fp = fopen("students.dat", "rb"); // "rb" for read binary
    if (fp == NULL) {
        perror("Error opening students.dat for reading");
        return EXIT_FAILURE;
    }
    if (fread(&student2, sizeof(Student), 1, fp) == 1) {
        printf("Student record read: ID=%d, Name=%s, Score=%.2f\n", 
               student2.id, student2.name, student2.score);
    } else {
        perror("Error reading student record");
    }
    fclose(fp);

    return 0;
}
        

File Positioning: fseek(), ftell(), rewind()

These functions allow you to control the read/write position within a file.

• fseek(FILE *stream, long offset, int whence): Sets the file position indicator for the stream.
  • offset: Number of bytes to move.
  • whence: Origin for the offset: SEEK_SET (beginning of file), SEEK_CUR (current position), SEEK_END (end of file).
  Returns 0 on success, non-zero on error.
• long ftell(FILE *stream): Returns the current value of the file position indicator for the stream. Returns -1L on error.
• void rewind(FILE *stream): Sets the file position indicator to the beginning of the file. Equivalent to (void)fseek(stream, 0L, SEEK_SET) but also clears the error and EOF indicators.

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

int main() {
    FILE *fp;
    fp = fopen("my_file.txt", "w+"); // Open for read/write, create/truncate
    if (fp == NULL) {
        perror("Error opening my_file.txt");
        return EXIT_FAILURE;
    }

    fprintf(fp, "0123456789");
    printf("Current position after writing: %ld\n", ftell(fp)); // Should be 10

    fseek(fp, 5, SEEK_SET); // Move 5 bytes from the beginning
    printf("Position after fseek(5, SEEK_SET): %ld\n", ftell(fp)); // Should be 5

    fputc('A', fp); // Overwrite '5' with 'A'
    printf("Current position after fputc('A'): %ld\n", ftell(fp)); // Should be 6

    rewind(fp); // Go back to the beginning
    printf("Position after rewind(): %ld\n", ftell(fp)); // Should be 0

    char buffer[10];
    // Read 9 characters (+ null terminator) from the beginning
    if (fgets(buffer, sizeof(buffer), fp) != NULL) {
        printf("Content after rewind and fgets: %s\n", buffer); // Should be "01234A678"
    } else {
        perror("Error reading after rewind");
    }

    fclose(fp);
    return 0;
}
        

Error and EOF Indicators: feof() and ferror()

These functions help determine the status of a file stream.

• int feof(FILE *stream): Returns non-zero if the end-of-file indicator is set for the given stream.
• int ferror(FILE *stream): Returns non-zero if the error indicator is set for the given stream.
• void clearerr(FILE *stream): Clears the end-of-file and error indicators for the given stream.

It's generally recommended to check the return value of I/O functions (like fread(), fgets(), fgetc()) directly for EOF or NULL, and then use ferror() to distinguish between end-of-file and actual read errors.

Best Practices and Security Considerations

• Always check return values: Most <stdio.h> functions return an indicator of success or failure (e.g., NULL for fopen(), EOF for character functions, number of items for fread()/fwrite()). Always check these to ensure your I/O operations are successful and handle errors gracefully. The perror() function is useful for printing system error messages.
• fclose() is essential: Failing to close files can lead to data corruption, resource leaks, or exceeding the operating system's file descriptor limits. Use a consistent pattern to ensure files are closed, even if errors occur.
• Avoid gets(): It's inherently unsafe due to buffer overflow risks. Use fgets() instead, always specifying the buffer size.
• Use sized input with scanf(): For string inputs with scanf(), specify a maximum width (e.g., scanf("%19s", buffer);) to prevent buffer overflows, though fgets() is still generally preferred for lines of text.
• Binary vs. Text Mode: Be mindful of opening files in binary ("rb", "wb") versus text ("r", "w") mode. Text mode can perform newline character conversions (e.g., converting '\n' to "\r\n" on Windows), which can distort binary data. Always use binary mode for non-textual data.
• Handle EOF and NULL carefully: Differentiate between reaching the end of a file and an actual I/O error using feof() and ferror().
• Flush output when necessary: Output streams are often buffered. Use fflush(stdout) or fflush(filePtr) to force buffered data to be written immediately, especially useful before sensitive operations or when debugging.