Project: Student Record Management System in C with File Storage

drwxr-xr-x2026-01-135 min0 views

A Student Record Management System is a fundamental database application that demonstrates core programming concepts including CRUD operations (Create, Read, Update, Delete), file handling for data persistence, and structured data management [web:324][web:325]. This console-based project allows users to manage student information such as name, roll number, course, marks, and grades through an interactive menu system, storing all data in files to preserve records between program executions [web:323][web:329]. The system implements file I/O operations using fopen, fclose, fread, and fwrite functions from C's standard library, enabling permanent storage of student records in binary or text format that persists beyond program termination. Building this project provides hands-on experience with real-world data management scenarios similar to those found in school administration systems, library databases, and enterprise resource planning applications.

This comprehensive tutorial guides you through building a complete student management system from scratch, covering project structure with student data model definition using structures, file operations including opening, reading, writing, and closing files with proper error handling, implementing CRUD operations for adding new records, displaying all students, searching by roll number or name, updating existing information, and deleting records, designing a menu-driven interface for user interaction, handling edge cases and validation, and following best practices for file management and memory safety [web:325][web:326]. The complete working code demonstrates professional programming techniques including modular function design, robust error handling, and data persistence—essential skills for building real-world applications.

Project Structure and Data Model

The foundation of the management system is a well-designed student structure containing all necessary fields for student information [web:331]. The structure encapsulates related data into a single unit, and an array or linked list of these structures manages multiple student records efficiently.

cproject_structure.c

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

// Define constants
#define MAX_NAME_LENGTH 50
#define MAX_COURSE_LENGTH 30
#define FILENAME "students.dat"

// Student structure definition
typedef struct {
    int rollNumber;
    char name[MAX_NAME_LENGTH];
    char course[MAX_COURSE_LENGTH];
    float marks;
    char grade;
    int isActive;  // 1 = active, 0 = deleted
} Student;

// Project Features:
// 1. Add new student record
// 2. Display all students
// 3. Search student by roll number
// 4. Search student by name
// 5. Update student information
// 6. Delete student record
// 7. Calculate and assign grade
// 8. File-based persistence

// Grade calculation function
char calculateGrade(float marks) {
    if (marks >= 90) return 'A';
    else if (marks >= 80) return 'B';
    else if (marks >= 70) return 'C';
    else if (marks >= 60) return 'D';
    else if (marks >= 50) return 'E';
    else return 'F';
}

int main() {
    printf("=== Student Record Management System ===\n\n");
    
    printf("Data Structure:\n");
    printf("  - Roll Number (unique identifier)\n");
    printf("  - Name (student name)\n");
    printf("  - Course (enrolled course)\n");
    printf("  - Marks (academic score)\n");
    printf("  - Grade (calculated from marks)\n");
    printf("  - Status (active/deleted)\n\n");
    
    printf("Storage: Binary file (students.dat)\n");
    printf("Operations: Create, Read, Update, Delete\n");
    
    return 0;
}

Binary vs Text Files: Binary files store data in exact memory format using fwrite/fread, offering faster access and smaller file sizes [web:245]. Text files are human-readable but require parsing and conversion.

File Operations and Helper Functions

File handling forms the backbone of data persistence, using functions like fopen to open files in various modes, fread to read data from files into structures, fwrite to write structure data to files, and fclose to properly close files and flush buffers [web:245][web:330]. Proper error checking ensures file operations succeed before proceeding with data manipulation.

cfile_operations.c

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

#define MAX_NAME_LENGTH 50
#define MAX_COURSE_LENGTH 30
#define FILENAME "students.dat"

typedef struct {
    int rollNumber;
    char name[MAX_NAME_LENGTH];
    char course[MAX_COURSE_LENGTH];
    float marks;
    char grade;
    int isActive;
} Student;

// Check if file exists
int fileExists(const char *filename) {
    FILE *file = fopen(filename, "rb");
    if (file) {
        fclose(file);
        return 1;
    }
    return 0;
}

// Create new file if doesn't exist
void initializeFile() {
    if (!fileExists(FILENAME)) {
        FILE *file = fopen(FILENAME, "wb");
        if (file == NULL) {
            printf("Error: Unable to create file\n");
            exit(1);
        }
        fclose(file);
        printf("Database file created successfully\n");
    }
}

