# Basic File Handling Programming Questions

Here are 10 C programming exercises that involve file handling:

1. **Word Count:**
    
    * Read a text file and count the number of words in it.
        
2. **Character Frequency:**
    
    * Read a text file and count the frequency of each character. Output the results to another file.
        
3. **File Copy:**
    
    * Create a program that copies the contents of one file into another.
        
4. **Line Numbers:**
    
    * Read a file and print each line with line numbers. Save the output to another file.
        
5. **File Encryption:**
    
    * Implement a simple encryption algorithm to encrypt the contents of a file. Save the encrypted text to another file.
        
6. **File Concatenation:**
    
    * Merge the contents of two files into a third file.
        
7. **Record Management:**
    
    * Create a program that manages records. Each record can have multiple fields. Implement functionalities like add, delete, search, and modify records using a file as storage.
        
8. **File Search:**
    
    * Implement a program that searches for a specific word in a text file and prints the line numbers where the word is found.
        
9. **CSV File Handling:**
    
    * Read a CSV (Comma-Separated Values) file and perform operations like sorting or filtering based on specific criteria.
        
10. **File Deletion:**
    
    * Write a program that deletes a specific line from a text file.
        

These exercises cover a range of dynamic memory allocation-related concepts and will help you practice and strengthen your skills in C programming. I have solved all of the above with explanatory comments. You should first make a sincere attempt at solving these problems before looking at the solutions.

1. **Word Count:**
    
    ```c
    #include <stdio.h>
    
    int main() {
        FILE *file;
        char ch;
        int wordCount = 0;
    
        // Open the file in read mode
        file = fopen("sample.txt", "r");
    
        // Check if file is opened successfully
        if (file == NULL) {
            printf("Could not open the file.\n");
            return 1; // Exit with an error code
        }
    
        // Count words in the file
        while ((ch = fgetc(file)) != EOF) {
            if (ch == ' ' || ch == '\n' || ch == '\t') {
                wordCount++;
            }
        }
    
        // Close the file
        fclose(file);
    
        // Print the word count
        printf("Word count: %d\n", wordCount);
    
        return 0; // Exit successfully
    }
    ```
    
2. **Character Frequency:**
    
    ```c
    #include <stdio.h>
    
    int main() {
        FILE *inputFile, *outputFile;
        char ch;
        int frequency[256] = {0};
    
        // Open the input file in read mode
        inputFile = fopen("input.txt", "r");
    
        // Check if file is opened successfully
        if (inputFile == NULL) {
            printf("Could not open the input file.\n");
            return 1; // Exit with an error code
        }
    
        // Count character frequency
        while ((ch = fgetc(inputFile)) != EOF) {
            frequency[ch]++;
        }
    
        // Close the input file
        fclose(inputFile);
    
        // Open the output file in write mode
        outputFile = fopen("output.txt", "w");
    
        // Check if file is opened successfully
        if (outputFile == NULL) {
            printf("Could not open the output file.\n");
            return 1; // Exit with an error code
        }
    
        // Write character frequency to the output file
        for (int i = 0; i < 256; i++) {
            if (frequency[i] > 0) {
                fprintf(outputFile, "Character '%c' occurs %d times.\n", i, frequency[i]);
            }
        }
    
        // Close the output file
        fclose(outputFile);
    
        return 0; // Exit successfully
    }
    ```
    
3. **File Copy:**
    
    ```c
    #include <stdio.h>
    
    int main() {
        FILE *sourceFile, *destinationFile;
        char ch;
    
        // Open the source file in read mode
        sourceFile = fopen("source.txt", "r");
    
        // Check if file is opened successfully
        if (sourceFile == NULL) {
            printf("Could not open the source file.\n");
            return 1; // Exit with an error code
        }
    
        // Open the destination file in write mode
        destinationFile = fopen("destination.txt", "w");
    
        // Check if file is opened successfully
        if (destinationFile == NULL) {
            printf("Could not open the destination file.\n");
            fclose(sourceFile); // Close the source file before exiting
            return 1; // Exit with an error code
        }
    
        // Copy the contents of the source file to the destination file
        while ((ch = fgetc(sourceFile)) != EOF) {
            fputc(ch, destinationFile);
        }
    
        // Close both files
        fclose(sourceFile);
        fclose(destinationFile);
    
        return 0; // Exit successfully
    }
    ```
    
