• PROJECT REPORT•

Library
management
system
Presented by,
CO-FY
 Om Appasaheb Mandavgad (Roll No: 25)
 Aditya Ramkrishna Marathe (Roll No: 26)
 Tejas Vilas Mhaske (Roll No: 27)
 Yash Rajesh Mule (Roll No: 28)

Guided by,
Prof. Pande A. S.
 Introduction
In today's digital age, efficient management of resources
is a crucial aspect of any system, especially in libraries
where books and users need to be tracked seamlessly. The
Library Management System (LMS) is designed to simplify
the process of managing a library's operations, including the
borrowing and returning of books, tracking users, and
maintaining an organized catalog. This project report
outlines the development of a Library Management System
using C++, one of the most popular programming languages
known for its efficiency and object-oriented capabilities.
The project is aimed at automating library operations,
providing an easy-to-use interface for both administrators
and users. The system enables users to search for available
books, borrow or return them, while administrators can
add, remove, or update book records as well as manage user
information. By implementing this project in C++, we ensure
that the system runs efficiently and provides quick
responses, even when handling large datasets.
This report will cover various aspects of the project,
including:

 Problem Definition: A detailed description of the

problem the system is designed to solve.
 System Design and Architecture: Explanation of how
the system is structured, including class diagrams and
function flow.
 Implementation: Description of key features, data
structures, and algorithms used in the project.
  Challenges and Solutions: Insights into the challenges
faced during the development process and how they
were addressed.
 Future Enhancements: Suggestions for future
improvements and potential features that could be
added to the system.

The Library Management System is expected to be a

comprehensive solution for handling day-to-day library
operations, minimizing manual efforts, and providing a
more user-friendly experience for both librarians and library
users. Through the use of C++ and object-oriented
programming, this project demonstrates the effectiveness of
applying computer science concepts to real-world problems.
 Abstract
The Library Management System is a C++-based
application designed to automate and enhance the
management of a library's core operations, such as book
cataloging, user management, and the borrowing and
returning of books. The system offers a structured and
user-friendly interface that allows librarians to efficiently
manage inventory and track user transactions, ensuring
smooth and transparent library processes.
This project utilizes object-oriented programming
principles to create modular classes for managing books,
users, and library functions. Through a straightforward
design, administrators can add new books, update
records, and track which users have borrowed specific
items. Similarly, users can search for available books,
borrow and return them easily. The system is designed
to handle large volumes of data effectively, enabling
faster, more reliable management of library resources.
The Library Management System aims to reduce
manual effort, increase accuracy in maintaining records,
and enhance the overall efficiency of library operations.
Additionally, the system can be expanded in the future
to support more complex functionalities, such as digital
book lending, user authentication, and advanced search
options, making it a scalable solution for modern
libraries.
 Problem Definition
Managing a library manually is a complex and time-
consuming task that often leads to inefficiencies. Traditional
paper-based systems for cataloging books, keeping track of
borrowed and returned books, and managing user information
are prone to errors, require excessive manual effort, and are
inefficient in handling a large number of transactions. The lack
of an organized, automated system can lead to several issues,
including:

1. Difficulty in Tracking Books: With hundreds or thousands

of books, it becomes challenging to know which books are
available, issued, or overdue. Manual tracking of book inventory
can result in lost or misplaced items.

2. User Management: Handling user information and tracking

their borrowing history is cumbersome without an automated
system. Errors in maintaining user details can lead to confusion
regarding who borrowed which book and when it is due for
return.

3. Time-Consuming Operations: Processes such as searching

for books, updating records, and issuing/returning books take
a lot of time when done manually. This slows down the daily
operations of the library, leading to delays and inefficiencies.

4. Record-Keeping Errors: Manual entry of book and user data

increases the chances of human error, such as incorrect book
status or user details, which can lead to confusion and
inaccurate records.

5. Limited Scalability: A manual or semi-automated system

may work for a small library, but as the number of books and
users grows, it becomes increasingly difficult to scale the
system without automation.

The Library Management System aims to solve these problems

by automating the management of library resources. The
system will allow for the efficient cataloging of books, user
management, and tracking of book circulation, ensuring that all
records are updated in real-time. It will provide a user-friendly
interface that minimizes human error, reduces the time
required for everyday tasks, and makes the entire process more
efficient and scalable.
 System Design and Architecture
