VISVESVARAYA TECHNOLOGICAL UNIVERSITY

“JNANA SANGAMA”, Belagavi-590018

A Mini Project Report on

“Student Academic Record Management System”

SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENT FOR

THE AWARD OF DEGREE OF

BACHELOR OF ENGINEERING IN
INFORMATION SCIENCE AND ENGINEERING

SUBMITTED BY

ANINDYA KHANRA (1JB23IS019)

Under the Guidance of

Mrs. Shivani Bhat

Assistant Professor,
Dept. of ISE, SJBIT
Bengaluru-60

DEPARTMENT OF INFORMATION SCIENCE AND ENGINEERING

SJB INSTITUTE OF TECHNOLOGY
BGS HEALTH AND EDUCATION CITY, KENGERI, BENGALURU-560060, KARNATAKA, INDIA.

2024-2025
 || Jai Sri Gurudev ||
Sri Adichunchanagiri Shikshana Trust ®
SJB INSTITUTE OF TECHNOLOGY
BGS Health & Education City, Kengeri, Bengaluru – 560 060

Department of Information Science & Engineering

CERTIFICATE

Certified that the Mini project work entitled “Student Academic Record Management

System” carried out by Anindya Khanra bearing USN 1JB23IS019 and is a bonafide
student of SJB Institute of Technology in partial fulfilment for 3rd semester Mini Project in
INFORMATION SCIENCE AND ENGINEERING of the VISVESVARAYA
TECHNOLOGICAL UNIVERSITY, BELAGAVI during the academic year 2024-25. It is
certified that all corrections/suggestions indicated for Internal Assessment have been
incorporated in the report deposited in the departmental library. The mini project report has
been approved as it satisfies the academic requirements in respect of Mini Project prescribed
for the said degree.

Mrs. Shivani Bhat Dr. Shashidhara HR

Assistant Professor Professor & Head
Dept. of ISE, SJBIT Dept. of ISE, SJBIT

EXTERNAL VIVA

Name of the Examiners Signature with Date

1.

2.
 ACKNOWLEDGEMENT
We would like to express our profound gratitude to His Divine Soul Jagadguru Padma
Bhushan Sri Sri Sri Dr. Balagangadharanatha Mahaswamiji and His Holiness Jagadguru
Sri Sri Sri Dr. Nirmalanandanatha Swamiji for providing us an opportunity to be a part of
this esteemed institution.

We would also like to express our sincere thanks to Revered Sri Sri Dr. Prakashnath
Swamiji, Managing Director of SJB Institute of Technology, for his continuous support in
providing the necessary amenities to carry out this project at this esteemed institution.

We express our heartfelt gratitude to Dr. Puttaraju, Academic Director of the BGS and SJB
Group of Institutions, Dr. K. V. Mahendra Prashanth, Principal of SJB Institute of
Technology, and Dr. Shashidhara H R, Professor & Head of the Department of Information
Science and Engineering, for providing us outstanding amenities and for their unwavering
support, state-of-the-art facilities, and the enriching academic environment, which were
instrumental in the successful completion of our project work.

We extend our heartfelt gratitude to all the Deans of SJB Institute of Technology for their
unwavering support, cutting-edge facilities, and the inspiring academic environment, all of
which played a pivotal role in the successful completion of our project work.

We wish to express our heartfelt gratitude to our guide, Mrs. Shivani Bhat, Assistant
Professor, Dept of ISE for her valuable guidance, suggestions, and encouragement during the
entire period of our project work.

Finally, we take this opportunity to extend my earnest gratitude and respect to our parents, the
teaching & technical staff of the department, the library staff, and all my friends, who have
directly or indirectly supported me during the period of my project work.

Regards,
Anindya Khanra [1JB23IS019]
 ABSTRACT

The "Student Academic Record Management System" is an advanced application developed in