// Count total records in file
int countRecords() {
    FILE *file = fopen(FILENAME, "rb");
    if (file == NULL) {
        return 0;
    }
    
    int count = 0;
    Student student;
    
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.isActive) {
            count++;
        }
    }
    
    fclose(file);
    return count;
}

// Check if roll number exists
int rollNumberExists(int rollNumber) {
    FILE *file = fopen(FILENAME, "rb");
    if (file == NULL) {
        return 0;
    }
    
    Student student;
    
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.isActive && student.rollNumber == rollNumber) {
            fclose(file);
            return 1;
        }
    }
    
    fclose(file);
    return 0;
}

// Get next available roll number
int getNextRollNumber() {
    FILE *file = fopen(FILENAME, "rb");
    if (file == NULL) {
        return 1;  // First student
    }
    
    int maxRoll = 0;
    Student student;
    
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.rollNumber > maxRoll) {
            maxRoll = student.rollNumber;
        }
    }
    
    fclose(file);
    return maxRoll + 1;
}

// Display file information
void displayFileInfo() {
    printf("\n=== Database Information ===\n");
    printf("File: %s\n", FILENAME);
    printf("Total Records: %d\n", countRecords());
    printf("File Size: %ld bytes\n", 
           countRecords() * sizeof(Student));
}

int main() {
    initializeFile();
    displayFileInfo();
    
    return 0;
}

Always Check fopen Return: fopen returns NULL if file cannot be opened [web:245]. Always check this before using the file pointer to prevent segmentation faults and data corruption.

Create Operation: Adding Student Records

The Create operation adds new student records to the database by accepting user input, validating the data, calculating the grade based on marks, and appending the record to the file using append mode [web:323][web:324]. The "ab" mode opens the file for appending in binary format, preserving existing data while adding new records at the end.

ccreate_operation.c

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

#define MAX_NAME_LENGTH 50
#define MAX_COURSE_LENGTH 30
#define FILENAME "students.dat"

typedef struct {
    int rollNumber;
    char name[MAX_NAME_LENGTH];
    char course[MAX_COURSE_LENGTH];
    float marks;
    char grade;
    int isActive;
} Student;

char calculateGrade(float marks) {
    if (marks >= 90) return 'A';
    else if (marks >= 80) return 'B';
    else if (marks >= 70) return 'C';
    else if (marks >= 60) return 'D';
    else if (marks >= 50) return 'E';
    else return 'F';
}

int rollNumberExists(int rollNumber) {
    FILE *file = fopen(FILENAME, "rb");
    if (file == NULL) return 0;
    
    Student student;
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.isActive && student.rollNumber == rollNumber) {
            fclose(file);
            return 1;
        }
    }
    fclose(file);
    return 0;
}

// Add new student record
void addStudent() {
    Student student;
    FILE *file;
    
    printf("\n=== Add New Student ===\n\n");
    
    // Input roll number with validation
    printf("Enter Roll Number: ");
    scanf("%d", &student.rollNumber);
    
    // Check for duplicate roll number
    if (rollNumberExists(student.rollNumber)) {
        printf("Error: Roll number already exists!\n");
        return;
    }
    
    // Clear input buffer
    while (getchar() != '\n');
    
    // Input name
    printf("Enter Name: ");
    fgets(student.name, MAX_NAME_LENGTH, stdin);
    student.name[strcspn(student.name, "\n")] = 0;  // Remove newline
    
    // Input course
    printf("Enter Course: ");
    fgets(student.course, MAX_COURSE_LENGTH, stdin);
    student.course[strcspn(student.course, "\n")] = 0;
    
    // Input marks with validation
    do {
        printf("Enter Marks (0-100): ");
        scanf("%f", &student.marks);
        
        if (student.marks < 0 || student.marks > 100) {
            printf("Invalid marks! Please enter between 0 and 100.\n");
        }
    } while (student.marks < 0 || student.marks > 100);
    
    // Calculate grade
    student.grade = calculateGrade(student.marks);
    
    // Mark as active
    student.isActive = 1;
    
    // Open file in append binary mode
    file = fopen(FILENAME, "ab");
    if (file == NULL) {
        printf("Error: Unable to open file\n");
        return;
    }
    
    // Write student record to file
    if (fwrite(&student, sizeof(Student), 1, file) == 1) {
        printf("\nStudent added successfully!\n");
        printf("Roll No: %d\n", student.rollNumber);
        printf("Name: %s\n", student.name);
        printf("Course: %s\n", student.course);
        printf("Marks: %.2f\n", student.marks);
        printf("Grade: %c\n", student.grade);
    } else {
        printf("Error: Failed to write record\n");
    }
    
    fclose(file);
}