The Library Management System is structured using object-
oriented principles, which facilitates modular design and
enhances maintainability. The system is primarily composed of
three main classes: Book, User, and Library. Each class
encapsulates specific functionalities and data, allowing for a
clear separation of concerns.

Class Structure
1. Book Class

 Attributes:
o id: Unique identifier for each book.
o title: Title of the book.
o author: Author of the book.
o isIssued: Boolean flag to indicate whether the book is
currently issued or available.
 Methods:
o addBook(): Initializes book attributes.
o displayBook(): Displays book details.

2. User Class

 Attributes:
o id: Unique identifier for each user.
o name: Name of the user.
 Methods:
o addUser(): Initializes user attributes.
o displayUser(): Displays user details.

3. Library Class

 Attributes:
o books[MAX_BOOKS]: Array to store book objects.
o users[MAX_USERS]: Array to store user objects.
 o bookCount: Counter to track the number of books.
o userCount: Counter to track the number of users.
 Methods:
o addBook(): Adds a new book to the library.
o addUser(): Adds a new user to the library.
o searchBookByTitle(): Searches for a book by its title.
o issueBook(): Issues a book to a user.
o returnBook(): Processes the return of a book.
o displayAllBooks(): Displays all books in the library.
o displayAllUsers(): Displays all users registered in the
library.

Function Flow
1. User Interaction:
o The user navigates a menu-driven interface, selecting
options to manage books and users.
2. Adding Books and Users:
o When a book or user is added, the respective class method
(addBook or addUser) is called, initializing the object's
attributes and updating the count.
3. Searching for Books:
o The user can search for a book by title, which triggers the
searchBookByTitle method in the Library class to check
the array of books.
4. Issuing and Returning Books:
o When a book is issued or returned, the issueBook or
returnBook method is called, checking the book's current
status and updating the isIssued attribute accordingly.
5. Displaying Records:
o The displayAllBooks and displayAllUsers methods provide
a complete view of the library's inventory and user base.
 Class Diagram

Book User
id: int id: int
title: string name: string
isIssued: bool addUser()
displayUser()
addBook()
displayBook()

Library
books[MAX_BOOKS]
users[MAX_USERS]
bookCount: int
userCount: int
addBook()
addUser()
searchBookByTitle()
issueBook()
returnBook()
displayAllBooks()
displayAllUsers()
 Implementation

The Library Management System is implemented using object-

oriented programming principles in C++. Below is a detailed
description of the key features, data structures, and algorithms
used in the project.

Key Features
1. Book Management

o Adding Books: The system allows administrators to add books

to the library by specifying the book ID, title, and author.
o Displaying Books: A list of all books, including their status
(issued or available), can be displayed.
o Searching Books: Books can be searched by their title to
check their availability and current status.
o Issuing Books: Users can borrow books, changing the book's
status from "available" to "issued".
o Returning Books: When a book is returned, its status is
updated back to "available".

2. User Management

o Adding Users: Administrators can register new users by adding

a user ID and user name.
o Displaying Users: A list of all registered users can be displayed
for easy tracking.

3. Book Issuing and Returning

o The system allows for issuing books to users and keeping track
of which user has borrowed a specific book. A book's status is
updated accordingly when it is issued or returned.
4. Data Integrity

o The system ensures that only available books can be issued,

and only issued books can be returned. This prevents data
inconsistencies.

Data Structures
1. Book Class

 The Book class represents a single book in the library. It stores

the book’s attributes, such as:

o id (integer): A unique identifier for each book.

o title (string): The title of the book.
o author (string): The author of the book.
o isIssued (boolean): A flag indicating whether the book is
currently issued or available.

2. User Class

 The User class represents a library user. It stores:

o id (integer): A unique identifier for each user.

o name (string): The name of the user.

3. Library Class

 The Library class manages both Book and User objects. It

maintains:

o books[MAX_BOOKS]: An array of Book objects to store all the

books in the library.
o users[MAX_USERS]: An array of User objects to store all
registered users.
 o bookCount: An integer to keep track of how many books are