C to address the need for efficient, reliable, and scalable solutions in academic record
management. Designed for academic institutions, it dynamically manages student details,
calculates CGPA, and evaluates performance based on grades across various subjects. The
system employs a queue-based data structure and dynamic memory allocation for flexibility
and scalability, enabling the addition of subjects with credit allocation, capturing individual
student grades, and automated CGPA computation through credit-weighted averaging. It
identifies students failing to meet minimum performance standards and features dynamic
subject and student management, real-time grade validation, automated CGPA calculation, and
dynamic expansion to accommodate increasing data sizes. Its modular design ensures seamless
integration of components like student addition, subject management, and CGPA computation
while maintaining independent operation. Extensive testing validates its robustness against
invalid inputs, high data volumes, and edge cases. Future enhancements include database
integration for persistent storage, a graphical user interface for ease of use, and advanced
analytical features such as performance trends and predictions. By addressing challenges like
data scalability, real-time validation, and performance accuracy, this system exemplifies a
modern approach to academic data management, combining efficiency with user-friendliness
for educational institutions and administrators.
 TABLE OF CONTENTS

Sl. No. Chapters Page No

Acknowledgement
Abstract
Table of Contents
1 Introduction 1
1.1 Background Study 1-2
1.2 Objectives 2-3
1.3 Future Scope 4-5
1.4 Problem Statement 5
2 System Requirements Specification 6-8
3 System Design 9-11
4 Implementation 12-13
5 Testing 14-20
6 Snapshots 21-24
Conclusion 25
Future Enhancements 26
References 27
 LIST OF FIGURES

Figure No Title Page Number

1.1 Subject Add Function 14

1.2 Student Add Function 15
1.3 Initialization of Queue 16
2.1 Enqueue & Dequeue Function 17
2.2 Display Function 18
2.3 Delete Function 18
3.1 Main Function 20
4.1 Menu Option 21
4.2 Adding Subjects Details 21
4.3 Adding Student Details 22
4.4 Adding Student Details 22
4.5 Viewing Student Grade 23
4.6 Delete the Student Details By USN No 23
4.7 Exit 24
CHAPTER 1

INTRODUCTION

The project is a comprehensive system designed for managing student academic records
efficiently. It automates key operations such as adding subjects, recording student grades,
calculating CGPA (Cumulative Grade Point Average), and determining pass/fail status based
on predefined criteria.
This program addresses common challenges in academic record management, including
scalability, dynamic data handling, and accurate performance evaluation. Using queue-based
data structures and dynamic memory allocation, it ensures efficient management of student
data and adapts to varying input sizes seamlessly.
By integrating real-time grade validation and automated CGPA computation, the project not
only simplifies academic record-keeping but also provides a user-friendly solution that can be
scaled and extended for broader applications, such as database integration and analytical
reporting. This system is ideal for educational institutions seeking a reliable, fast, and scalable
solution for managing student records.

1.1Background Study
Efficient academic record management is an essential component of educational institutions
worldwide. Traditionally, this process relied on manual record-keeping methods, such as
ledgers and report cards. While effective for smaller datasets, these methods often struggled to
meet the demands of larger institutions, where maintaining accuracy and efficiency became
increasingly challenging. The introduction of computational tools like spreadsheets marked a
significant improvement, but these systems lacked automation, scalability, and real-time data
processing, necessitating more advanced solutions.
The emergence of programming languages like C revolutionized academic record management
by enabling the development of tailored solutions for handling student data. C programming is
well-suited for such applications due to its efficiency, close-to-hardware operation, and support
for essential features like dynamic memory allocation and data structures. These capabilities
allow for the creation of systems that are both resource-efficient and capable of handling
dynamic datasets.
This project, implemented in C, aims to address common challenges in academic record
management, such as scalability, accuracy, and adaptability. It provides functionalities to
dynamically add subjects, record student details, validate grades, calculate CGPA (Cumulative
Grade Point Average), and determine pass/fail status.

Dept. of ISE, SJBIT 2024–25 1

 Introduction