4. **Line Numbers:**
    
    ```c
    #include <stdio.h>
    
    int main() {
        FILE *inputFile, *outputFile;
        char line[100];
        int lineNumber = 1;
    
        // Open the input file in read mode
        inputFile = fopen("input.txt", "r");
    
        // Check if file is opened successfully
        if (inputFile == NULL) {
            printf("Could not open the input file.\n");
            return 1; // Exit with an error code
        }
    
        // Open the output file in write mode
        outputFile = fopen("output.txt", "w");
    
        // Check if file is opened successfully
        if (outputFile == NULL) {
            printf("Could not open the output file.\n");
            fclose(inputFile); // Close the input file before exiting
            return 1; // Exit with an error code
        }
    
        // Read each line and print with line numbers
        while (fgets(line, sizeof(line), inputFile) != NULL) {
            fprintf(outputFile, "%d: %s", lineNumber, line);
            lineNumber++;
        }
    
        // Close both files
        fclose(inputFile);
        fclose(outputFile);
    
        return 0; // Exit successfully
    }
    ```
    
5. **File Encryption:**
    
    ```c
    #include <stdio.h>
    
    int main() {
        FILE *inputFile, *outputFile;
        char ch;
    
        // Open the input file in read mode
        inputFile = fopen("input.txt", "r");
    
        // Check if file is opened successfully
        if (inputFile == NULL) {
            printf("Could not open the input file.\n");
            return 1; // Exit with an error code
        }
    
        // Open the output file in write mode
        outputFile = fopen("output.txt", "w");
    
        // Check if file is opened successfully
        if (outputFile == NULL) {
            printf("Could not open the output file.\n");
            fclose(inputFile); // Close the input file before exiting
            return 1; // Exit with an error code
        }
    
        // Encrypt and write to the output file
        while ((ch = fgetc(inputFile)) != EOF) {
            fputc(ch + 1, outputFile); // Simple encryption by shifting characters by 1
        }
    
        // Close both files
        fclose(inputFile);
        fclose(outputFile);
    
        return 0; // Exit successfully
    }
    ```
    
6. **File Concatenation:**
    
    ```c
    #include <stdio.h>
    
    int main() {
        FILE *file1, *file2, *outputFile;
        char ch;
    
        // Open the first file in read mode
        file1 = fopen("file1.txt", "r");
    
        // Check if file is opened successfully
        if (file1 == NULL) {
            printf("Could not open file1.\n");
            return 1; // Exit with an error code
        }
    
        // Open the second file in read mode
        file2 = fopen("file2.txt", "r");
    
        // Check if file is opened successfully
        if (file2 == NULL) {
            printf("Could not open file2.\n");
            fclose(file1); // Close the first file before exiting
            return 1; // Exit with an error code
        }
    
        // Open the output file in write mode
        outputFile = fopen("output.txt", "w");
    
        // Check if file is opened successfully
        if (outputFile == NULL) {
            printf("Could not open the output file.\n");
            fclose(file1); // Close the first file before exiting
            fclose(file2); // Close the second file before exiting
            return 1; // Exit with an error code
        }
    
        // Copy the contents of file1 to the output file
        while ((ch = fgetc(file1)) != EOF) {
            fputc(ch, outputFile);
        }
    
        // Copy the contents of file2 to the output file
        while ((ch = fgetc(file2)) != EOF) {
            fputc(ch, outputFile);
        }
    
        // Close all files
        fclose(file1);
        fclose(file2);
        fclose(outputFile);
    
        return 0; // Exit successfully
    }
    ```
    