int main() {
    // Create file if doesn't exist
    FILE *file = fopen(FILENAME, "ab");
    if (file) fclose(file);
    
    addStudent();
    
    return 0;
}

// File modes explanation:
// "rb"  - Read binary (file must exist)
// "wb"  - Write binary (creates/truncates file)
// "ab"  - Append binary (creates if not exists, writes at end)
// "rb+" - Read/write binary (file must exist)
// "wb+" - Read/write binary (creates/truncates file)
// "ab+" - Read/append binary (creates if not exists)

Read Operation: Displaying Student Records

The Read operation retrieves and displays all active student records from the file using fread in a loop until end-of-file is reached [web:245]. The function reads one Student structure at a time, checks if the record is active, and formats the output in a table for better readability.

cread_operation.c

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

#define MAX_NAME_LENGTH 50
#define MAX_COURSE_LENGTH 30
#define FILENAME "students.dat"

typedef struct {
    int rollNumber;
    char name[MAX_NAME_LENGTH];
    char course[MAX_COURSE_LENGTH];
    float marks;
    char grade;
    int isActive;
} Student;

// Display all student records
void displayAllStudents() {
    FILE *file = fopen(FILENAME, "rb");
    Student student;
    int count = 0;
    
    if (file == NULL) {
        printf("Error: Unable to open file\n");
        return;
    }
    
    printf("\n=== All Student Records ===\n\n");
    
    // Print table header
    printf("%-10s %-25s %-20s %-10s %-6s\n", 
           "Roll No", "Name", "Course", "Marks", "Grade");
    printf("-------------------------------------------------------------------\n");
    
    // Read and display each record
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.isActive) {
            printf("%-10d %-25s %-20s %-10.2f %-6c\n",
                   student.rollNumber,
                   student.name,
                   student.course,
                   student.marks,
                   student.grade);
            count++;
        }
    }
    
    printf("-------------------------------------------------------------------\n");
    printf("Total Records: %d\n", count);
    
    if (count == 0) {
        printf("No records found in database.\n");
    }
    
    fclose(file);
}

// Display student statistics
void displayStatistics() {
    FILE *file = fopen(FILENAME, "rb");
    Student student;
    int count = 0;
    float totalMarks = 0;
    float maxMarks = 0;
    float minMarks = 100;
    
    if (file == NULL) {
        printf("Error: Unable to open file\n");
        return;
    }
    
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.isActive) {
            count++;
            totalMarks += student.marks;
            if (student.marks > maxMarks) maxMarks = student.marks;
            if (student.marks < minMarks) minMarks = student.marks;
        }
    }
    
    fclose(file);
    
    if (count > 0) {
        printf("\n=== Student Statistics ===\n");
        printf("Total Students: %d\n", count);
        printf("Average Marks: %.2f\n", totalMarks / count);
        printf("Highest Marks: %.2f\n", maxMarks);
        printf("Lowest Marks: %.2f\n", minMarks);
    } else {
        printf("No records to analyze.\n");
    }
}

int main() {
    displayAllStudents();
    printf("\n");
    displayStatistics();
    
    return 0;
}

fread Return Value: fread returns the number of elements successfully read [web:245]. Use this in the loop condition to detect end-of-file: while(fread(&student, sizeof(Student), 1, file) == 1).

Search Operations: Finding Student Records

Search operations allow finding specific students by roll number or name by reading the file sequentially and comparing each record's fields with the search criteria [web:324][web:326]. Implementing both exact match and partial match searches provides flexibility in locating student information.

csearch_operations.c

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

#define MAX_NAME_LENGTH 50
#define MAX_COURSE_LENGTH 30
#define FILENAME "students.dat"

typedef struct {
    int rollNumber;
    char name[MAX_NAME_LENGTH];
    char course[MAX_COURSE_LENGTH];
    float marks;
    char grade;
    int isActive;
} Student;