By leveraging a queue-based data structure and dynamic memory management, the system
ensures efficient handling of student records and adapts seamlessly to varying input sizes.
A queue-based approach is particularly advantageous for managing student records in an
orderly fashion. Using a FIFO (First-In-First-Out) method ensures fairness and simplifies data
retrieval and processing. Dynamic arrays further enhance flexibility by allowing the system to
accommodate variable numbers of subjects and grades. Together, these data structures form the
backbone of the system, enabling smooth execution of operations such as adding students,
managing grades, and calculating performance metrics.
CGPA, a widely used metric for evaluating academic performance, plays a central role in this
system. Accurate CGPA computation involves validating grades, applying credit-weighted
averaging, and determining overall performance status. This project automates these
calculations, eliminating the risk of human error and ensuring precise results. Additionally, the
system provides real-time feedback on grade inputs, ensuring data integrity and reliability.
The project also emphasizes modular design, where individual components, such as student
management and grade validation, operate independently while integrating seamlessly with the
overall system. This approach not only simplifies development and debugging but also makes
the system scalable and adaptable for future enhancements.
Compared to existing academic management solutions, which often include extensive features
but are resource-intensive, this project offers a lightweight and efficient alternative. It focuses
on core functionalities, making it ideal for small to medium-sized institutions seeking cost-
effective and reliable solutions. Moreover, its implementation in C ensures compatibility with
a wide range of hardware and software environments, further enhancing its usability.
In conclusion, the "Student Academic Record Management System" demonstrates the potential
of C programming in addressing critical challenges in academic data management. By
integrating dynamic data structures, modular programming, and automated computation, it lays
the foundation for scalable and efficient solutions. The system also offers significant scope for
future enhancements, including database integration, graphical interfaces, and advanced
analytics, ensuring its relevance in modern educational contexts.

1.2 Objectives
Efficient Management of Student Data
o Design a system to store, manage, and process student academic records
systematically using appropriate data structures like queues, arrays, and
dynamic memory allocation.

Dept. of ISE, SJBIT 2024–25 2

 Introduction
Implementation of Dynamic Queue
o Develop a queue-based mechanism to manage student information, enabling
efficient storage, retrieval, and processing of student records while dynamically
handling memory allocation.

Support for Subject and Grade Handling

o Allow the addition of multiple subjects with associated credit values and record
individual student grades in each subject.

CGPA Calculation
o Provide functionality to calculate the Cumulative Grade Point Average (CGPA)
for each student based on grades and subject credits, taking into account failure
criteria.

Dynamic Memory Utilization

o Ensure efficient utilization of memory by dynamically allocating space for
subjects, grades, and student data as the system scales.

Modular Functionality
o Implement modular functions to support key operations like adding subjects,
enrolling students, calculating CGPA, displaying records, and managing the
queue.

Validation of Input Data

o Incorporate mechanisms to validate user inputs for subjects, grades, and student
details, ensuring data accuracy and integrity.

Comprehensive Display of Results

o Provide functionality to display detailed student records, including individual
subject performance, CGPA, and whether they have passed or failed.

User Interaction
o Create an interactive menu-driven system to guide users through the various
operations, ensuring ease of use and clarity.

Scalability and Robustness

o Ensure the system can handle an increasing number of students and subjects
while maintaining consistent performance and reliability.
o

Dept. of ISE, SJBIT 2024–25 3

 Introduction

1.3 Future Scope

Integration with Persistent Storage
• Enable the system to store and retrieve data persistently using databases (e.g., MySQL,
SQLite) or file-based systems (e.g., JSON, CSV, XML).
• This would allow the system to retain student and subject records across multiple
sessions and facilitate long-term data analysis.

Advanced Search and Filtering Options

• Add functionality to search for students by name, roll number, or specific criteria like
grade ranges or CGPA.
• Implement filtering options to view students based on performance metrics, such as top
scorers or those requiring academic assistance.

Graphical User Interface (GUI)

• Develop a user-friendly interface using frameworks like Tkinter, JavaFX, or a web-
based frontend.
• Include features like clickable menus, dropdown options for subject selection, and real-
time data visualization using charts and graphs.

Advanced Reporting and Analytics

• Develop reporting tools to generate comprehensive summaries, such as department-
wide performance or subject-wise statistics.
• Introduce analytics features to identify trends, forecast outcomes, and suggest
improvement areas for students.

AI-Driven Insights
• Use machine learning algorithms to analyze student performance and predict academic
outcomes.
• Offer personalized recommendations for students, such as subject-specific study
materials or remedial classes.

Dept. of ISE, SJBIT 2024–25 4

 Introduction

Role-Based Access Control

• Designate roles like “Administrator,” “Faculty,” and “Student,” with tailored access
permissions.
• Provide dashboards specific to each role, ensuring secure and organized data handling.