stored in the library.
o userCount: An integer to keep track of how many users are
registered.

These arrays ensure constant-time access to any book or user,

facilitating efficient search, add, and display operations.

Algorithms
1. Adding Books and Users

o When a book or user is added, the system appends the new

Book or User object to their respective arrays.
o Time Complexity: O(1) for adding a book or user (constant
time since the arrays are indexed by bookCount and
userCount).

2. Searching Books by Title

o The search algorithm loops through the books array and

compares the input title with the stored titles.
o Time Complexity: O(n), where n is the number of books. This
is a linear search due to the lack of indexing or advanced data
structures like hash tables.

3. Issuing and Returning Books

o For issuing a book, the system searches for the book by its ID
in the books array, checks if it is available, and changes its
status to issued.
o For returning a book, the system checks if the book is issued
and changes its status back to available.
o Time Complexity: O(n), where n is the number of books. This
is because the system performs a linear search for the book by
its ID.
4. Displaying All Books and Users

o Both operations involve iterating through the respective arrays

(books and users) and printing the stored data.
o Time Complexity: O(n) for displaying all books or users, where
n is the number of books or users, respectively.

Improvements and Future Enhancements

While this implementation covers basic library functionalities,
future improvements could include:

 Implementing more efficient data structures (e.g., hash tables

or binary search trees) to optimize searching for books and
users.
 Adding features like user authentication, fine calculation for
overdue books, and more sophisticated reporting and tracking
of library activity.
 Incorporating a database system for persistent storage of books
and users.

This implementation is designed to be simple, efficient for small-to-

medium libraries, and scalable for future development.
 Code
#include <iostream>
#include <cstring>
using namespace std;

// Define the maximum number of books and users

const int MAX_BOOKS = 100;
const int MAX_USERS = 100;

// Book class definition

class Book {
public:
int id;
char title[100];
char author[100];
bool isIssued;

Book() {
id = 0;
strcpy(title, "Unknown");
strcpy(author, "Unknown");
isIssued = false;
}

void addBook(int bookId, const char* bookTitle, const char* bookAuthor)

{
id = bookId;
strcpy(title, bookTitle);
strcpy(author, bookAuthor);
isIssued = false;
}

void displayBook() {
cout << "Book ID: " << id << ", Title: " << title << ", Author: " <<
author;
if (isIssued)
cout << " [Issued]" << endl;
else
cout << " [Available]" << endl;
}
};
// User class definition
class User {
public:
int id;
char name[100];

User() {
id = 0;
strcpy(name, "Unknown");
}

void addUser(int userId, const char* userName) {

id = userId;
strcpy(name, userName);
}

void displayUser() {
cout << "User ID: " << id << ", Name: " << name << endl;
}
};

// Library class to manage books and users

class Library {
private:
Book books[MAX_BOOKS];
User users[MAX_USERS];
int bookCount;
int userCount;

public:
Library() {
bookCount = 0;
userCount = 0;
}

// Add a new book

void addBook(int bookId, const char* bookTitle, const char* bookAuthor)
{
if (bookCount < MAX_BOOKS) {
books[bookCount].addBook(bookId, bookTitle, bookAuthor);
bookCount++;
} else {
cout << "Library is full, cannot add more books!" << endl;
}
}
// Add a new user
void addUser(int userId, const char* userName) {
if (userCount < MAX_USERS) {
users[userCount].addUser(userId, userName);
userCount++;
} else {
cout << "Cannot add more users!" << endl;
}
}

// Search for a book by title

void searchBookByTitle(const char* bookTitle) {
for (int i = 0; i < bookCount; i++) {
if (strcmp(books[i].title, bookTitle) == 0) {
books[i].displayBook();
return;
}
}
cout << "Book not found!" << endl;
}

// Issue a book
void issueBook(int bookId) {
for (int i = 0; i < bookCount; i++) {
if (books[i].id == bookId) {
if (!books[i].isIssued) {
books[i].isIssued = true;
cout << "Book issued successfully!" << endl;
} else {
cout << "Book is already issued!" << endl;
}
return;
}
}
cout << "Book not found!" << endl;
}

// Return a book
void returnBook(int bookId) {
for (int i = 0; i < bookCount; i++) {
if (books[i].id == bookId) {
if (books[i].isIssued) {
books[i].isIssued = false;
cout << "Book returned successfully!" << endl;
 } else {
cout << "Book was not issued!" << endl;
}
return;
}
}
cout << "Book not found!" << endl;
}

// Display all books

void displayAllBooks() {
for (int i = 0; i < bookCount; i++) {
books[i].displayBook();
}
}

// Display all users

void displayAllUsers() {
for (int i = 0; i < userCount; i++) {
users[i].displayUser();
}
}
};