void displayStudent(Student *student) {
    printf("\nRoll Number: %d\n", student->rollNumber);
    printf("Name: %s\n", student->name);
    printf("Course: %s\n", student->course);
    printf("Marks: %.2f\n", student->marks);
    printf("Grade: %c\n", student->grade);
}

// Search by roll number
void searchByRollNumber() {
    FILE *file = fopen(FILENAME, "rb");
    Student student;
    int rollNumber;
    int found = 0;
    
    if (file == NULL) {
        printf("Error: Unable to open file\n");
        return;
    }
    
    printf("\n=== Search by Roll Number ===\n\n");
    printf("Enter Roll Number: ");
    scanf("%d", &rollNumber);
    
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.isActive && student.rollNumber == rollNumber) {
            printf("\nStudent Found!\n");
            displayStudent(&student);
            found = 1;
            break;
        }
    }
    
    if (!found) {
        printf("\nStudent with Roll Number %d not found.\n", rollNumber);
    }
    
    fclose(file);
}

// Convert string to lowercase for case-insensitive comparison
void toLowerCase(char *str) {
    for (int i = 0; str[i]; i++) {
        str[i] = tolower(str[i]);
    }
}

// Search by name (partial match, case-insensitive)
void searchByName() {
    FILE *file = fopen(FILENAME, "rb");
    Student student;
    char searchName[MAX_NAME_LENGTH];
    char studentNameLower[MAX_NAME_LENGTH];
    char searchNameLower[MAX_NAME_LENGTH];
    int found = 0;
    
    if (file == NULL) {
        printf("Error: Unable to open file\n");
        return;
    }
    
    printf("\n=== Search by Name ===\n\n");
    printf("Enter Name (or part of name): ");
    
    // Clear input buffer
    while (getchar() != '\n');
    
    fgets(searchName, MAX_NAME_LENGTH, stdin);
    searchName[strcspn(searchName, "\n")] = 0;
    
    // Convert search term to lowercase
    strcpy(searchNameLower, searchName);
    toLowerCase(searchNameLower);
    
    printf("\nSearch Results:\n");
    printf("-------------------------------------------------------------------\n");
    
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.isActive) {
            // Convert student name to lowercase for comparison
            strcpy(studentNameLower, student.name);
            toLowerCase(studentNameLower);
            
            // Check if search term is found in student name
            if (strstr(studentNameLower, searchNameLower) != NULL) {
                displayStudent(&student);
                printf("-------------------------------------------------------------------\n");
                found = 1;
            }
        }
    }
    
    if (!found) {
        printf("No students found matching \"%s\"\n", searchName);
    }
    
    fclose(file);
}

// Search by course
void searchByCourse() {
    FILE *file = fopen(FILENAME, "rb");
    Student student;
    char searchCourse[MAX_COURSE_LENGTH];
    int found = 0;
    
    if (file == NULL) {
        printf("Error: Unable to open file\n");
        return;
    }
    
    printf("\n=== Search by Course ===\n\n");
    printf("Enter Course: ");
    
    while (getchar() != '\n');
    fgets(searchCourse, MAX_COURSE_LENGTH, stdin);
    searchCourse[strcspn(searchCourse, "\n")] = 0;
    
    printf("\nStudents in %s:\n", searchCourse);
    printf("-------------------------------------------------------------------\n");
    
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.isActive && strcmp(student.course, searchCourse) == 0) {
            displayStudent(&student);
            printf("-------------------------------------------------------------------\n");
            found = 1;
        }
    }
    
    if (!found) {
        printf("No students found in course \"%s\"\n", searchCourse);
    }
    
    fclose(file);
}

int main() {
    int choice;
    
    printf("\n=== Search Menu ===\n");
    printf("1. Search by Roll Number\n");
    printf("2. Search by Name\n");
    printf("3. Search by Course\n");
    printf("\nEnter choice: ");
    scanf("%d", &choice);
    
    switch (choice) {
        case 1:
            searchByRollNumber();
            break;
        case 2:
            searchByName();
            break;
        case 3:
            searchByCourse();
            break;
        default:
            printf("Invalid choice\n");
    }
    
    return 0;
}

Update Operation: Modifying Student Records