Real-Time Data Visualization

• Add dynamic dashboards to showcase academic trends, performance metrics, and
statistical overviews.
• Include tools for graphical analysis, such as heatmaps for identifying problem areas in
subjects.

1.4 Problem Statement

Managing academic records efficiently is a critical requirement for educational institutions.
This includes tasks such as maintaining student personal information, enrolling students in
subjects, recording grades, calculating performance metrics like CGPA, and generating detailed
reports. However, manual or fragmented systems are often prone to errors, inefficiencies, and
scalability challenges.
The lack of a unified, dynamic, and reliable system can result in difficulties in handling large
volumes of data, ensuring data integrity, and providing timely insights into student
performance. Educational administrators require a solution that is both efficient and adaptable
to accommodate an increasing number of students, subjects, and complex academic
requirements.
This project aims to develop a Student Management System (SMS) that leverages
fundamental data structures like queues, arrays, and dynamic memory allocation. The system
will handle the addition of subjects, enrolment of students, grade recording, CGPA calculation,
and student performance display. The solution will emphasize modularity, scalability, and user-
friendly interaction while demonstrating practical applications of data structures in solving
real-world academic management challenges.

Dept. of ISE, SJBIT 2024–25 5

CHAPTER 2

SYSTEM REQUIREMENTS SPECIFICATION

Hardware Requirements
1. Processor
o Minimum Requirement: A single-core processor with a clock speed of at least
1 GHz.
▪ This ensures basic compilation and execution of C programs.
o Recommended: A dual-core or quad-core processor for faster execution and
multitasking during development and debugging.
▪ Example: Intel Core i3, AMD Ryzen 3, or equivalent.

2. Memory (RAM)
o Minimum Requirement: 4 GB of RAM.
▪ Sufficient for running the program in a small-scale setup or educational
environment.
o Recommended: 8 GB or more to ensure smooth performance during
compilation, debugging, and multitasking, especially when using resource-
intensive IDEs or running additional background processes.

3. Storage
o Minimum Requirement: 100 MB of free storage space.
▪ Necessary to store the source code, executable files, and compiler
installation.
o Recommended: 500 MB to 1 TB for additional resources like libraries,
documentation, backups, or extended functionality.

Dept. of ISE, SJBIT 2024–25 6

 System Requirements Specifications

4. Input/Output Devices
o Keyboard: For entering commands and data during program execution.
o Monitor: To display the text-based interface of the system and debugging
outputs.
o Mouse (Optional): Useful when working with graphical IDEs or editors.

5. Peripherals
o Printer: For printing student records, academic summaries, or other outputs
generated by the system.

Software Requirements
1. Operating System
• Supported OS Platforms:
o Windows: Windows 7 or later.
▪ Popular C compilers like GCC (via MinGW) and MSVC are available.
o Linux: Distributions such as Ubuntu, Fedora, or Debian.
▪ Pre-installed GCC compilers make Linux ideal for C development.
o macOS: Versions that support Xcode or GCC for C programming.
▪ Native development environment support in macOS.

2. Compiler
• GCC (GNU Compiler Collection):
o Widely used, open-source compiler for compiling and debugging C programs.
• Alternatives:
o Clang: Known for fast compilation and improved error diagnostics.
o Microsoft C/C++ Compiler (MSVC): Available with Visual Studio.

Dept. of ISE, SJBIT 2024–25 7

 System Requirements Specifications

o Turbo C++: Common in educational setups, though outdated for modern

development.

3. Integrated Development Environment (IDE)

• IDEs enhance productivity by providing features like syntax highlighting, debugging
tools, and code autocompletion.

• Recommended IDEs:
o Code::Blocks: Lightweight and user-friendly; ideal for beginners.
o Dev-C++: Suitable for educational environments and Windows users.
o Visual Studio Code: Highly customizable with extensions for C/C++
development.
o Eclipse IDE for C/C++ Developers: Suitable for large-scale projects, providing
advanced debugging and project management features.

4. Text Editors
• While IDEs are recommended, lightweight text editors can also be used for simple
development.

• Options:
o Nano, Vim: Terminal-based editors for Linux users.
o Notepad++: Feature-rich editor for Windows users.
o Sublime Text: A modern, fast editor with excellent support for C/C++ syntax.