7. **Record Management:**
    
    ```c
    #include <stdio.h>
    #include <stdlib.h>
    
    // Define a structure for a record
    struct Record {
        int id;
        char name[50];
        float salary;
    };
    
    // Function to display the menu
    void displayMenu() {
        printf("\nRecord Management System\n");
        printf("1. Add Record\n");
        printf("2. Delete Record\n");
        printf("3. Search Record\n");
        printf("4. Modify Record\n");
        printf("5. Display All Records\n");
        printf("6. Exit\n");
        printf("Enter your choice: ");
    }
    
    // Function to add a new record
    void addRecord(FILE *file) {
        struct Record record;
    
        printf("Enter ID: ");
        scanf("%d", &record.id);
        printf("Enter name: ");
        scanf("%s", record.name);
        printf("Enter salary: ");
        scanf("%f", &record.salary);
    
        // Write the record to the file
        fseek(file, 0, SEEK_END);
        fwrite(&record, sizeof(struct Record), 1, file);
    
        printf("Record added successfully.\n");
    }
    
    // Function to delete a record
    void deleteRecord(FILE *file) {
        int targetID;
        printf("Enter the ID to delete: ");
        scanf("%d", &targetID);
    
        FILE *tempFile = fopen("temp.dat", "wb");
        struct Record record;
    
        // Copy records to the temporary file, excluding the one to delete
        while (fread(&record, sizeof(struct Record), 1, file) == 1) {
            if (record.id != targetID) {
                fwrite(&record, sizeof(struct Record), 1, tempFile);
            }
        }
    
        fclose(file);
        fclose(tempFile);
    
        // Remove the original file
        remove("records.dat");
    
        // Rename the temporary file to the original file name
        rename("temp.dat", "records.dat");
    
        printf("Record deleted successfully.\n");
    }
    
    // Function to search for a record by ID
    void searchRecord(FILE *file) {
        int targetID;
        printf("Enter the ID to search: ");
        scanf("%d", &targetID);
    
        struct Record record;
    
        // Search for the record by ID
        fseek(file, 0, SEEK_SET);
        while (fread(&record, sizeof(struct Record), 1, file) == 1) {
            if (record.id == targetID) {
                printf("Record found:\n");
                printf("ID: %d, Name: %s, Salary: %.2f\n", record.id, record.name, record.salary);
                return; // Record found, no need to continue searching
            }
        }
    
        printf("Record with ID %d not found.\n", targetID);
    }
    
    // Function to modify a record
    void modifyRecord(FILE *file) {
        int targetID;
        printf("Enter the ID to modify: ");
        scanf("%d", &targetID);
    
        struct Record record;
    
        // Search for the record by ID
        fseek(file, 0, SEEK_SET);
        while (fread(&record, sizeof(struct Record), 1, file) == 1) {
            if (record.id == targetID) {
                printf("Enter new name: ");
                scanf("%s", record.name);
                printf("Enter new salary: ");
                scanf("%f", &record.salary);
    
                // Write the modified record back to the file
                fseek(file, -sizeof(struct Record), SEEK_CUR);
                fwrite(&record, sizeof(struct Record), 1, file);
    
                printf("Record modified successfully.\n");
                return; // Record modified, no need to continue searching
            }
        }
    
        printf("Record with ID %d not found.\n", targetID);
    }
    
    // Function to display all records
    void displayAllRecords(FILE *file) {
        struct Record record;
    
        // Display all records in the file
        fseek(file, 0, SEEK_SET);
        while (fread(&record, sizeof(struct Record), 1, file) == 1) {
            printf("ID: %d, Name: %s, Salary: %.2f\n", record.id, record.name, record.salary);
        }
    }
    
    int main() {
        FILE *file = fopen("records.dat", "ab+");
    
        // Check if the file is opened successfully
        if (file == NULL) {
            printf("Could not open the file.\n");
            return 1; // Exit with an error code
        }
    
        int choice;
    
        do {
            displayMenu();
            scanf("%d", &choice);
    
            switch (choice) {
                case 1:
                    addRecord(file);
                    break;
                case 2:
                    deleteRecord(file);
                    break;
                case 3:
                    searchRecord(file);
                    break;
                case 4:
                    modifyRecord(file);
                    break;
                case 5:
                    displayAllRecords(file);
                    break;
                case 6:
                    printf("Exiting the program.\n");
                    break;
                default:
                    printf("Invalid choice. Please enter a valid option.\n");
            }
    
        } while (choice != 6);
    
        fclose(file);
    
        return 0; // Exit successfully
    }
    ```
    
8. **File Search:**
    
    ```c
    #include <stdio.h>
    #include <string.h>
    
    int main() {
        FILE *file;
        char line[100], searchWord[20];
        int lineNumber = 1;
    
        // Open the file in read mode
        file = fopen("textfile.txt", "r");
    
        // Check if file is opened successfully
        if (file == NULL) {
            printf("Could not open the file.\n");
            return 1; // Exit with an error code
        }
    
        // Get the word to search
        printf("Enter the word to search: ");
        scanf("%s", searchWord);
    
        // Search for the word and print line numbers
        while (fgets(line, sizeof(line), file) != NULL) {
            if (strstr(line, searchWord) != NULL) {
                printf("Word found at line %d: %s", lineNumber, line);
            }
            lineNumber++;
        }
    
        // Close the file
        fclose(file);
    
        return 0; // Exit successfully
    }
    ```
    