The Update operation modifies existing student records by locating the record using fseek to position the file pointer, reading the current data, allowing modification of specific fields, and writing the updated record back using fwrite [web:323][web:326]. The file is opened in "rb+" mode enabling both reading and writing without truncating existing data.

cupdate_operation.c

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

#define MAX_NAME_LENGTH 50
#define MAX_COURSE_LENGTH 30
#define FILENAME "students.dat"

typedef struct {
    int rollNumber;
    char name[MAX_NAME_LENGTH];
    char course[MAX_COURSE_LENGTH];
    float marks;
    char grade;
    int isActive;
} Student;

char calculateGrade(float marks) {
    if (marks >= 90) return 'A';
    else if (marks >= 80) return 'B';
    else if (marks >= 70) return 'C';
    else if (marks >= 60) return 'D';
    else if (marks >= 50) return 'E';
    else return 'F';
}

void displayStudent(Student *student) {
    printf("\nCurrent Information:\n");
    printf("Roll Number: %d\n", student->rollNumber);
    printf("Name: %s\n", student->name);
    printf("Course: %s\n", student->course);
    printf("Marks: %.2f\n", student->marks);
    printf("Grade: %c\n", student->grade);
}

// Update student record
void updateStudent() {
    FILE *file = fopen(FILENAME, "rb+");
    Student student;
    int rollNumber;
    int found = 0;
    long position;
    
    if (file == NULL) {
        printf("Error: Unable to open file\n");
        return;
    }
    
    printf("\n=== Update Student Record ===\n\n");
    printf("Enter Roll Number to update: ");
    scanf("%d", &rollNumber);
    
    // Search for the student
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.isActive && student.rollNumber == rollNumber) {
            found = 1;
            
            // Get current file position (start of this record)
            position = ftell(file) - sizeof(Student);
            
            displayStudent(&student);
            
            // Update menu
            int choice;
            printf("\nWhat would you like to update?\n");
            printf("1. Name\n");
            printf("2. Course\n");
            printf("3. Marks\n");
            printf("4. All fields\n");
            printf("\nEnter choice: ");
            scanf("%d", &choice);
            
            // Clear input buffer
            while (getchar() != '\n');
            
            switch (choice) {
                case 1:  // Update name
                    printf("Enter new name: ");
                    fgets(student.name, MAX_NAME_LENGTH, stdin);
                    student.name[strcspn(student.name, "\n")] = 0;
                    break;
                
                case 2:  // Update course
                    printf("Enter new course: ");
                    fgets(student.course, MAX_COURSE_LENGTH, stdin);
                    student.course[strcspn(student.course, "\n")] = 0;
                    break;
                
                case 3:  // Update marks
                    do {
                        printf("Enter new marks (0-100): ");
                        scanf("%f", &student.marks);
                        if (student.marks < 0 || student.marks > 100) {
                            printf("Invalid! Enter between 0 and 100.\n");
                        }
                    } while (student.marks < 0 || student.marks > 100);
                    
                    // Recalculate grade
                    student.grade = calculateGrade(student.marks);
                    break;
                
                case 4:  // Update all fields
                    printf("Enter new name: ");
                    fgets(student.name, MAX_NAME_LENGTH, stdin);
                    student.name[strcspn(student.name, "\n")] = 0;
                    
                    printf("Enter new course: ");
                    fgets(student.course, MAX_COURSE_LENGTH, stdin);
                    student.course[strcspn(student.course, "\n")] = 0;
                    
                    do {
                        printf("Enter new marks (0-100): ");
                        scanf("%f", &student.marks);
                        if (student.marks < 0 || student.marks > 100) {
                            printf("Invalid! Enter between 0 and 100.\n");
                        }
                    } while (student.marks < 0 || student.marks > 100);
                    
                    student.grade = calculateGrade(student.marks);
                    break;
                
                default:
                    printf("Invalid choice. No changes made.\n");
                    fclose(file);
                    return;
            }
            
            // Move file pointer to the record position
            fseek(file, position, SEEK_SET);
            
            // Write updated record
            if (fwrite(&student, sizeof(Student), 1, file) == 1) {
                printf("\nRecord updated successfully!\n");
                displayStudent(&student);
            } else {
                printf("Error: Failed to update record\n");
            }
            
            break;
        }
    }
    
    if (!found) {
        printf("\nStudent with Roll Number %d not found.\n", rollNumber);
    }
    
    fclose(file);
}