Dept. of ISE, SJBIT 2024–25 8

CHAPTER 3

SYSTEM DESIGN

1. Objectives
• Manage a queue of students.
• Handle student grades for multiple subjects.
• Calculate CGPA and determine pass/fail status.

• Provide a CLI-based interface for user interaction.

2. Architecture
This design is modular, ensuring that each functionality is encapsulated in well-defined
sections:

Core Modules:
1. Subject Management:
o Adding subjects dynamically to the system with a growing list.
2. Student Queue Management:
o Using a circular queue to enqueue and dequeue students dynamically.
o Expanding the queue as needed for scalability.
3. Grade and CGPA Processing:
o Dynamically assign grades to students.
o Calculate CGPA and track failure status per student.
4. Interface:
o Provide menu-driven CLI input for adding subjects, adding students, and
viewing details.

Dept. of ISE, SJBIT 2024–25 9

 System Design

3. Detailed Workflow
Step 1: Add Subjects
• User chooses option 1 from the menu.
• Dynamically allocate memory for subjects as needed.
• Each subject is stored with its name and credits.

Step 2: Add Students

• User chooses option 2 from the menu.
• Dynamically allocate memory for student grades.
• Validate grades input (0.0–10.0 range).
• Calculate CGPA using weighted grade averages based on subject credits.

Step 3: Display Student Details

• User chooses option 3 from the menu.
• Iteratively display student details, including:
o Name, roll number.
o Grades per subject with pass/fail status.
o CGPA or "Incomplete" if failed in any subject.

Step 4: Exit
• Free all allocated memory for students, grades, and subjects.
• Exit the program.

Dept. of ISE, SJBIT 2024–25 10

 System Design

• Below is a basic flowchart showing how the system operates:

Flowchart
+-----------------------------------+
| Start the Program |
+------------------------------------+

+------------------------------------+
| Display Main Menu Options |
+------------------------------------+

+------------------------------------+
| Get User's Choice |
+------------------------------------+

+--------------------------------------------+ +------------------------------------+
| 1. Add Subject | | Add subject Record |
+--------------------------------------------+ +------------------------------------+
+--------------------------------------------+ +------------------------------------+
| 2. Add Student | |Create new student record |

+--------------------------------------------+ +------------------------------------+

+---------------------------------------------+ +------------------------------------+
| 3. View Student | | Display all student details |

+--------------------------------------------+ +------------------------------------+
| 4. Delete Student by USN Number | |Delete student record |
+--------------------------------------------+ +------------------------------------+

+---------------------------------------------+ +------------------------------------+
| 5. Exit | | 5. Exit |
+---------------------------------------------+ +------------------------------------+

Dept. of ISE, SJBIT 2024–25 11

CHAPTER 4
IMPLEMENTATION

1. Data Structures Used

Queue:
o Dynamic circular queue to manage student records.
o Supports enqueue, dequeue, and dynamic resizing.
Structures:
o Subject: Stores name and credits.
o Student: Stores name, roll number, grades, failure status, and CGPA.

2.Core Functionalities
Adding Subjects:
o Dynamically adds subjects with name and credits.
o Expands subject list when capacity is reached.
Adding Students:
o Collects student details and grades, validates input, and calculates CGPA.
o Adds student to the queue with dynamic memory allocation.
Displaying Students:
o Iterates through the queue, showing name, roll number, grades, pass/fail status,
and CGPA.
Deleting Students:
o Dequeues students after processing their records.

3. Coding Implementation
Key Functions:
o initializeQueue: Sets up the queue.
o addSubject: Dynamically manages subject records.
o addStudent: Collects student details and calculates CGPA.
o calculateCGPA: Computes CGPA or marks as "Incomplete."
o displayStudents: Lists student records in the queue.
o enqueue/dequeue: Adds/removes students from the queue.

Dept. of ISE, SJBIT 2024–25 12

 Implementation

Memory Management:
o Frees dynamically allocated memory for students and subjects on exit.

4.Flowchart
Start Program.
Display Menu:
o Add Subject, Add Student, Display Students, Exit.
Get User Input:
o Perform action based on selection.
Exit Program:
o Free memory and terminate.

