A
Project Report on
SMART CART
Submitted in partial fulfilment of the requirements for
The Award of the Degree of
BACHELOR OF TECHNOLOGY
In
COMPUTER SCIENCE AND ENGINEERING
By
A. MANIKANTA-23K81A0567
Under the esteemed guidance of
Mr. K.GANAPATHI BABU
ASSISTANT PROFESSOR
DEPARTMENT OF CSE
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
St. MARTIN’S ENGINEERING COLLEGE
UGC AUTONOMOUS
NBA & NAAC A+ Accredited
Dhulapally, Secunderabad –
500100
ACADEMIC YEAR : 2024-25
St. MARTIN'S ENGINEERING COLLEGE
UGC Autonomous
Accredited by NBA & NAAC A+
Dhulapally, Secunderabad-500 100
www.smec.ac.in
Certificate
This is to certify that the project entitled "SMART CART" is being submitted by
“A.MANIIKANTA (23K81A0567)” in fulfilment of the requirement for the award of degree of
BACHELOR OF TECHNOLOGY IN COMPUTER SCIENCE AND
ENGINEERING is recorded bonafide work carried out by them. The result embodied
in this report have been verified and found satisfactory.
Project Internal Examiner Signature of HOD
Mr. K.GANAPATHI BABU
Dr. R. SANTHOSH KUMAR
Assistant Professor
Professor and Head of Department of CSE
Department of CSE
St. MARTIN'S ENGINEERING COLLEGE
UGC Autonomous
Accredited by NBA & NAAC A+
Dhulapally, Secunderabad-500 100
www.smec.ac.in
DEPARTMENT OF COMPUTER SCIENCE AND
ENGINEERING
DECLARATION
I, the student of “Bachelor of Technology in Department of Computer Science and
Engineering”, session: 2023 - 2027, St. Martin’s Engineering College, Dhulapally,
Kompally, Secunderabad, here by declare that the work presented in this project work
entitled “SMART CART” is the outcome of my own bonafide work and is correct to the best
of my knowledge and this work has been undertaken taking care of Engineering Ethics. This
result embodied in this project report has not been submitted in any university for
award of any degree.
A.MANIKANTA-23K81A0567
ACKNOWLEDGEMENT
The satisfaction and euphoria that accompanies the successful completion of any task would be
incomplete without the mention of the people who made it possible and whose encouragement and
guidance have crowded my efforts with success.
First and foremost, I would like to express my deep sense of gratitude and indebtedness to my
College Management for their kind support and permission to use the facilities available in the
Institute.
I especially would like to express my deep sense of gratitude and in debtedness to Dr.P.SANTOSH
KUMAR PATRA, Group Director, St. Martin’s Engineering College Dhulapally, for permittingus to
undertake this project.
I wish to record my profound gratitude to Dr.M.SREENIVAS RAO, Principal, St. Martin’s Engineering
College, for his motivation and encouragement.
I am also thankful to Dr. R. SATHOSH KUMAR Head of the Department, Computer Science and
Engineering, St.Martin’s Engineering College,Dhulapally, Secunderabad for his support and
guidance through out my project.
I would like to express my sincere gratitude and indebtedness to my project supervisor Mr.
K.GANAPATHI BABU Assistant Professor, Department of Computer Science and Engineering,
St.Martin’s Engineering College, Dhulapally, for his support and guidance throughout my project.
Finally, I express thanks to all those who have helped me successfully completing this project.
Furthermore, I would like to thank my family and friends for their moral support and
encouragement. I express thanks to all those who have helped me in successfully completing the
project.
A.MANIKANTA-23K81A0567
i
CONTENTS
Acknowledgement i
ABSTRACT 1
INTRODUCTION 2
Introduction Background Working Principle
Limitations Summary
LITERATURE SURVEY 3
SYSTEM ANALYSIS 4
Existing System
Proposed System
SYSTEM REQUIREMENTS & SPECIFICATIONS 5
System Requirements
Hardware Requirements
Software Requirements Algorithm
System Architecture
SOURCE CODE 7
TESTING 11
EXPERIMENTAL RESULTS 12
CONCLUSION 14
FUTURE ENHANCEMENT 15
REFERENCES 16
ABSTRACT
The shopping cart program in C is a console-based application designed to emulate basic e-
commerce functionality. The program utilizes a modular structure with functions to perform key
operations such as adding items to the cart, removing items, displaying the cart contents,
calculating the total cost, and exiting the program. Items in the cart are represented by a
structure, encapsulating details like name, price, and quantity. The user interacts with the
program through a menu-driven interface, providing a seamless experience for managing a
virtual shopping cart. While the program demonstrates fundamental programming concepts such
as loops, arrays, and user input handling, it serves as a foundation for potential future
enhancements. Future developments could include features like persistent storage, dynamic
memory allocation, user authentication, graphical user interfaces, and advanced functionalities
such as discounts, promotions, and transaction history. Overall, this shopping cart program
provides a starting point for understanding basic programming principles and can be expanded
for more sophisticated e- commerce applications.
1
INTRODUCTION
The shopping cart program in C serves as a fundamental demonstration of programming principles
applied to a basic e-commerce scenario. In the realm of software development, shopping cart
applications are foundational components, mimicking the functionality of real-world online shopping
experiences. This program showcases essential concepts such as modularization, user interaction, and
data structuring. The application allows users to add items to their virtual shopping cart, remove
items, view the cart's contents, calculate the total cost, and exit the program. By encapsulating item
details in a structured format, the program manages the complexities of tracking multiple items
efficiently. The user interacts with the program through a menu-driven interface, making it accessible
and intuitive. While this implementation is relatively simple, it lays the groundwork for potential
future enhancements, including features like persistent storage, dynamic memory allocation, and user
authentication. In essence, this introductory shopping cart program not only illustrates the core
principles of programming but also serves as a starting point for the development of more
sophisticated and scalable e-commerce applications in the C language.
2
LITERATURE SURVEY
E-commerce System Architecture:
Literature often explores the architecture of e-commerce systems, covering topics such as server-side
scripting, client-server communication, and the integration of databases. Understanding the
underlying architecture is crucial for designing scalable and efficient shopping cart systems.
Programming Paradigms:
Research may delve into different programming paradigms and methodologies employed in
developing shopping cart applications. Object-oriented programming (OOP), procedural
programming, and the use of design patterns can be explored for effective code organization and
maintainability.
User Interface Design:
Studies may focus on user interface (UI) and user experience (UX) design principles in the context of
shopping cart applications. This could include research on graphical user interfaces (GUIs),
accessibility, and human-computer interaction.
Security in E-commerce:
Given the sensitive nature of user data and transactions in e-commerce systems, literature may cover
security measures, encryption techniques, and best practices for securing shopping cart programs
against common threats like SQL injection and cross-site scripting.
Database Management:
Research may address database management aspects of shopping cart systems, exploring topics such
as data modeling, normalization, and efficient querying. The integration of databases with backend
systems is crucial for managing product information and user transactions.
Scalability and Performance:
Literature may discuss techniques for optimizing the performance and scalability of shopping cart
applications, especially in scenarios with a large number of concurrent users. This could involve
considerations for server load balancing, caching strategies, and efficient algorithms.
3
SYSTEM ANALYSIS
Existing System:
The current shopping cart program in C is a console-based application allowing users to perform
basic operations like adding and removing items, displaying the cart, and calculating the total cost. It
utilizes a modular structure with a menu-driven interface but has limitations such as a fixed-size
array, no persistent storage, and a basic console interface.
Proposed System:
The proposed system suggests enhancements to overcome limitations. Key improvements include
introducing persistent storage, dynamic memory allocation, user authentication, a graphical user
interface (GUI) for better usability, item categorization, and search functionality. Additional features
encompass the ability to update item quantities easily, apply discounts, maintain a transaction history,
and improve error handling. Localization support and security measures, such as secure coding
practices, are also recommended for a more versatile and secure shopping cart application. These
enhancements collectively aim to transform the basic program into a more sophisticated and user-
friendly e-commerce system.
4
SYSTEM REQUIREMENTS AND SPECIFICATIONS
Software Requirements:
C Compiler:A C compiler is essential for compiling and running C language programs. Common
choices include GCC (GNU Compiler Collection), Clang, or Microsoft Visual C++.
Text Editor or IDE:A text editor or integrated development environment (IDE) is needed for
writing, editing, and managing the source code. Examples include Visual Studio Code, Atom, or
Code::Blocks.
Operating System:The program can be developed and run on various operating systems, such as
Windows, Linux, or macOS, depending on the user's preference.
Hardware Requirements:
The hardware requirements for a basic console-based shopping cart program in C are minimal.
Since the program does not involve resource-intensive operations or graphical components, it can
run on most modern computing devices with modest specifications:
Processor:A standard processor, such as Intel Core i3 or equivalent, is sufficient.
RAM (Memory):A minimum of 2 GB RAM is adequate for running the program.
Storage:The program's size is small, so a few megabytes of storage space are more than enough.
Input Devices:Standard input devices like a keyboard for user interaction with the console interface.
These requirements assume that the shopping cart program remains a simple console application
without advanced graphical elements or resource-intensive processes. If future enhancements
involve graphical user interfaces, dynamic memory allocation for large datasets, or integration with
external databases, the hardware requirements may need to be adjusted accordingly.
Software Requirements Algorithm:
The shopping cart program in C begins with initialization, setting up an empty cart. It offers a
menu- driven user interface for adding/removing items, displaying the cart, calculating totals, and
exiting. Features include error handling, optional persistence for saving/loading data, and dynamic
memory allocation. Advanced options like user authentication, graphical interfaces, item
categorization, and discounts are optional enhancements, offering scalability and improved user
experience based on specific needs.
5
SYSTEM ARCHITECTURE:
The system architecture for the shopping cart program in C comprises several key components:
Initialization:Initialize variables and data structures.Set up an empty shopping cart.
User Interface Layer:Implement a menu-driven interface for user interaction.
Display options and validate user input.
Shopping Cart Manager:Handle shopping cart operations.Interact with the user interface layer.
Manage the shopping cart data structure.
Shopping Cart Data Structure:Represent items with attributes like name, price, and quantity.
Manage storage and retrieval of items.
Modules:Add Item Module: Add items to the cart.
Remove Item Module: Remove items from the cart.
Display Cart Module: Display cart contents.
Calculate Total Module: Calculate the total cost.
Error Handling Module: Handle errors and display messages.
Optional Modules:
This architecture emphasizes modularity and separation of concerns, facilitating scalability and
maintainability. The shopping cart manager acts as an intermediary, coordinating actions
between the user interface and the data structures representing the shopping cart. Optional
modules allow for flexibility and the addition of advanced features based on specific
requirements.
6
SOURCE CODE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Define a structure for an item in the cart
typedef struct {
char name[50];
double price;
int quantity;
} Item;
// Function to display the contents of the cart
void displayCart(Item cart[], int itemCount)
printf("\nShopping Cart:\n");
printf(" \n");
printf("| %-30s | %-10s | %-10s |\n", "Item", "Price",
"Quantity"); printf(" \n");
for (int i = 0; i < itemCount; i++) {
printf("| %-30s | %-10.2lf | %-10d |\n", cart[i].name, cart[i].price, cart[i].quantity);
printf(" \n");
}
7
// Function to calculate the total cost of the items in the cart
double calculateTotal(Item cart[], int itemCount) {
double total = 0.0;
for (int i = 0; i < itemCount; i++) {
total += cart[i].price * cart[i].quantity;
return total;
int main() {
const int MAX_ITEMS = 100;
Item cart[MAX_ITEMS];
int itemCount = 0;
int choice;
do {
printf("\n1. Add item to cart\n");
printf("2. Remove item from cart\n");
printf("3. Display cart\n");
printf("4. Calculate total\n");
printf("0. Exit\n");
printf("Enter your choice:
"); scanf("%d", &choice);
8
switch (choice) {
case 1:
if (itemCount < MAX_ITEMS)
{ printf("Enter item name: ");
scanf("%s", cart[itemCount].name);
printf("Enter item price: ");
scanf("%lf", &cart[itemCount].price);
printf("Enter quantity: ");
scanf("%d", &cart[itemCount].quantity);
itemCount++;
} else {
printf("Cart is full. Cannot add more items.\n");
break;
case 2:
if (itemCount > 0)
{ int index;
printf("Enter index of item to remove: ");
scanf("%d", &index);
if (index >= 0 && index < itemCount) {
// Remove the item by shifting elements in the array
for (int i = index; i < itemCount - 1; i++) {
cart[i] = cart[i + 1];
9
ItemCount--;
printf("Item removed from the cart.\n");
} else {
printf("Invalid index.\n");
} else {
printf("Cart is empty. Cannot remove items.\n");
break;
case 3:
displayCart(cart, itemCount);
break;
case 4:
printf("Total cost: $%.2lf\n", calculateTotal(cart, itemCount));
break;
case 0:
printf("Exiting the program.\n");
break;
default:
printf("Invalid choice. Please enter a valid option.\n");
} while (choice !=
0); return 0;
10
TESTING
1. Add item to cart
2. Remove item from cart
3. Display cart
4. Calculate total
0. Exit
Enter your choice: 1
Enter item name: Laptop
Enter item price: 999.99
Enter quantity: 2
1. Add item to cart
2. Remove item from cart
3. Display cart
4. Calculate total
0. Exit
Enter your choice: 1
Enter item name: Smartphone
Enter item price: 399.99
Enter quantity: 1
11
EXPERIMENTAL RESULTS
1. Add item to cart
2. Remove item from cart
3. Display cart
4. Calculate total
0. Exit
Enter your choice: 3
Shopping Cart:
| Item | Price | Quantity |
| Laptop | 999.99 |2 |
| Smartphone | 399.99 |1 |
1. Add item to cart
2. Remove item from cart
3. Display cart
4. Calculate total
0. Exit
Enter your choice: 4
Total cost: $2399.97
1. Add item to cart
2. Remove item from cart
12
3. Display cart
4. Calculate total
0. Exit
Enter your choice: 2
Enter index of item to remove: 0
Item removed from the cart.
1. Add item to cart
2. Remove item from cart
3. Display cart
4. Calculate total
0. Exit
Enter your choice: 3
Shopping Cart:
| Item | Price | Quantity |
| Smartphone | 399.99 |1 |
1. Add item to cart
2. Remove item from cart
3. Display cart
4. Calculate total
0. Exit
Enter your choice: 0
Exiting the program.
13
CONCLUSION
The shopping cart program in C demonstrates fundamental principles of programming,
encapsulating item details using structures, modularizing functionality with functions, and
engaging users through a menu-driven interface. The use of a do-while loop allows for repetitive
user interactions until the choice to exit is made. The program incorporates error handling,
providing informative messages in cases such as attempting to add items when the cart is full or
trying to remove items from an empty cart. The array of structures efficiently manages the cart's
content, with each item possessing attributes such as name, price, and quantity. However, it's
important to note that this is a simplistic console application, and real-world shopping cart
systems often require more sophisticated features like persistent storage, dynamic memory
allocation for scalability, and a graphical user interface for a user-friendly experience. The code's
modularity facilitates code maintenance and readability, but for larger and more complex
applications, additional considerations such as proper input validation, security measures, and
robust error handling mechanisms become imperative. Nonetheless, this program serves as a
foundation for understanding basic principles of programming and can be extended and
enhanced for more advanced applications.
14
FUTURE ENHANCEMENT
In the evolution of the shopping cart program in C, various future enhancements can be
envisioned to elevate its functionality and user experience. One crucial improvement involves
implementing persistent storage mechanisms, such as file or database systems, to ensure that
cart data is retained across program sessions. Integrating dynamic memory allocation
techniques, such as malloc and free, enables the program to handle a variable number of items,
enhancing scalability. User authentication features can be introduced to secure individual user
carts, requiring login/logout functionality and safeguarding cart data from unauthorized access.
A transition from the console interface to a graphical user interface (GUI) using libraries like
GTK or Qt could significantly enhance the program's visual appeal and user interaction.
Additional features like item categorization, search capabilities, and the ability to easily update
item quantities contribute to a more streamlined and user-friendly experience. The
incorporation of discount and promotion systems, along with a transaction history log, adds
complexity and value to the program, providing users with more comprehensive shopping
capabilities. Error handling mechanisms can be refined to offer clearer and more user-friendly
error messages, aiding users in resolving issues efficiently. Localization support for multiple
languages and currencies broadens the program's accessibility. Finally, the implementation of
robust security measures becomes imperative, especially if the program deals with user
authentication or sensitive information, mitigating potential vulnerabilities and ensuring data
integrity and confidentiality. Collectively, these enhancements transform the basic shopping
cart program into a versatile and feature-rich application ready for real-world scenarios.
15
REFERENCES
Jessica Keyes. Software Engineering Handbook. Auerbach Publications (CRC Press), 2003.
Contains complete examples of various SE documents.
Roger S. Pressman. Software Engineering: A Practioner's Approach (Sixth Edition,
International Edition). McGraw-Hill, 2005.
Ian Sommerville. Software Engineering (Seventh Edition). Addison-Wesley, 2004.
Hans van Vliet. Software Engineering: Principles and Practice (Second Edition). Wiley, 1999.
16