int main() {
    updateStudent();
    return 0;
}

// fseek explanation:
// fseek(file, offset, whence)
// - offset: number of bytes to move
// - whence: SEEK_SET (from beginning), SEEK_CUR (from current),
//          SEEK_END (from end)
// ftell(file) returns current file position

File Pointer Positioning: Use fseek and ftell for random access to records [web:245]. ftell gets current position, fseek moves to specific position for in-place updates without rewriting entire file.

Delete Operation: Removing Student Records

The Delete operation marks records as inactive rather than physically removing them, implementing soft delete for data recovery and audit trails [web:323]. For hard delete, the program creates a temporary file, copies all active records except the one to delete, then replaces the original file with the temporary file.

cdelete_operation.c

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

#define MAX_NAME_LENGTH 50
#define MAX_COURSE_LENGTH 30
#define FILENAME "students.dat"
#define TEMP_FILE "temp.dat"

typedef struct {
    int rollNumber;
    char name[MAX_NAME_LENGTH];
    char course[MAX_COURSE_LENGTH];
    float marks;
    char grade;
    int isActive;
} Student;

// Soft delete - mark as inactive
void softDeleteStudent() {
    FILE *file = fopen(FILENAME, "rb+");
    Student student;
    int rollNumber;
    int found = 0;
    long position;
    
    if (file == NULL) {
        printf("Error: Unable to open file\n");
        return;
    }
    
    printf("\n=== Delete Student (Soft Delete) ===\n\n");
    printf("Enter Roll Number to delete: ");
    scanf("%d", &rollNumber);
    
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.isActive && student.rollNumber == rollNumber) {
            found = 1;
            position = ftell(file) - sizeof(Student);
            
            printf("\nStudent found:\n");
            printf("Name: %s\n", student.name);
            printf("Course: %s\n", student.course);
            
            printf("\nAre you sure you want to delete? (y/n): ");
            char confirm;
            scanf(" %c", &confirm);
            
            if (confirm == 'y' || confirm == 'Y') {
                // Mark as inactive
                student.isActive = 0;
                
                // Write back to file
                fseek(file, position, SEEK_SET);
                fwrite(&student, sizeof(Student), 1, file);
                
                printf("\nStudent record deleted successfully.\n");
            } else {
                printf("\nDeletion cancelled.\n");
            }
            
            break;
        }
    }
    
    if (!found) {
        printf("\nStudent with Roll Number %d not found.\n", rollNumber);
    }
    
    fclose(file);
}

// Hard delete - physically remove record
void hardDeleteStudent() {
    FILE *file = fopen(FILENAME, "rb");
    FILE *tempFile = fopen(TEMP_FILE, "wb");
    Student student;
    int rollNumber;
    int found = 0;
    int count = 0;
    
    if (file == NULL || tempFile == NULL) {
        printf("Error: Unable to open files\n");
        if (file) fclose(file);
        if (tempFile) fclose(tempFile);
        return;
    }
    
    printf("\n=== Delete Student (Hard Delete) ===\n\n");
    printf("Enter Roll Number to delete: ");
    scanf("%d", &rollNumber);
    
    // Copy all records except the one to delete
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (student.rollNumber == rollNumber && student.isActive) {
            found = 1;
            printf("\nDeleting student: %s (Roll: %d)\n", 
                   student.name, student.rollNumber);
        } else {
            // Write to temporary file
            fwrite(&student, sizeof(Student), 1, tempFile);
            if (student.isActive) count++;
        }
    }
    
    fclose(file);
    fclose(tempFile);
    
    if (found) {
        // Replace original file with temporary file
        remove(FILENAME);
        rename(TEMP_FILE, FILENAME);
        printf("Student deleted successfully.\n");
        printf("Remaining records: %d\n", count);
    } else {
        // Remove temporary file
        remove(TEMP_FILE);
        printf("\nStudent with Roll Number %d not found.\n", rollNumber);
    }
}