5. Testing
Scenarios
o Adding single/multiple subjects and students.
o Calculating CGPA with pass/fail cases.
o Handling edge cases like empty queue operations.

Sample Outputs
Includes code execution results, such as adding student data, adding subject details,
and student CGPA calculation and student fail or passed.

6. Program Output
Output is displayed via console, showing the user interface and results for each
operation (e.g., Showing student grade, CGPA and passed or fail).

Dept. of ISE, SJBIT 2024–25 13

CHAPTER 5

TESTING

1.Unit Testing
1.1 Testing Subject Management
• Objective:
Verify that subjects can be added, stored, and managed correctly.
• Test Cases:
o Add a valid subject.
▪ Input: Subject Name: "Mathematics", Credits: 3.
▪ Expected Output: "Subject added successfully."
o Attempt to add a subject with invalid credits.
▪ Input: Subject Name: "Physics", Credits: -1.
▪ Expected Output: Error message prompting valid credits.
o Exceed the initial subject list capacity.
▪ Action: Add 12 subjects to a list with an initial capacity of 10.
▪ Expected Output: All subjects added successfully with dynamic array
expansion.

Figure 1.1 Subject Add Function

1.2 Testing Student Management

• Objective:
Ensure students can be added and their details stored dynamically.
• Test Cases:
o Add a student with valid grades.
▪ Input: Name: "Alice", Roll Number: "101", Grades: [8.5, 9.0].
▪ Expected Output: "Student Alice added successfully."

Dept. of ISE, SJBIT 2024–25 14

 Testing
o Add a student with failing grades.
▪ Input: Name: "Bob", Roll Number: "102", Grades: [4.0, 6.0].
▪ Expected Output: CGPA marked as "Incomplete."
o Add a student with invalid grade input.
▪ Input: Grades: [-1.0, 12.0].
▪ Expected Output: Error message prompting valid grades (0.0–10.0).

Figure 1.2 Student Add Function

1.3 Testing Queue Operations

• Objective:
Validate queue operations (enqueue, dequeue) and memory management.
• Test Cases:
o Enqueue a new student when the queue is not full.
▪ Action: Add a student record.
▪ Expected Output: Student successfully enqueued.
o Enqueue a student when the queue is full.
▪ Action: Add a student to a full queue.
▪ Expected Output: Queue dynamically expands, student successfully
added.
o Dequeue a student when the queue is not empty.
▪ Action: Remove the first student in the queue.
▪ Expected Output: The student is removed, and queue pointers update
correctly.
o Attempt to dequeue from an empty queue.
▪ Expected Output: "Queue is empty."

Dept. of ISE, SJBIT 2024–25 15

 Testing

Figure 1.3 Initialization of Queue

2. Integration Testing
2.1 Adding and Displaying Students
• Objective:
Test the interaction between subject and student management modules.
• Test Cases:
o Add subjects, then students, and display their details.
▪ Setup:
▪ Add subjects: "Math (3 credits)", "Physics (4 credits)".
▪ Add students: "Alice (Grades: 8.0, 7.5)", "Bob (Grades: 4.0,
9.0)".
▪ Expected Output:
▪ Alice: CGPA calculated as 7.72.
▪ Bob: Result marked as "Incomplete."

Dept. of ISE, SJBIT 2024–25 16

 Testing

Figure 2.1 Enqueue & Dequeue Function

2.2 Display and Delete Workflow

• Objective:
Ensure proper functioning of the display and deletion sequence.
• Test Cases:
o Add multiple students and display details.
▪ Action: Add three students and display them.
▪ Expected Output: Students displayed in the order of addition.
o Delete a student and re-display.
▪ Action: Remove the first student and display the queue again.
▪ Expected Output: The remaining students are displayed in updated
order.

Dept. of ISE, SJBIT 2024–25 17

 Testing

Figure 2.2 Display Function

Figure 2.3 Delete Function

3. System Testing
3.1 End-to-End Testing
• Objective:
Test the entire workflow from adding subjects to displaying students.
• Test Cases:
o Add subjects, add students, calculate CGPA, display details, and delete students.

Dept. of ISE, SJBIT 2024–25 18

 Testing