9. **CSV File Handling:**
    
    ```c
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    // Define a structure for an employee record
    struct Employee {
        int id;
        char name[50];
        float salary;
    };
    
    // Function to read records from a CSV file
    int readCSVFile(const char *filename, struct Employee **employees) {
        FILE *file = fopen(filename, "r");
        
        // Check if the file is opened successfully
        if (file == NULL) {
            printf("Could not open the file.\n");
            return -1; // Return an error code
        }
    
        int capacity = 10; // Initial capacity for records array
        int size = 0;      // Current size of records array
        *employees = malloc(capacity * sizeof(struct Employee));
    
        // Check if memory allocation is successful
        if (*employees == NULL) {
            printf("Memory allocation failed.\n");
            fclose(file); // Close the file before exiting
            return -1;    // Return an error code
        }
    
        // Read records from the CSV file
        while (fscanf(file, "%d,%49[^,],%f\n", &(*employees)[size].id, (*employees)[size].name, &(*employees)[size].salary) == 3) {
            size++;
    
            // Check if the records array needs to be resized
            if (size >= capacity) {
                capacity *= 2;
                *employees = realloc(*employees, capacity * sizeof(struct Employee));
    
                // Check if memory reallocation is successful
                if (*employees == NULL) {
                    printf("Memory reallocation failed.\n");
                    fclose(file); // Close the file before exiting
                    return -1;    // Return an error code
                }
            }
        }
    
        fclose(file); // Close the file
    
        return size;  // Return the number of records read
    }
    
    // Function to print records
    void printRecords(struct Employee *employees, int size) {
        printf("ID\tName\t\tSalary\n");
        for (int i = 0; i < size; i++) {
            printf("%d\t%-15s\t%.2f\n", employees[i].id, employees[i].name, employees[i].salary);
        }
    }
    
    // Function to compare records for sorting by ID
    int compareByID(const void *a, const void *b) {
        return ((struct Employee *)a)->id - ((struct Employee *)b)->id;
    }
    
    // Function to filter records by salary threshold
    void filterBySalary(struct Employee *employees, int size, float threshold) {
        printf("\nEmployees with Salary above %.2f:\n", threshold);
        printf("ID\tName\t\tSalary\n");
        for (int i = 0; i < size; i++) {
            if (employees[i].salary > threshold) {
                printf("%d\t%-15s\t%.2f\n", employees[i].id, employees[i].name, employees[i].salary);
            }
        }
    }
    
    int main() {
        const char *filename = "employees.csv";
        struct Employee *employees;
        int size;
    
        // Read records from the CSV file
        size = readCSVFile(filename, &employees);
    
        // Check if reading the file was successful
        if (size == -1) {
            return 1; // Exit with an error code
        }
    
        // Display the original records
        printf("Original Records:\n");
        printRecords(employees, size);
    
        // Sort records by ID
        qsort(employees, size, sizeof(struct Employee), compareByID);
        printf("\nRecords after sorting by ID:\n");
        printRecords(employees, size);
    
        // Filter records by salary threshold (example: 50000)
        filterBySalary(employees, size, 50000);
    
        // Free allocated memory
        free(employees);
    
        return 0; // Exit successfully
    }
    ```
    
10. **File Deletion:**
    
    ```c
    #include <stdio.h>
    #include <stdlib.h>
    
    int main() {
        FILE *file, *tempFile;
        char line[100];
        int lineToDelete;
    
        // Open the file in read mode
        file = fopen("data.txt", "r");
    
        // Check if file is opened successfully
        if (file == NULL) {
            printf("Could not open the file.\n");
            return 1; // Exit with an error code
        }
    
        // Open a temporary file in write mode
        tempFile = fopen("temp.txt", "w");
    
        // Check if file is opened successfully
        if (tempFile == NULL) {
            printf("Could not open the temporary file.\n");
            fclose(file); // Close the file before exiting
            return 1; // Exit with an error code
        }
    
        // Get the line number to delete
        printf("Enter the line number to delete: ");
        scanf("%d", &lineToDelete);
    
        // Copy lines to the temporary file, excluding the specified line
        int currentLine = 1;
        while (fgets(line, sizeof(line), file) != NULL) {
            if (currentLine != lineToDelete) {
                fprintf(tempFile, "%s", line);
            }
            currentLine++;
        }
    
        // Close both files
        fclose(file);
        fclose(tempFile);
    
        // Remove the original file
        remove("data.txt");
    
        // Rename the temporary file to the original file name
        rename("temp.txt", "data.txt");
    
        return 0; // Exit successfully
    }
    ```