// Restore soft-deleted record
void restoreStudent() {
    FILE *file = fopen(FILENAME, "rb+");
    Student student;
    int rollNumber;
    int found = 0;
    long position;
    
    if (file == NULL) {
        printf("Error: Unable to open file\n");
        return;
    }
    
    printf("\n=== Restore Deleted Student ===\n\n");
    printf("Enter Roll Number to restore: ");
    scanf("%d", &rollNumber);
    
    while (fread(&student, sizeof(Student), 1, file) == 1) {
        if (!student.isActive && student.rollNumber == rollNumber) {
            found = 1;
            position = ftell(file) - sizeof(Student);
            
            printf("\nFound deleted student: %s\n", student.name);
            
            // Restore by marking as active
            student.isActive = 1;
            fseek(file, position, SEEK_SET);
            fwrite(&student, sizeof(Student), 1, file);
            
            printf("Student restored successfully.\n");
            break;
        }
    }
    
    if (!found) {
        printf("\nNo deleted record found with Roll Number %d.\n", 
               rollNumber);
    }
    
    fclose(file);
}

int main() {
    int choice;
    
    printf("\n=== Delete Menu ===\n");
    printf("1. Soft Delete (can be restored)\n");
    printf("2. Hard Delete (permanent)\n");
    printf("3. Restore Deleted Record\n");
    printf("\nEnter choice: ");
    scanf("%d", &choice);
    
    switch (choice) {
        case 1:
            softDeleteStudent();
            break;
        case 2:
            hardDeleteStudent();
            break;
        case 3:
            restoreStudent();
            break;
        default:
            printf("Invalid choice\n");
    }
    
    return 0;
}

Soft vs Hard Delete: Soft delete marks records inactive for recovery, while hard delete permanently removes data [web:323]. Use soft delete for audit trails and hard delete to reclaim disk space.

Complete Management System with Menu

The complete system integrates all CRUD operations into a menu-driven interface running in a continuous loop until the user exits [web:324][web:329]. This demonstrates professional application structure with clear separation of concerns, modular functions, and user-friendly navigation.

ccomplete_system.c

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

#define MAX_NAME_LENGTH 50
#define MAX_COURSE_LENGTH 30
#define FILENAME "students.dat"

typedef struct {
    int rollNumber;
    char name[MAX_NAME_LENGTH];
    char course[MAX_COURSE_LENGTH];
    float marks;
    char grade;
    int isActive;
} Student;

// Function prototypes
void displayMenu();
void addStudent();
void displayAllStudents();
void searchStudent();
void updateStudent();
void deleteStudent();
void initializeSystem();
void clearScreen();
void pauseScreen();

// Main function
int main() {
    int choice;
    
    initializeSystem();
    
    printf("\n" "==========================================\n");
    printf("  STUDENT RECORD MANAGEMENT SYSTEM\n");
    printf("==========================================\n\n");
    
    while (1) {
        displayMenu();
        printf("\nEnter your choice: ");
        scanf("%d", &choice);
        
        switch (choice) {
            case 1:
                addStudent();
                break;
            case 2:
                displayAllStudents();
                break;
            case 3:
                searchStudent();
                break;
            case 4:
                updateStudent();
                break;
            case 5:
                deleteStudent();
                break;
            case 6:
                printf("\nThank you for using the system!\n");
                exit(0);
            default:
                printf("\nInvalid choice! Please try again.\n");
        }
        
        pauseScreen();
    }
    
    return 0;
}

// Display main menu
void displayMenu() {
    printf("\n" "==========================================\n");
    printf("              MAIN MENU\n");
    printf("==========================================\n");
    printf("1. Add New Student\n");
    printf("2. Display All Students\n");
    printf("3. Search Student\n");
    printf("4. Update Student\n");
    printf("5. Delete Student\n");
    printf("6. Exit\n");
    printf("==========================================\n");
}

// Initialize system - create file if doesn't exist
void initializeSystem() {
    FILE *file = fopen(FILENAME, "ab");
    if (file == NULL) {
        printf("Error: Unable to initialize system\n");
        exit(1);
    }
    fclose(file);
}

// Clear screen
void clearScreen() {
    #ifdef _WIN32
        system("cls");
    #else
        system("clear");
    #endif
}

// Pause screen
void pauseScreen() {
    printf("\nPress Enter to continue...");
    while (getchar() != '\n');  // Clear input buffer
    getchar();  // Wait for Enter
}

// Note: Implement addStudent, displayAllStudents, searchStudent,
// updateStudent, and deleteStudent using code from previous sections