▪ Setup:
▪ Add 2 subjects: "Math (3 credits)", "Chemistry (4 credits)".
▪ Add 3 students with varying grades.
▪ Expected Output:
▪ All functionalities work as expected (add, calculate, display,
delete).

3.2 Performance Testing

• Objective:
Assess the program's performance under various conditions.
• Test Cases:
o Add 100 students to test scalability of the queue.
▪ Expected Output: Queue expands dynamically without errors.
o Display a queue of 100 students.
▪ Expected Output: Display completes efficiently without crashes.

4. User Acceptance Testing (UAT)

4.1 Real User Testing
• Objective: Validate ease of use and functionality from the user’s perspective.
• Test Cases:
o Perform actions such as adding subjects, adding students, displaying students,
and exiting.
▪ Feedback Expected:
▪ Menu options are intuitive.
▪ Errors are handled gracefully with clear prompts.

5. Security Testing
5.1 Memory Safety
• Objective: Ensure no memory leaks or invalid memory accesses.
• Test Cases:
o Use valgrind to test memory allocation and deallocation during:
▪ Adding subjects.
▪ Adding and deleting students.
▪ Exiting the program.
o Expected Output: No memory leaks or invalid memory accesses detected.

Dept. of ISE, SJBIT 2024–25 19

 Testing

Figure 3.1 Main Function

Dept. of ISE, SJBIT 2024–25 20

CHAPTER 6
SNAPSHOTS

Figure 4.1 Menu Option

Figure 4.2 Adding Subjects Details

Dept. of ISE, SJBIT 2024–25 21

 Snapshots

Figure 4.3 Adding Student Details

Figure 4.4 Adding Student Details

Dept. of ISE, SJBIT 2024–25 22

 Snapshots

Figure 4.5 Viewing Student

Figure 4.6 Delete the Student Details by USN No

Dept. of ISE, SJBIT 2024–25 23

 Snapshots

Figure 4.7 Exit

Dept. of ISE, SJBIT 2024–25 24

 CONCLUSION

This project is an effective implementation of a student management system using

fundamental data structures like arrays and queues. The project allows for adding
subjects, recording student details, calculating CGPA, and maintaining a queue of
students for efficient management. It also enables deletion of students by their unique
roll numbers, thus covering a wide range of functionalities needed in an academic
management system.

The project demonstrates the application of dynamic memory management, modular

programming, and efficient data handling techniques. Through real-time CGPA
computation and tracking of failed subjects, the project ensures accurate academic
performance representation. The addition of clear prompts and feedback to users
ensures ease of interaction and usability.

Dept. of ISE, SJBIT 2024–25 25

 FUTURE ENHANCEMENTS

Graphical User Interface (GUI): Transitioning the command-line interface to a

graphical interface can enhance user interaction and make the system visually appealing.

Database Integration: Implementing a database (e.g., MySQL, SQLite) would enable

persistent storage, scalability, and ease of access to student and subject records.

Search Functionality: Add a feature to search for students by name or roll number directly
from the queue for quicker access.

Export Functionality: Allow exporting student details and performance records to

external files (e.g., CSV, Excel) for administrative purposes.

Detailed Error Handling: Enhance error messages and validation checks for a smoother
user experience, including preventing duplicate subjects or students.

Integration of Additional Features: Features like attendance tracking, performance

analytics, or subject-specific grading policies can be incorporated.

Cloud-Based Deployment: Making the system accessible as a web or cloud-based

application would allow multiple users to interact with it concurrently.

Mobile Application: Developing a mobile version of the system can increase accessibility
for teachers and students alike.

Dept. of ISE, SJBIT 2024–25 26

 REFERENCES

BOOK:
1.Fundamentals of Data Structures in C.
By: Ellis Horowitz and Sartaj Sahni.
2. An Introduction to Data Structures with Applications.
By: Jean-Paul Tremblay & Paul G. Sorenson.

Web links and Video Lectures:

1. http://elearning.vtu.ac.in/econtent/courses/video/CSE/06CS35.html
2. https://nptel.ac.in/courses/106/105/106105171/
3. http://www.nptelvideos.in/2012/11/data-structures-and-algorithms.html

Dept. of ISE, SJBIT 2024–25 27