C Programming File Handling Exercises

#include <stdio.h>
#include <stdlib.h> // Needed for exit()

int main() {
    // Declare a file pointer
    FILE *fp;
    char name[] = "Alice Johnson";
    int age = 30;

    // Open the file in write mode ("w")
    fp = fopen("data.txt", "w");

    // Check for file opening error
    if (fp == NULL) {
        printf("Error opening file!\n");
        // Exit the program if file cannot be opened
        exit(1); 
    }

    // Write data to the file
    fprintf(fp, "Name: %s\n", name);
    fprintf(fp, "Age: %d years\n", age);

    // Close the file
    fclose(fp);

    printf("Data successfully written to data.txt.\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program first declares a FILE pointer, fp. It attempts to open data.txt in write mode ("w"). If the file doesn’t exist, it’s created; if it exists, its content is truncated (deleted). The program checks if fp is NULL, which indicates a failure to open the file.
• If successful, fprintf() is used exactly like printf(), but its first argument is the file pointer, directing the output to the file instead of the console. Finally, fclose(fp) is called to close the file, flushing any remaining buffers and releasing the file resource.

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

int main() {
    FILE *fp;
    char buffer[100]; // Buffer to hold each line of data

    // Open the file in read mode ("r")
    fp = fopen("data.txt", "r");

    if (fp == NULL) {
        printf("Error opening file or file not found!\n");
        exit(1);
    }

    printf("Content of data.txt:\n");
    printf("---------------------\n");

    // Read content line by line using fgets()
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        // Print the line read from the file to the console
        printf("%s", buffer);
    }

    // Close the file
    fclose(fp);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The file is opened in read mode ("r"). A character array, buffer, is used as a temporary storage space for each line read.
• The fgets() function reads a line from the file stream (fp) and stores it into buffer, reading at most sizeof(buffer) - 1 characters, or until a newline character or EOF is encountered.
• The loop continues as long as fgets() returns a non-NULL value. The content of the buffer is then printed to the standard output using printf().

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

int main() {
    FILE *fp;

    // Use a simple date string for demonstration
    char date[] = "2025-10-15"; 

    // Open the file in append mode ("a")
    fp = fopen("data.txt", "a");

    if (fp == NULL) {
        printf("Error opening file!\n");
        exit(1);
    }

    // Write the new data (appended to the end)
    fprintf(fp, "Date Appended: %s\n", date);
    fprintf(fp, "Status: Successfully appended.\n");

    // Close the file
    fclose(fp);

    printf("New data successfully appended to data.txt.\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

The core difference here is the use of the append mode ("a") in fopen(). When a file is opened in this mode, the file pointer is automatically positioned at the end of the file. Subsequent write operations using fprintf() or other output functions will simply add the new data after the existing content, preserving the original data.

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

int main() {
    FILE *fp;
    int character;
    long char_count = 0; // Use long for potentially large files

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

    if (fp == NULL) {
        printf("Error: Could not open data.txt\n");
        exit(1);
    }

    // Read the file character by character
    while ((character = fgetc(fp)) != EOF) {
        char_count++;
    }

    fclose(fp);

    printf("Total number of characters in the file: %ld\n", char_count);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The file is read using the fgetc() function, which returns the next character from the file stream as an int. We use an int to store the return value because it must be able to hold the EOF value (which is outside the range of a standard char).
• Inside the while loop, as long as the returned value is not equal to EOF, the character counter (char_count) is incremented.

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

int main() {
    FILE *fp;
    int character;
    int line_count = 0;

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

    if (fp == NULL) {
        printf("Error: Could not open data.txt\n");
        exit(1);
    }

    // Read character by character
    while ((character = fgetc(fp)) != EOF) {
        // Check for the newline character
        if (character == '\n') {
            line_count++;
        }
    }

    // A common convention: If the file is not empty and doesn't end with a newline, 
    // the last line won't have been counted yet. We check the file size to see if it's empty.
    if (line_count == 0) {
         // Reset pointer to beginning to check if file is empty
         fseek(fp, 0, SEEK_END); 
         if (ftell(fp) > 0) { 
             line_count = 1; // It's not empty, so it has at least one line
         }
    } else {
         // If there was content and the last character wasn't a newline, increment count
         // Simpler approach: Check if the last character read was NOT a newline
         fseek(fp, -1, SEEK_END);
         if (fgetc(fp) != '\n') {
             line_count++;
         }
    }

    // Simpler, more robust approach:
    // if (line_count > 0 || (fseek(fp, 0, SEEK_END) != -1 && ftell(fp) > 0) ) {
    //     // Logic to handle the last line without a newline
    // }


    fclose(fp);

    printf("Total number of lines in the file: %d\n", line_count);

    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise uses fgetc() to iterate through the file.

• The program specifically looks for the newline character ('\n'); every time this character is found, the line_count is incremented.
• A key complexity in line counting is handling the last line of the file. If a file ends with actual content but without a final newline character, the last line won’t be counted.
• The robust solution often involves a conditional check after the loop to see if the file contained any characters at all and if the last character read was not a newline.

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h> // For isspace()

#define OUT 0 // Outside a word
#define IN 1  // Inside a word

int main() {
    FILE *fp;
    int character;
    int word_count = 0;
    int state = OUT;

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

    if (fp == NULL) {
        printf("Error: Could not open data.txt\n");
        exit(1);
    }

    // Read character by character
    while ((character = fgetc(fp)) != EOF) {
        // Check if the character is a delimiter (space, tab, or newline)
        if (isspace(character)) {
            state = OUT; // We are outside a word
        } 
        // If the character is NOT a delimiter AND we were OUT of a word
        else if (state == OUT) {
            state = IN;  // We just started a new word
            word_count++;
        }
        // If we are IN a word, do nothing and continue reading
    }

    fclose(fp);

    printf("Total number of words in the file: %d\n", word_count);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This program uses a simple state machine to accurately count words. The state variable tracks whether the program is currently IN a word or OUT of a word (i.e., at a delimiter).
• The isspace() function checks for any whitespace character (space, tab, newline, etc.). A word is counted only when the program transitions from the OUT state to the IN state, meaning a non-delimiter character was just encountered after one or more delimiters. This correctly handles multiple spaces between words.

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

int main() {
    FILE *source_fp, *dest_fp;
    int character;

    // Open source file for reading
    source_fp = fopen("data.txt", "r");

    if (source_fp == NULL) {
        perror("Error opening data.txt");
        exit(1);
    }

    // Open destination file for writing (creates or overwrites)
    dest_fp = fopen("destination.txt", "w");

    if (dest_fp == NULL) {
        perror("Error opening destination.txt");
        fclose(source_fp); // Close source file before exiting
        exit(1);
    }

    // Copy content character by character
    while ((character = fgetc(source_fp)) != EOF) {
        fputc(character, dest_fp); // Write the character to the destination file
    }

    // Close both files
    fclose(source_fp);
    fclose(dest_fp);

    printf("File 'data.txt' successfully copied to 'destination.txt'.\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program utilizes two separate file pointers. It reads one character at a time from the source file using fgetc() until the EOF is reached. For every character read, fputc() is immediately used to write that same character to the destination file stream.
• This is the most fundamental and robust method for binary or text file copying in C. Crucially, the program includes error checking for both file operations and ensures that the source file is closed even if the destination file fails to open.

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

int main() {
    FILE *fp;
    char buffer[256];
    int target_line, current_line = 0;

    printf("Enter the line number to display: ");
    if (scanf("%d", &target_line) != 1 || target_line < 1) {
        printf("Invalid line number entered.\n");
        return 1;
    }

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

    if (fp == NULL) {
        printf("Error: Could not open data.txt\n");
        return 1;
    }

    // Read lines one by one
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        current_line++;

        // Check if the current line matches the target line
        if (current_line == target_line) {
            printf("\n--- Line %d ---\n", target_line);
            printf("%s", buffer);
            printf("--------------\n");
            fclose(fp);
            return 0; // Exit successfully after finding the line
        }
    }

    fclose(fp);

    // If the loop finishes without finding the line
    printf("Error: Line %d not found (File has %d lines).\n", target_line, current_line);

    return 0;
}Code language: C++ (cpp)

Explanation:

• After getting the desired target_line from the user, the program reads the file line by line using fgets().
• A current_line counter is incremented for every line successfully read. When current_line equals target_line, the content of the buffer is printed, the file is closed, and the program exits.
• If the loop finishes without the condition being met, it means the requested line number was greater than the total number of lines in the file.

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

int main() {
    FILE *fp;
    int i;

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

    if (fp == NULL) {
        printf("Error opening file!\n");
        exit(1); 
    }

    printf("Writing numbers 1 to 10 to numbers.txt...\n");

    // Loop from 1 to 10
    for (i = 1; i <= 10; i++) {
        // Write the number and a newline character to the file
        fprintf(fp, "%d\n", i);
    }

    fclose(fp);

    printf("Numbers successfully written.\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

• The file is opened in write mode ("w"). A standard for loop is used to generate the numbers 1 through 10.
• The key function is fprintf(fp, "%d\n", i). The \n (newline character) appended to the format string is crucial, as it ensures that each subsequent number is written starting on a new line in the text file, fulfilling the problem requirement.

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

int main() {
    FILE *fp;
    int number;
    int sum = 0;
    int read_count;

    fp = fopen("numbers.txt", "r");

    if (fp == NULL) {
        printf("Error opening file 'numbers.txt'.\n");
        exit(1); 
    }

    printf("Reading numbers from file and calculating sum...\n");

    // Loop using fscanf() to read integers
    // fscanf returns the number of successfully read items (should be 1)
    while ((read_count = fscanf(fp, "%d", &number)) == 1) {
        sum += number; // Add the read number to the total sum
        // printf("Read: %d\n", number); // Uncomment for debugging
    }

    fclose(fp);

    // Check if the loop ended because of EOF or a format mismatch
    if (feof(fp)) {
        printf("Successfully processed all numbers.\n");
        printf("The total sum of the numbers is: %d\n", sum);
    } else if (ferror(fp)) {
        printf("An I/O error occurred during reading.\n");
    } else {
         // This happens if fscanf failed because it encountered non-integer data
         printf("Error: Found non-numeric data in the file.\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The file is opened in read mode.
• The core of the program is the while loop condition: (read_count = fscanf(fp, "%d", &number)) == 1. The fscanf() function attempts to read an integer from the file and store it at the address of the number variable. It returns the count of items successfully matched and assigned.
• As long as it returns 1, an integer was read and assigned, and it is added to the sum. When fscanf() reaches the end of the file or encounters non-numeric data, it will return a value other than 1, terminating the loop.

#include <stdio.h>
#include <stdlib.h> 
#include <ctype.h> // For toupper()

int main() {
    FILE *in_fp, *out_fp;
    int character;

    in_fp = fopen("data.txt", "r");
    if (in_fp == NULL) {
        perror("Error opening data.txt");
        exit(1);
    }

    out_fp = fopen("output_upper.txt", "w");
    if (out_fp == NULL) {
        perror("Error opening output_upper.txt");
        fclose(in_fp);
        exit(1);
    }

    // Read character by character until EOF
    while ((character = fgetc(in_fp)) != EOF) {
        // Convert to uppercase (if it's a letter) and write to the output file
        fputc(toupper(character), out_fp);
    }

    printf("Content copied to 'output_upper.txt' in uppercase.\n");

    fclose(in_fp);
    fclose(out_fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

The program reads the input file character by character using fgetc(). The retrieved character is passed directly to the toupper() function.

If the character is a lowercase letter, toupper() returns its uppercase equivalent; otherwise, it returns the character itself unchanged. This result is immediately written to the output file using fputc(). This ensures a perfect copy with only the casing modified.

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

int is_vowel(char ch) {
    switch (ch) {
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
        case 'A':
        case 'E':
        case 'I':
        case 'O':
        case 'U':
            return 1; // It is a vowel
        default:
            return 0; // It is not a vowel
    }
}

int main() {
    FILE *in_fp, *out_fp;
    int character;

    in_fp = fopen("data.txt", "r");
    if (in_fp == NULL) {
        perror("Error opening data.txt");
        exit(1);
    }

    out_fp = fopen("no_vowels.txt", "w");
    if (out_fp == NULL) {
        perror("Error opening no_vowels.txt");
        fclose(in_fp);
        exit(1);
    }

    while ((character = fgetc(in_fp)) != EOF) {
        // Write only if the character is NOT a vowel
        if (!is_vowel(character)) {
            fputc(character, out_fp);
        }
    }

    printf("Vowels removed. Result saved in 'no_vowels.txt'.\n");

    fclose(in_fp);
    fclose(out_fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

• This program defines a helper function, is_vowel(), for clarity.
• The main loop reads the file character by character. Inside the loop, the condition !is_vowel(character) checks if the character is not a vowel (both upper and lower case). Only when this condition is true is the character written to the output file using fputc().
• All vowel characters are simply skipped, effectively removing them from the copied content.

#include <stdio.h>
#include <stdlib.h> 
#include <string.h> // For strcmp()

int main() {
    FILE *fp;
    char filename[100];
    char target_word[50];
    char file_word[50];
    int count = 0;

    printf("Enter the filename: ");
    scanf("%s", filename);
    printf("Enter the word to search: ");
    scanf("%s", target_word);

    fp = fopen(filename, "r");
    if (fp == NULL) {
        perror("Error opening file");
        exit(1);
    }

    // Read word by word from the file
    // fscanf with %s reads a string until it hits whitespace
    while (fscanf(fp, "%s", file_word) == 1) {
        // Compare the word read from the file with the target word
        // strcmp returns 0 if the strings are identical
        if (strcmp(file_word, target_word) == 0) {
            count++;
        }
    }

    fclose(fp);

    printf("\nThe word '%s' appears %d times in '%s'.\n", target_word, count, filename);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program takes the filename and the target_word from the user. It then uses fscanf(fp, "%s", file_word) inside a loop. The %s format specifier tells fscanf() to read a string (a “word”) until it encounters any whitespace (space, tab, or newline) and stores it in file_word.
• This elegantly handles word separation. The strcmp() function performs a case-sensitive comparison. When strcmp() returns 0, the words match, and the counter is incremented.

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

#define OLD_WORD "the"
#define NEW_WORD "a"

int main() {
    FILE *in_fp, *out_fp;
    char file_word[50];

    in_fp = fopen("sample.txt", "r");
    if (in_fp == NULL) {
        perror("Error opening sample.txt");
        exit(1);
    }

    out_fp = fopen("modified.txt", "w");
    if (out_fp == NULL) {
        perror("Error opening modified.txt");
        fclose(in_fp);
        exit(1);
    }

    // Read word by word
    while (fscanf(in_fp, "%s", file_word) == 1) {
        // Check if the word needs replacement
        if (strcmp(file_word, OLD_WORD) == 0) {
            fprintf(out_fp, "%s ", NEW_WORD); // Write the new word
        } else {
            fprintf(out_fp, "%s ", file_word); // Write the original word
        }
    }

    printf("Word replacement complete. Saved to 'modified.txt'.\n");

    fclose(in_fp);
    fclose(out_fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

• The program reads sample.txt word by word using fscanf().
• Inside the loop, it checks if file_word is equal to the predefined OLD_WORD using strcmp(). If they are equal, the NEW_WORD is written to modified.txt using fprintf();
• otherwise, the original file_word is written. A space character is appended after every word written ("%s ") to maintain separation, since fscanf("%s", ...) consumes the delimiter but doesn’t store it.

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

int main() {
    FILE *fp;
    long size, i;
    int character;

    fp = fopen("reverse_me.txt", "r");
    if (fp == NULL) {
        perror("Error opening reverse_me.txt");
        exit(1);
    }

    // 1. Find the size of the file
    fseek(fp, 0, SEEK_END); // Move pointer to the end
    size = ftell(fp);       // Get the current position (the size)

    printf("Reversed content:\n");

    // 2. Loop backward from size - 1 down to 0
    for (i = size - 1; i >= 0; i--) {
        // Move the pointer 'i' bytes from the beginning (SEEK_SET)
        fseek(fp, i, SEEK_SET); 

        // Read the character at that position
        character = fgetc(fp); 

        // Display the character
        printf("%c", character);
    }

    printf("\n");
    fclose(fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise heavily relies on fseek() and ftell() for random access (non-sequential I/O).
• First, fseek(fp, 0, SEEK_END) positions the pointer at the end of the file, and ftell() retrieves this position, which is the file’s size in bytes.
• The for loop iterates backward from size - 1 (the index of the last character) to 0 (the first character).
• Inside the loop, fseek(fp, i, SEEK_SET) moves the file pointer to the i^th byte from the beginning, and fgetc() reads the character at that exact location.

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

void copy_file(FILE *source, FILE *dest) {
    int ch;
    while ((ch = fgetc(source)) != EOF) {
        fputc(ch, dest);
    }
}

int main() {
    FILE *fp1, *fp2, *fp_out;

    fp1 = fopen("file1.txt", "r");
    fp2 = fopen("file2.txt", "r");
    fp_out = fopen("merged.txt", "w");

    if (fp1 == NULL || fp2 == NULL || fp_out == NULL) {
        perror("Error opening one or more files");
        if (fp1) fclose(fp1);
        if (fp2) fclose(fp2);
        if (fp_out) fclose(fp_out);
        exit(1);
    }

    // 1. Copy content of file1 to merged.txt
    copy_file(fp1, fp_out);

    // Optional: Add a newline or separator between the two files
    fprintf(fp_out, "\n--- End of File 1 ---\n"); 

    // 2. Copy content of file2 to merged.txt (appended)
    copy_file(fp2, fp_out);

    printf("Files merged successfully into 'merged.txt'.\n");

    fclose(fp1);
    fclose(fp2);
    fclose(fp_out);
    return 0;
}Code language: C++ (cpp)

Explanation:

• The program defines a reusable copy_file function to handle the character-by-character transfer logic. It opens both source files in read mode and the destination file in write mode.
• It calls copy_file first with fp1 as the source, and then with fp2 as the source. Since the destination file pointer (fp_out) remains open, the second call to copy_file automatically appends the content of file2.txt immediately after the content of file1.txt.

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

#define SPACES_PER_TAB 4

int main() {
    FILE *in_fp, *out_fp;
    int character, i;

    in_fp = fopen("tabbed.txt", "r");
    if (in_fp == NULL) {
        perror("Error opening tabbed.txt");
        exit(1);
    }

    out_fp = fopen("spaced.txt", "w");
    if (out_fp == NULL) {
        perror("Error opening spaced.txt");
        fclose(in_fp);
        exit(1);
    }

    while ((character = fgetc(in_fp)) != EOF) {
        if (character == '\t') {
            // If a tab is found, write 4 spaces instead
            for (i = 0; i < SPACES_PER_TAB; i++) {
                fputc(' ', out_fp);
            }
        } else {
            // For any other character, write it as is
            fputc(character, out_fp);
        }
    }

    printf("Tabs replaced with %d spaces. Saved to 'spaced.txt'.\n", SPACES_PER_TAB);

    fclose(in_fp);
    fclose(out_fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

The program reads the input file using fgetc(). Inside the loop, it checks if the character is equal to the tab escape sequence ('\t'). If it is, a small for loop executes, writing the space character (' ') to the output file exactly four times using fputc().

If the character is not a tab, it is written to the output file unmodified.

#include <stdio.h>
#include <stdlib.h> 
#include <ctype.h> // For isalpha(), isupper(), islower()

#define SHIFT 3

int main() {
    FILE *in_fp, *out_fp;
    int character, encrypted_char;

    in_fp = fopen("plain.txt", "r");
    if (in_fp == NULL) {
        perror("Error opening plain.txt");
        exit(1);
    }

    out_fp = fopen("encrypted.txt", "w");
    if (out_fp == NULL) {
        perror("Error opening encrypted.txt");
        fclose(in_fp);
        exit(1);
    }

    while ((character = fgetc(in_fp)) != EOF) {
        encrypted_char = character; // Default: no change

        if (isalpha(character)) {
            int base;
            if (islower(character)) {
                base = 'a';
            } else { // isupper(character)
                base = 'A';
            }

            // Caesar Cipher formula
            encrypted_char = (character - base + SHIFT) % 26 + base;
        }

        fputc(encrypted_char, out_fp);
    }

    printf("File encrypted with shift %d. Saved to 'encrypted.txt'.\n", SHIFT);

    fclose(in_fp);
    fclose(out_fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

• The program reads the file character by character. It uses isalpha() to check if the character is a letter. If it is, it determines the base ('a' or 'A') using islower() or isupper().
• The core Caesar cipher logic uses modular arithmetic: (character - base) converts the letter to an index 0−25. Adding the SHIFT and taking the result modulo 26 wraps the index around the alphabet.
• Finally, adding base converts the index back into the shifted ASCII character. Non-alphabetic characters are written directly without modification.

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

#define SHIFT 3 // Must use the same shift value

int main() {
    FILE *in_fp, *out_fp;
    int character, decrypted_char;

    in_fp = fopen("encrypted.txt", "r");
    if (in_fp == NULL) {
        perror("Error opening encrypted.txt");
        exit(1);
    }

    out_fp = fopen("decrypted.txt", "w");
    if (out_fp == NULL) {
        perror("Error opening decrypted.txt");
        fclose(in_fp);
        exit(1);
    }

    while ((character = fgetc(in_fp)) != EOF) {
        decrypted_char = character;

        if (isalpha(character)) {
            int base;
            if (islower(character)) {
                base = 'a';
            } else {
                base = 'A';
            }

            // Decryption formula (handling C's negative modulo behavior)
            // The term '+ 26' ensures the result of the modulus is always positive.
            decrypted_char = (character - base - SHIFT + 26) % 26 + base; 
        }

        fputc(decrypted_char, out_fp);
    }

    printf("File successfully decrypted. Saved to 'decrypted.txt'.\n");

    fclose(in_fp);
    fclose(out_fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

• The structure is identical to the encryption program, but the mathematical operation is reversed.
• Decryption requires subtracting the SHIFT value. In C, the result of the modulo operator (%) can be negative if the numerator is negative.
• To correctly handle the alphabet wrap-around (e.g., decrypting ‘C’ with a shift of 3 should result in ‘Z’), the expression includes an extra +26 before the final modulo operation: (index - SHIFT + 26) % 26. This guarantees a positive result within the 0−25 range, ensuring the character correctly wraps backward from ‘a’ to ‘z’ or ‘A’ to ‘Z’.

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

// Define the structure for a student record
struct Student {
    char name[50];
    int roll_number;
    float marks;
};

int main() {
    FILE *fp;
    struct Student s;

    // Get data from the user
    printf("Enter Student Name: ");
    scanf("%s", s.name);
    printf("Enter Roll Number: ");
    scanf("%d", &s.roll_number);
    printf("Enter Marks: ");
    scanf("%f", &s.marks);

    // Open the file in write-binary mode ("wb")
    fp = fopen("students.dat", "wb");
    if (fp == NULL) {
        perror("Error opening students.dat");
        exit(1);
    }

    // Write the structure's data to the file
    fwrite(&s, sizeof(struct Student), 1, fp);

    printf("Student record successfully written to students.dat (Binary).\n");

    fclose(fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

The file is opened in binary write mode ("wb"). The fwrite() function is used to write data. Its arguments are:

1. The address of the data block to write (&s).
2. The size of each item to write (sizeof(struct Student)).
3. The number of items to write (1).
4. The file pointer (fp). This approach writes the structure as a continuous block of raw bytes, making it a highly efficient way to store structured, non-textual data.

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

// Re-define the structure
struct Student {
    char name[50];
    int roll_number;
    float marks;
};

int main() {
    FILE *fp;
    struct Student s;

    // Open the file in read-binary mode ("rb")
    fp = fopen("students.dat", "rb");
    if (fp == NULL) {
        perror("Error opening students.dat");
        exit(1);
    }

    // Read the structure's data from the file
    // It returns the number of items successfully read (should be 1)
    if (fread(&s, sizeof(struct Student), 1, fp) == 1) {
        printf("\n--- Student Record Read ---\n");
        printf("Name: %s\n", s.name);
        printf("Roll Number: %d\n", s.roll_number);
        printf("Marks: %.2f\n", s.marks);
        printf("---------------------------\n");
    } else {
        printf("Error reading record or file is empty.\n");
    }

    fclose(fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

• The file is opened in binary read mode ("rb").
• The fread() function is the counterpart to fwrite(). It attempts to read data into the memory location provided (&s). Since the function returns the number of items successfully read, checking if the return value is 1 confirms that a complete Student record was successfully retrieved from the binary file.

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

struct Student {
    char name[50];
    int roll_number;
    float marks;
};

int main() {
    FILE *fp;
    struct Student s;
    int n, i;

    printf("Enter the number of students to record: ");
    scanf("%d", &n);

    fp = fopen("class.dat", "wb");
    if (fp == NULL) {
        perror("Error opening class.dat");
        exit(1);
    }

    for (i = 0; i < n; i++) {
        printf("\n--- Student %d ---\n", i + 1);
        printf("Name: ");
        scanf("%s", s.name);
        printf("Roll Number: ");
        scanf("%d", &s.roll_number);
        printf("Marks: ");
        scanf("%f", &s.marks);

        // Write the record to the file
        fwrite(&s, sizeof(struct Student), 1, fp);
    }

    printf("\n%d student records successfully written to class.dat.\n", n);

    fclose(fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

• The program uses a standard for loop to iterate N times.
• In each iteration, it prompts the user for the three fields of the Student structure. Once the fields are populated, fwrite() is called, writing one complete block of sizeof(struct Student) data to the file.
• Since the file is open in binary mode, the records are stored contiguously, one after the other.

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

struct Student {
    char name[50];
    int roll_number;
    float marks;
};

int main() {
    FILE *fp;
    struct Student s;
    int target_roll, found = 0;

    printf("Enter the Roll Number to search: ");
    scanf("%d", &target_roll);

    fp = fopen("class.dat", "rb");
    if (fp == NULL) {
        perror("Error opening class.dat");
        exit(1);
    }

    // Read records until EOF or error
    while (fread(&s, sizeof(struct Student), 1, fp) == 1) {
        if (s.roll_number == target_roll) {
            printf("\n--- Record Found ---\n");
            printf("Name: %s\n", s.name);
            printf("Roll Number: %d\n", s.roll_number);
            printf("Marks: %.2f\n", s.marks);
            printf("--------------------\n");
            found = 1;
            break; // Stop searching once found
        }
    }

    if (!found) {
        printf("Student with Roll Number %d not found.\n", target_roll);
    }

    fclose(fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

• The file is opened in binary read mode.
• The while loop repeatedly calls fread() to load the next record from the file into the s variable.
• If fread() successfully reads a record (returns 1), the program compares the student’s roll_number with the target_roll. If they match, the details are printed, the found flag is set, and the break statement exits the loop, improving efficiency.

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

struct Student {
    char name[50];
    int roll_number;
    float marks;
};

int main() {
    FILE *fp;
    struct Student s;
    int target_roll, found = 0;
    float new_marks;
    long record_size = sizeof(struct Student);

    printf("Enter Roll Number to update marks for: ");
    scanf("%d", &target_roll);
    printf("Enter new Marks: ");
    scanf("%f", &new_marks);

    // Open in read/write binary mode ("r+b")
    fp = fopen("class.dat", "r+b"); 
    if (fp == NULL) {
        perror("Error opening class.dat");
        exit(1);
    }

    // Read records sequentially
    while (fread(&s, record_size, 1, fp) == 1) {
        if (s.roll_number == target_roll) {
            found = 1;

            // 1. Move file pointer back to the start of the current record
            // Current position = End of the record just read
            // New position = Current position - size of the record
            fseek(fp, -record_size, SEEK_CUR); 

            // 2. Update the marks in the memory structure
            s.marks = new_marks;

            // 3. Write the modified structure back, overwriting the old data
            fwrite(&s, record_size, 1, fp); 

            printf("\nMarks for %s (Roll %d) successfully updated.\n", s.name, target_roll);
            break;
        }
    }

    if (!found) {
        printf("Roll Number %d not found for update.\n", target_roll);
    }

    fclose(fp);
    return 0;
}Code language: C++ (cpp)

Explanation:

• The file is opened in "r+b" mode, allowing both reading and writing (overwriting) of binary data.
• The program reads records until the target_roll is found. Crucially, after a successful fread(), the file pointer is at the end of the record that was just read.
• To overwrite this record, fseek(fp, -record_size, SEEK_CUR) moves the pointer backward by the size of one record (record_size) from the current position (SEEK_CUR).
• The in-memory structure s is updated, and fwrite() then overwrites the old record’s data with the new data at the repositioned pointer.

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

int main() {
    FILE *fp;
    long file_size = -1;

    fp = fopen("class.dat", "rb");
    if (fp == NULL) {
        perror("Error opening class.dat");
        exit(1);
    }

    // 1. Move the file pointer to the end of the file
    if (fseek(fp, 0, SEEK_END) == 0) {
        // 2. Get the current position (which is the file size)
        file_size = ftell(fp);
    } else {
        perror("Error seeking to end of file");
    }

    fclose(fp);

    if (file_size != -1) {
        printf("The size of 'class.dat' is: %ld bytes\n", file_size);
    } else {
        printf("Could not determine file size.\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

This is the standard C method for finding file size.

• The call fseek(fp, 0, SEEK_END) moves the file pointer zero bytes relative to the end of the file, placing it right after the last byte.
• The function ftell(fp) then returns the current absolute position of the pointer, measured from the beginning of the file. Since the pointer is at the end, the returned value is exactly the total size of the file in bytes.

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

int main() {
    FILE *fp;
    const char *filename = "missing.txt";

    printf("Attempting to open the file '%s'...\n", filename);

    // Attempt to open the file for reading
    fp = fopen(filename, "r");

    // Check if the file pointer is NULL (file open failed)
    if (fp == NULL) {
        // perror prints the given string followed by the system error message 
        // corresponding to the current errno value (e.g., "No such file or directory").
        perror("File Open Error");
        printf("Program will now exit.\n");
        // Exit with a non-zero status code to indicate an error
        exit(EXIT_FAILURE); 
    }

    // Only executed if the file opened successfully
    printf("File opened successfully (unexpected for missing.txt!).\n");
    fclose(fp);

    return 0;
}Code language: C++ (cpp)

Explanation:

• When fopen() fails (e.g., file not found, permission denied), it returns a NULL pointer and sets a global integer variable named errno to an appropriate error code.
• The program checks for the NULL return. The perror() function is the standard C mechanism for reporting such errors. It prints the string argument you pass (“File Open Error” in this case), followed by a colon and the system’s human-readable description of the error code stored in errno. This provides much more informative output than a simple “File Error” message