// Compile and run:
// gcc -o student_mgmt student_management.c
// ./student_mgmt

Best Practices and Error Handling

Professional file-based applications require robust error handling, input validation, and proper resource management to prevent data corruption and crashes. Following established patterns ensures reliable data persistence and user-friendly error messages when problems occur.

Always check fopen return: Verify FILE pointer is not NULL before using it to prevent segmentation faults [web:245]
Close files properly: Always call fclose after finishing file operations to flush buffers and free resources
Validate user input: Check ranges for marks, verify roll numbers don't duplicate, and sanitize string inputs
Use binary mode for structures: Open files with "b" flag (rb, wb) for structure I/O to avoid text conversion issues
Check fread/fwrite return values: Verify correct number of elements read/written to detect errors
Clear input buffers: Use while(getchar() != '\n') after scanf to prevent leftover characters causing issues
Implement soft delete: Mark records inactive instead of physical deletion for audit trails and recovery
Use temporary files for modifications: When restructuring data, write to temp file then rename to avoid corruption
Provide confirmation prompts: Ask for confirmation before destructive operations like deletion
Regular backups: Implement backup functionality to copy database file periodically

Project Enhancement Ideas

The basic student management system can be extended with advanced features to create a more sophisticated application suitable for real-world deployment. These enhancements demonstrate additional programming concepts and database management techniques.

Sorting functionality: Sort students by roll number, name, marks, or grade using sorting algorithms
Report generation: Create formatted reports with statistics, class averages, and grade distribution
Password protection: Add login system with username/password authentication for security [web:323]
Multiple subjects: Track marks for multiple subjects per student with overall GPA calculation
Attendance tracking: Add attendance records with date-wise tracking and percentage calculation
Export to CSV: Export student data to CSV format for spreadsheet analysis and reporting
Data import: Import student records from text or CSV files for bulk data entry
Advanced search: Search by grade range, marks range, or multiple criteria with filters
Linked list implementation: Use dynamic linked lists instead of file storage for in-memory operations [web:328]
Database indexing: Create index files for faster searches on large datasets

Conclusion

Building a Student Record Management System in C demonstrates mastery of fundamental database operations and file handling concepts essential for real-world application development. The project implements complete CRUD functionality through Create operations that add new student records using fwrite in append binary mode with validation for duplicate roll numbers and marks ranges, Read operations displaying all active records by reading the file sequentially with fread and formatting output in tables, Update operations modifying specific fields using fseek and ftell for random access positioning combined with in-place writes, and Delete operations offering both soft delete through isActive flags for recovery and hard delete physically removing records via temporary file creation. File handling leverages C's standard library functions where fopen with mode "rb+" enables simultaneous reading and writing without truncation, fread returns number of elements successfully read for loop control and error detection, fwrite persists structure data in binary format preserving exact memory representation, fseek positions file pointer for random access to specific records, ftell retrieves current position for update operations, and fclose flushes buffers and frees resources preventing data loss and memory leaks.

The system architecture follows professional practices through modular design separating each operation into dedicated functions improving code organization and maintainability, robust error handling checking fopen return values before file operations and validating all user input before processing, menu-driven interface providing intuitive navigation through continuous loop until user chooses exit, data persistence storing records in binary files that survive program termination enabling permanent record storage, and soft delete implementation marking records inactive instead of physical removal supporting audit trails and data recovery. Best practices mandate always checking FILE pointer for NULL after fopen to prevent crashes, closing files with fclose after operations to flush buffers and free resources, validating input ranges for marks and checking roll number uniqueness, using binary mode flags for structure I/O avoiding text conversion issues, clearing input buffers after scanf preventing leftover characters from causing subsequent read failures, and implementing confirmation prompts before destructive operations protecting against accidental data loss. Enhancement opportunities include sorting algorithms for ordering records by various fields, report generation with statistics and grade distribution analysis, password protection for security, multi-subject tracking with GPA calculation, attendance management, CSV export for spreadsheet integration, bulk import from files, advanced filtering and search capabilities, linked list implementation for dynamic memory management, and database indexing for performance optimization. This comprehensive project serves as an excellent foundation for understanding database management, file I/O operations, data structures, and real-world application development—skills directly transferable to enterprise software, web backends, embedded systems, and any domain requiring persistent data storage and manipulation.