// Main function
int main() {
Library library;
int choice, bookId, userId;
char bookTitle[100], bookAuthor[100], userName[100];

while (true) {
cout << "\n--- Library Management System ---\n";
cout << "1. Add Book\n";
cout << "2. Add User\n";
cout << "3. Search Book by Title\n";
cout << "4. Issue Book\n";
cout << "5. Return Book\n";
cout << "6. Display All Books\n";
cout << "7. Display All Users\n";
cout << "8. Exit\n";
cout << "Enter your choice: ";
cin >> choice;
 switch (choice) {
case 1:
cout << "Enter Book ID: ";
cin >> bookId;
cin.ignore(); // to ignore leftover newline from previous
input
cout << "Enter Book Title: ";
cin.getline(bookTitle, 100);
cout << "Enter Book Author: ";
cin.getline(bookAuthor, 100);
library.addBook(bookId, bookTitle, bookAuthor);
break;

case 2:
cout << "Enter User ID: ";
cin >> userId;
cin.ignore();
cout << "Enter User Name: ";
cin.getline(userName, 100);
library.addUser(userId, userName);
Break;

Case 3:
Court << "Enter Book Title to Search: “
cin.ignore();
cin.getline(bookTitle, 100);
library.searchBookByTitle(bookTitle);
break;

case 4:
cout << "Enter Book ID to Issue: ";
cin >> bookId;
library.issueBook(bookId);
break;

case 5:
cout << "Enter Book ID to Return: ";
cin >> bookId;
library.returnBook(bookId);
break;

case 6:
library.displayAllBooks();
break;
 case 7:
library.displayAllUsers();
break;

case 8:
cout << "Exiting the program..." << endl;
return 0;

default:
cout << "Invalid choice, please try again." << endl;
}
}
return 0;
}
 Output
1. Main Menu

Upon running the program, the system displays a menu of available

operations:

2. Adding a Book

The user selects option 1 to add a book to the system:

3. Adding a User

The user selects option 2 to add a new user to the system:

4. Displaying All Books

When option 6 is selected, the system displays the list of books currently
in the library:

5. Displaying All Users

When option 7 is selected, the system displays the list of all users:

6. Searching for a Book by Title

The user selects option 3 to search for a book by its title. For example,
searching for "The Great Gatsby":

7. Issuing a Book

The user selects option 4 to issue a book to a user. After entering the
book ID, the system updates the book’s status:

8. Returning a Book

The user selects option 5 to return a previously issued book:

 Conclusion
The Library Management System developed in C++ is an
efficient and practical solution for managing the core operations of a
library. The system successfully addresses key functionalities, such
as managing book inventories, user registrations, issuing and
returning books, and tracking book availability. By implementing
object-oriented principles, the system ensures a clean and modular
design, making it easy to maintain and extend as library needs
evolve.

Throughout the project, we focused on delivering a user-friendly

interface and providing seamless navigation for users and
administrators alike. The system’s ability to handle multiple books
and users efficiently demonstrates its applicability for small to
medium-sized libraries.

Future Scope:

o Although the system performs well for basic operations, there

is potential for enhancement. In the future, this project could
incorporate:
o Persistent Storage: Integrating a database to store book and
user data would allow for scalability and long-term data
retention.
o Advanced Search and Sorting: Adding more sophisticated
search algorithms and filtering capabilities could improve user
experience.
o Additional Features: Features like fine calculation for overdue
books, real-time inventory updates, and user authentication
could further enhance the system’s utility.

In conclusion, this project provides a solid foundation for library

management. The project not only enhances library efficiency but
also highlights the potential of C++ in developing real-world
management systems.