FAST FOOD

MANAGEMENT
SYSTEM

December 07
2007

PROJECT REPORT Submitted in the fulfillment of the

requirement for the award of the degree of POST GRADUATE
DIPLOMA IN INFORMATION TECHNOLOGY from Symbiosis
Centre for Distance Learning (SCDL)

By XXXXXX
XXXXX
Reg. No.
000000000

Table of Contents
Sr.
No.
1
2
3
4
5
6
7

8
9
10
11
12
13
14
15
16
17
18
19

Title
Introduction
Objective
Problem and Proposed Solution for Billing Reports
Scope of Package
System Design Process
Feasibility Study
System
Functional Requirement
Analysis
Process Requirement
Storage Requirement
Control Requirement
Data Flow Diagram
Class Design & Description
Database Design
Report Layout
Implementation
Input / Output Screens
Testing
Debugging
Implementation Issues
User Manual
Future Enhancements
Bibliography

Introduction
2

Pg.
No.
3
4
5
6
7
10
11
11
12
12
13
19
21
22
24
55
60
62
63
64
66
67

The Fast Food Management is one of the important work of any outlet either it
may be on large scale or small scale. The Fast Food Management System has
data of the items available in restaurant. It also handles the billing information
and item information purchased by the customer.
The Fast Food Management is a very tough and complex task that needs so
much work and cares to work on. This is the responsibility of the account and
manager of restaurant to take care of the Fast Food Management System. He is
responsible for maintaining all the things in the restaurant. In this way, it is an
important and very responsible post.

Objective
3

The objective of the project is to develop Fast Food Management System, which
shall be used to manage the database of several items in a coherent way.
Function of the System is as follows:
Stores the information of each and every item which is available in the
restaurant.
Add the information of new item.
View the information of each and every item.
Modify the information of item.
It can also make bill for customer.
It can also track the account information of item.
Accurate & Time Saving
Fast & Reliable
User Friendly - This system will be highly user friendly and any one can use it
easily.

Problem faced with Billing Report of Items

4

Billing reports are generated manually. For this reason there are certain
limitations:

There is no particular database of items sold.

More consumption of resources.
More wastage of time.
More chances of error.
More money is required as manpower is more.

Solution Provided
We make the current system of billing record keeping automated as a result:

There will be a particular database maintained.

Less consumption of resources.
Less wastage of time.
Less chances of error.
Less money is required as the manpower decreases.

Proposed Modules
Generation of Billing Reports.

Scope of Package
5

Fast Food Management System package can be implemented in any restaurant,

which is on large-scale, or small scale, and has following facilities to provide:

Item Details

Item
Item
Item
Item

Code
Name
Cost
price

Other operations
Purchase
See Menu
Total Billing

System Design Process

6

A system is simply a set of components that interact to accomplish some specific

purpose or we can define the system as the effective combination of the following
seven points:
Planning
Analysis
Designing
Implementation / Coding
Testing
Deployment
Maintenance

Planning:
Planning include feasibility study regarding the software that has to be develop.
The main points to be kept in mind during the planning phase are:
Economic feasibility
Technical feasibility
Behavioral feasibility
For planning it is necessary to analyze the given problem at global level. The more
we understand the problem, the better we can identify the alternative solutions.
For each suggested solution cost and delivery date are taken into account. An
estimate is made to identify whether user needs will be satisfied using current
software and hardware technologies.
Planning also decide whether it can be developed within existing budget
constraints. Planning is highly depending on the software developer and
application on hand.
The result of planning should be in the direction to judge whether the software is
viable to go ahead for development.
7

Analysis:
It is related to getting the requirements and various specifications required for
developing particular software. The basic idea behind the requirement analysis is
to know about what the customer wants. All the information regarding the
software to be developed is taken from client side either by going to his place or
getting the information from other resources such as reports, information
pertaining to employees, etc. This phase is of utmost importance as it contains
huge amount of important data, which will be used in developing software. If this
phase is not carried out properly, then certain bugs or shortcomings will be there
in the software, which is going to be developed by the programmer.

Designing:
This phase is related to the arranging of data in a proper manner so that the
programmer can work accordingly for developing the software. It is basically the
analysis part of the data that has been collected in the earlier phase. It also
includes the designing aspects that are related to drawing of data flow diagram,
entity relationship diagram, functional decomposition diagram, making data
dictionary and various other concerns that are part of getting a general view of
the software. This phase include all the study and minute details, which are
involved in development of software.

Implementation / Coding:
During this programmer develops the software by different methodologies that
are available for developing software. The programmer writes the code in certain
language and development team consists of various programmers who are
efficient in their respective domain.
8

Testing:
This phase is related to the testing of software after it has been developed. In this
phase testing engineer carries out various strategies and tools to check whether
the software developed by the programmer is following the predefined standards
and the quality of the software is up to the level to which it is required.
The various techniques used for testing by a testing engineer are white box, black
box, and unit testing, etc. These all techniques are useful in getting rid of the
shortcomings or failures which are on the part of the programmer. If certain
failures are encounter then they are informed to the programmer and he has to
eliminate that failure from software. This is how the software develops which is all
together free from the bugs and is ready for implementation.

Deployment:
Deployment is related to the installation of the software on the client side. Various
procedures involved in deploying software include giving documenting a software
to the client which consist of basic as well as technical part, it also includes giving
proper training sessions and presentation to the client regarding the working of
the system. It also includes checking of various hardware resources available with
the client and making sure that the software is running properly on thief machine.

Maintenance:

This is a very important phase. In this, review is done by the programmer or some
other technical employee of the company which has acquired the software in
order to manage the changing requirement of the customer from time to time. If
there is any failure in the software then the developer has to take care of it within
the certain time limit.

Feasibility Study
The benefits of the project can be categorized into tangible and intangible
benefits which
The system would acquire as a result of the successful project.

Improved working of the system

Increased system flexibility
Availability of latest technologies
Faster processing
Improved resource control
Increased accuracy in clerical operations
Decreased manual work

Tangible Benefits

Cost reduction
Less stationary requirement
Decrement in staff
Overall gain after the recovery of cost of project.

Intangible Benefits

Proper working of system

High employee morale
Gain in overall reputation
Financing totally computer based which acts as an asset
Improved management

10

System Analysis
Functional Requirement
Input / Output Requirement:
Input requirement is basically related to the inputs require by the system to
perform its job. Over all input requirement of the Fast Food Management System
can be divided into following category:
Item Details
Quantity
Item Code
Output of the Fast Food Management System can be divided into following
category:
Displaying Total Bill
Displaying Item Details

Process Requirement
All system has various processes associated with it and this Fast Food
Management System contains all following processes:

Add New Item Process

Modify Item Process
Delete Item Process
Purchase Item Process

11

Storage Requirement
In this system I have used the File Handling as back-end and all the information as
data will be store in the following files:
Food File
Billing File

Control Requirement
Always whenever a project is made some validation has to be imposed. So, in my
project also there are some validations which I have imposed. These validations
are

Number cannot be entered in the fields like item name.

Only digits should be used in Item Cost and Item Price.
It is mandatory to fill the all the fields.
Item cost must be lesser than item Price.
Billing once generated cannot be modified.

12

Data Flow Diagram

A Data Flow Diagram (DFD) is used to express system requirement in a graphical
form. It is also known as a bubble chart. A DFD depicts information flow and
transformations that are applied as data moves from input to output. Use of DFD
helps to clarify the system requirements. DFD are drawn during analysis and are
the starting point for the design phase. A DFD could be used to represent a
physical system at the beginning of analysis, or a logical system at alteration
point in the system, at the beginning of analysis, or a logical system at alteration
point in the system development life cycle. Being graphical, it is easy to
understand.
A DFD is used to describe what data flows rather than how it flows. The concerns
understand the transformations that are required to convert the input to output. It
is independent of hardware, software and data structure and file organization.

13

ADD
RECORD

14

Record of
Items

Item
Information

Main Screen

Purchase
15
System

Item Quantity

Billing Information

MAIN SCREEN

16

Display Item
Information

RECORD

MAIN MENU

17

Deletion of Item Information

Return to List

Item Record Deleted

Item Record
Main Menu

18

Prompt For
Modify

Found Item
Information
Record Database

MAIN
MENU
Item Information

Modify Item

19

Class Design & Description

Class Name:
food
Description:
It controls over all the functions related
with food items
Public function:
void add_item(void) ;
void delete_item(void) ;
void modify_item(void) ;
void list_of_item(void) ;
void purchase(void) ;
Private function:
int last_code(void) ;
void delete_record(int) ;
void modify_record(int) ;
void display_record(int) ;
int item_found(int) ;
int recordno(int) ;
void sort(void) ;

Diagram:
food
- itemcode : int
- itemname: string
- itemcost: float
- itemprice : float
+ add_item(void) : void
+ delete_item(void) : void
+ modify_item(void) : void
+ list_of_item(void) : void
+ purchase(void) : void
- last_code(void) : int
- delete_record(int) : void
- modify_record(int) : void
- display_record(int) : void
- item_found(int) : int
- recordno(int) : int
- sort(void) : void
20

Class Name:
Description:
making Bill

account
It controls over all the functions related to

Public function:

Diagram:

void bill_list(void) ;
void prepare_bill(int) ;
int last_billno(void) ;
void add_bill(int, int t_itemcode, char *t_itemname, float t_qty, float t_cost,
float t_price) ;

account
- code: int
- billno: int
- length: length
- dd: int
- mm: int
- yy: int
- cost : float
- price : float
- quantity: float
- name: string
- bill_list(void) : void
- prepare_bill(int) : void
- last_billno(void) : int
- add_bill(int, int, string, float, float, float) : void

Class Name:
Description:

menu
It controls over all the functions

Public function:
void main_menu(void);
Private function:
void box(void) ;
void edit_menu(void) ;

Diagram:
menu
+ main_menu(): void
21

- box(): void
- edit_menu(): void

Database Design
Table Design
Food Table
Field

Data

Constraints

Siz

name

type

Item_code

int

Auto Generated

Item_Name

Text

Not Null

20

Item_Cost

Float

Not Null, Non-

Item_Price Float

negative
Not Null, Non-

negative

Bill Table
Field

Data

name

type

Constraints

Siz
e

Integer
Item_code
Item_quant Integer

Reference Key
4
Non negative, not 2

ity
Total

null
Not negative

Float

22

Report Layout
MAIN MENU
FAST

FOOD

~~~~~~~~~~~~~~~
1:

PURCHASE

2:

SEE MENU

3:

EDIT

4:

TOTAL BILL

0:

QUIT

Enter Choice :

PURCHASE
Date : 22/4/2007
Item Code: 1
Item Name: Raj Kachori
Item Cost: 100
Item Price: 120

Quantity:2

Do you want to cancel this purchase (y/n):n

23

Do you want to purchase more (y/n): n

Total Bill
List of Bills
~~~~~~~~~~
Billno.
Date
Total
1

Item Code

17/11/2006

Item Name

Cost Price

Qty

Raj Kachori

100 120

240
Total Bill: Rs. 240/-

See Menu
List Of Items
~~~~~~~~~~

Item Code Item Name

1

Raj Kachori

Samosa

Item Cost

Item Price

100
3

120
5

24

Implementation
//**********************************************************
//
PROJECT FAST-FOOD MANAGEMENT
//**********************************************************
//**********************************************************
//
INCLUDED HEADER FILES
//**********************************************************
#include <iostream.h>
#include <fstream.h>
#include <process.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
#include <dos.h>
//**********************************************************
//
CLASS NAME : menu
//
DETAILS : IT CONTROLLS OVER ALL THE FUNCTIONS
//**********************************************************
class menu
{
public :
void main_menu(void) ;
private :
void box(void) ;
void edit_menu(void) ;
};

25

//**********************************************************
//
CLASS NAME : food
//
DETAILS : IT CONTROLLS OVER ALL THE FUNCTIONS
//
RELATED TO FOOD ITEMS
//**********************************************************
class food
{
public :
void add_item(void) ;
void delete_item(void) ;
void modify_item(void) ;
void list_of_item(void) ;
void purchase(void) ;
private :
int last_code(void) ;
void delete_record(int) ;
void modify_record(int) ;
void display_record(int) ;
int item_found(int) ;
int recordno(int) ;
void sort(void) ;
int itemcode ;
char itemname[30] ;
float itemcost, itemprice ;
};

26

//**********************************************************
//
CLASS NAME : account
//
DETAILS : IT CONTROLLS OVER ALL THE FUNCTIONS
//
RELATED TO MAKING BILL
//**********************************************************
class account
{
public :
void bill_list(void) ;
void prepare_bill(int) ;
int last_billno(void) ;
void add_bill(int, int t_itemcode, char *t_itemname, float t_qty, float t_cost,
float t_price) ;
private :
int code, billno, length ;
int dd, mm, yy ;
float cost, price, quantity ;
char name[30] ;
};
//**********************************************************
// THIS FUNCTION DRAW BOX FOR THE MENUS
//**********************************************************
void menu :: box(void)
{
char c1=178, c2=177, c3=176 ;
int k=1 ;
gotoxy(1,2) ;
for (int i=1; i<=1840; i++)
{
27

if (k == 1)
cout <<c1 ;
else
if (k == 2)
cout <<c2 ;
else
if (k == 3)
cout <<c3 ;
k++ ;
if (k == 4)
k=1;
}
for (i=5; i<=21; i++)
{
gotoxy(21,i) ;
cout <<"
}

";

}
//**********************************************************
// THIS FUNCTION CREATE MAIN MENU AND CALLS OTHER FUNCTIONS
//**********************************************************
void menu :: main_menu(void)
{
clrscr() ;
char ch ;
while (1)
{
clrscr() ;
box() ;
gotoxy(32,6) ;
cout <<"F A S T F O O D" ;
gotoxy(32,7) ;
cout <<"~~~~~~~~~~~~~~~~" ;
gotoxy(32,9) ;
cout <<"1: PURCHASE" ;
gotoxy(32,11) ;
cout <<"2: SEE MENU" ;
gotoxy(32,13) ;
cout <<"3: EDIT" ;
28

gotoxy(32,15) ;
cout <<"4: TOTAL BILL" ;
gotoxy(32,17) ;
cout <<"0: QUIT" ;
gotoxy(32,20) ;
cout <<"Enter Choice : " ;
ch = getche() ;
if (ch == 27)
return ;
else
if (ch == '1')
{
food f ;
f.purchase() ;
}
else
if (ch == '2')
{
food f ;
f.list_of_item() ;
}
else
if (ch == '3')
edit_menu() ;
else
if (ch == '4')
{
account a ;
a.bill_list();
}
else
if (ch == '0')
break ;
}
}
//**********************************************************
// THIS FUNCTION CREATE EDIT MENU AND CALLS OTHER FUNCTIONS
//**********************************************************
void menu :: edit_menu(void)
29

{
char ch ;
while (1)
{
for (int i=5; i<=21; i++)
{
gotoxy(21,i) ;
cout <<"
}
gotoxy(32,6) ;
cout <<"E D I T M E N U" ;
gotoxy(32,7) ;
cout <<"~~~~~~~~~~~~~~~~" ;
gotoxy(32,10) ;
cout <<"1: ADD ITEM" ;
gotoxy(32,12) ;
cout <<"2: MODIFY ITEM" ;
gotoxy(32,14) ;
cout <<"3: DELETE ITEM" ;
gotoxy(32,16) ;
cout <<"0: EXIT" ;
gotoxy(32,19) ;
cout <<"Enter Choice : " ;
ch = getche() ;
if (ch == 27)
return ;
else
if (ch == '1')
{
food f ;
f.add_item() ;
break ;
}
else
if (ch == '2')
{
food f ;
f.modify_item() ;
break ;
}
else
if (ch == '3')

";

30

{
food f ;
f.delete_item() ;
break ;
}
else
if (ch == '0')
break ;
}
}
//**********************************************************
// THIS FUNCTION RETURNS THE CODE OF THE LAST RECORD IN THE
// FOOD FILE (FOOD.DAT).
//**********************************************************
int food :: last_code(void)
{
fstream file ;
file.open("FOOD.DAT", ios::in) ;
file.seekg(0,ios::beg) ;
int t=0 ;
while (file.read((char *) this, sizeof(food)))
t = itemcode ;
file.close() ;
return t ;
}
//**********************************************************
// THIS FUNCTION DISPLAY THE LIST OF THE FOOD ITEMS
//**********************************************************
void food :: list_of_item(void)
{
clrscr() ;
fstream file ;
file.open("FOOD.DAT", ios::in) ;
file.seekg(0) ;
int row = 6 , found = 0 , pageno = 1 ;
gotoxy(30,2) ;
31

cout <<"LIST OF ITEMS" ;

gotoxy(29,3) ;
cout <<"~~~~~~~~~~~~~~~" ;
gotoxy(3,4) ;
cout <<"ITEM CODE ITEM NAME
ITEM COST ITEM PRICE" ;
gotoxy(2,5) ;
cout <<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
;
while (file.read((char *) this, sizeof(food)))
{
delay(20) ;
found = 1 ;
gotoxy(5,row) ;
cout <<itemcode ;
gotoxy(14,row) ;
cout <<itemname ;
gotoxy(37,row) ;
cout <<itemcost ;
gotoxy(51,row) ;
cout <<itemprice ;
if ( row == 22 )
{
row = 5 ;
gotoxy(66,1) ;
cout <<"Page no. : " <<pageno ;
gotoxy(66,2) ;
cout <<"===============" ;
pageno++ ;
gotoxy(1,25) ;
cout <<"Press any key to continue..." ;
getche() ;
clrscr() ;
gotoxy(30,2) ;
cout <<"LIST OF ITEMS" ;
gotoxy(3,4) ;
cout <<"ITEM CODE ITEM NAME

ITEM COST ITEM PRICE"

;
gotoxy(2,5) ;
cout
<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" ;
}
else
32

row++ ;
}
if ( !found )
{
gotoxy(5,10) ;
cout <<"\7Records not found" ;
}
gotoxy(66,1) ;
cout <<"Page no. : " <<pageno ;
gotoxy(66,2) ;
cout <<"===============" ;
gotoxy(1,25) ;
cout <<"Press any key to continue..." ;
getche() ;
file.close () ;
}
//**********************************************************
// THIS FUNCTION ADD RECORDS IN THE FOOD FILE (FOOD.DAT)
//**********************************************************
void food :: add_item(void)
{
int tcode, valid ;
char ch, t_itemcost[10], t_itemprice[10] ;
tcode = last_code() ;
tcode++ ;
do
{
clrscr() ;
gotoxy(71,2) ;
cout <<"<0>=Exit" ;
gotoxy(27,3) ;
cout <<"ADD FOOD ITEM TO THE MENU" ;
gotoxy(26,4) ;
cout <<"~~~~~~~~~~~~~~~~~~~~~~~~~~~" ;
gotoxy(5,6) ;
cout <<"Item Code : " <<tcode ;
gotoxy(5,8) ;
cout <<"Item Name : " ;
gotoxy(5,10) ;
33

cout <<"Item Cost : " ;

gotoxy(5,12) ;
cout <<"Item Price : " ;
do
{
valid = 1 ;
gotoxy(1,8) ; clreol() ;
gotoxy(1,24) ; clreol() ;
gotoxy(1,25) ; clreol() ;
gotoxy(3,25) ;
cout <<"ENTER ITEM NAME TO ADD IN THE MENU" ;
gotoxy(5,8) ;
cout <<"Item Name : " ;
gets(itemname) ;
strupr(itemname) ;
if (itemname[0] == '0')
return ;
if ((strlen(itemname) < 1) || (strlen(itemname) > 20))
{
valid = 0 ;
gotoxy(3,24) ;
cout <<"\7 Range = 1..20" ;
getch() ;
}
} while (!valid) ;
do
{
valid = 1 ;
gotoxy(1,10) ; clreol() ;
gotoxy(1,24) ; clreol() ;
gotoxy(1,25) ; clreol() ;
gotoxy(3,25) ;
cout <<"ENTER ITEM COST TO ADD IN THE MENU" ;
gotoxy(5,10) ;
cout <<"Item Cost : " ;
gets(t_itemcost) ;
itemcost = atof(t_itemcost) ;
if (t_itemcost[0] == '0')
return ;
if (itemcost < 1 || itemcost > 800)
{
valid = 0 ;
34

gotoxy(3,24) ;
cout <<"\7 Range = 1..800" ;
getch() ;
}
} while (!valid) ;
do
{
valid = 1 ;
gotoxy(1,12) ; clreol() ;
gotoxy(1,24) ; clreol() ;
gotoxy(1,25) ; clreol() ;
gotoxy(3,25) ;
cout <<"ENTER ITEM PRICE TO ADD IN THE MENU" ;
gotoxy(5,12) ;
cout <<"Item Price : " ;
gets(t_itemprice) ;
itemprice = atof(t_itemprice) ;
if (t_itemprice[0] == '0')
return ;
if (itemprice < itemcost || itemprice > 1000)
{
valid = 0 ;
gotoxy(3,24) ;
cout <<"\7 Range = " <<itemcost <<"..1000" ;
getch() ;
}
} while (!valid) ;
do
{
gotoxy(1,15) ; clreol() ;
gotoxy(1,24) ; clreol() ;
gotoxy(1,25) ; clreol() ;
gotoxy(5,15) ;
cout <<"Do you want to save this record (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
if (ch == '0')
return ;
} while (ch != 'N' && ch != 'Y') ;
if (ch == 'Y')
{
itemcode = tcode ;
35

fstream file ;
file.open("FOOD.DAT", ios::out | ios::app ) ;
file.write((char *) this, sizeof(food)) ;
file.close() ;
tcode++ ;
}
do
{
gotoxy(1,17) ; clreol() ;
gotoxy(1,24) ; clreol() ;
gotoxy(1,25) ; clreol() ;
gotoxy(5,17) ;
cout <<"Do you want to add more records (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
if (ch == '0')
return ;
} while (ch != 'N' && ch != 'Y') ;
} while (ch == 'Y') ;
}
//**********************************************************
// THIS FUNCTION DISPLAY THE RECORD OF THE GIVEN CODE FROM
// THE FOOD FILE (FOOD.DAT)
//**********************************************************
void food :: display_record(int tcode)
{
fstream file ;
file.open("FOOD.DAT", ios::in) ;
file.seekg(0,ios::beg) ;
while (file.read((char *) this, sizeof(food)))
{
if (itemcode == tcode)
{
gotoxy(5,3) ;
cout <<"Item Code : "<<itemcode ;
gotoxy(5,4) ;
cout <<"Item Name : "<<itemname ;
gotoxy(5,5) ;
cout <<"Item Cost : "<<itemcost ;
36

gotoxy(5,6) ;
cout <<"Item Price : "<<itemprice ;
break ;
}
}
file.close() ;
}
//**********************************************************
// THIS FUNCTION RETURN THE VALUE 1 IF THE RECORD IS FOUND
// FOR THE GIVEN CODE IN THE FOOD FILE (FOOD.DAT)
//**********************************************************
int food :: item_found(int tcode)
{
fstream file ;
file.open("FOOD.DAT", ios::in) ;
file.seekg(0,ios::beg) ;
int found=0 ;
while (file.read((char *) this, sizeof(food)))
{
if (itemcode == tcode)
{
found++ ;
break ;
}
}
file.close() ;
return found ;
}
//**********************************************************
// THIS FUNCTION RETURN THE RECORD NO. OF THE GIVEN CODE IN
// THE FOOD FILE (FOOD.DAT)
//**********************************************************
int food :: recordno(int tcode)
{
fstream file ;
file.open("FOOD.DAT", ios::in) ;
37

file.seekg(0,ios::beg) ;
int found=0 ;
while (file.read((char *) this, sizeof(food)))
{
found++ ;
if (itemcode == tcode)
break ;
}
file.close() ;
return found ;
}
//**********************************************************
// THIS FUNCTION DELETES THE RECORD FOR THE GIVEN CODE FROM
// THE FOOD FILE (FOOD.DAT)
//**********************************************************
void food :: delete_record(int tcode)
{
fstream file ;
file.open("FOOD.DAT", ios::in) ;
fstream temp ;
temp.open("temp.dat", ios::out) ;
file.seekg(0,ios::beg) ;
while ( !file.eof() )
{
file.read((char *) this, sizeof(food)) ;
if ( file.eof() )
break ;
if ( itemcode != tcode )
temp.write((char *) this, sizeof(food)) ;
}
file.close() ;
temp.close() ;
file.open("FOOD.DAT", ios::out) ;
temp.open("temp.dat", ios::in) ;
temp.seekg(0,ios::beg) ;
while ( !temp.eof() )
{
temp.read((char *) this, sizeof(food)) ;
if ( temp.eof() )
38

break ;
file.write((char *) this, sizeof(food)) ;
}
file.close() ;
temp.close() ;
}
//**********************************************************
// THIS FUNCTION GIVES THE CODE NO. TO DELETE RECORD FROM
// THE FOOD FILE (FOOD.DAT)
//**********************************************************
void food :: delete_item(void)
{
clrscr() ;
char t_code[5], ch ;
int t, tcode ;
gotoxy(3,25) ;
cout <<"Press <ENTER> to see the list" ;
gotoxy(5,3) ;
cout <<"Enter Item Code of the item to be deleted : " ;
gets(t_code) ;
t = atoi(t_code) ;
tcode = t ;
if (t_code[0] == '0')
return ;
if (tcode == 0)
{
list_of_item() ;
gotoxy(1,25) ; clreol() ;
gotoxy(3,25) ;
cout <<"Press <ENTER> to Exit" ;
gotoxy(5,24) ;
cout <<"Enter Item Code of the item to be deleted : " ;
gets(t_code) ;
t = atoi(t_code) ;
tcode = t ;
if (tcode == 0)
return ;
}
clrscr() ;
39

if (!item_found(tcode))
{
gotoxy(5,5) ;
cout <<"\7Record not found" ;
getch() ;
return ;
}
display_record(tcode) ;
do
{
gotoxy(1,8) ; clreol() ;
gotoxy(5,8) ;
cout <<"Do you want to delete this record (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
} while (ch != 'N' && ch != 'Y') ;
if (ch == 'N')
return ;
delete_record(tcode) ;
gotoxy(5,15) ;
cout <<"\7Record Deleted" ;
getch() ;
}
//**********************************************************
// THIS FUNCTION MODIFY THE RECORD FOR THE GIVEN CODE FROM
// THE FOOD FILE (FOOD.DAT)
//**********************************************************
void food :: modify_record(int tcode)
{
int recno ;
recno = recordno(tcode) ;
int valid, t_code ;
char ch, t_itemcost[10], t_itemprice[10], t_itemcode[5] ;
gotoxy(71,2) ;
cout <<"<0>=Exit" ;
gotoxy(5,12) ;
cout <<"Item Code : " ;
gotoxy(5,14) ;
cout <<"Item Name : " ;
40

gotoxy(5,16) ;
cout <<"Item Cost : " ;
gotoxy(5,18) ;
cout <<"Item Price : " ;
do
{
gotoxy(20,12) ; clreol() ;
cout <<"Change (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
if (ch == '0')
return ;
} while (ch != 'N' && ch != 'Y') ;
valid = 0 ;
while (ch == 'Y' && !valid)
{
valid = 1 ;
gotoxy(1,12) ; clreol() ;
gotoxy(1,24) ; clreol() ;
gotoxy(1,25) ; clreol() ;
gotoxy(3,25) ;
cout <<"ENTER ITEM CODE TO ADD IN THE MENU" ;
gotoxy(5,12) ;
cout <<"Item Code : " ;
gets(t_itemcode) ;
t_code = atoi(t_itemcode) ;
if (t_code == 0)
return ;
if (item_found(t_code) && t_code != tcode)
{
valid = 0 ;
gotoxy(3,24) ;
cout <<"\7 CODE ALREADY GIVEN" ;
getch() ;
}
}
do
{
gotoxy(20,14) ; clreol() ;
cout <<"Change (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
41

if (ch == '0')
return ;
} while (ch != 'N' && ch != 'Y') ;
valid = 0 ;
while (ch == 'Y' && !valid)
{
valid = 1 ;
gotoxy(1,14) ; clreol() ;
gotoxy(1,24) ; clreol() ;
gotoxy(1,25) ; clreol() ;
gotoxy(3,25) ;
cout <<"ENTER ITEM NAME TO ADD IN THE MENU" ;
gotoxy(5,14) ;
cout <<"Item Name : " ;
gets(itemname) ;
strupr(itemname) ;
if (itemname[0] == '0')
return ;
if ((strlen(itemname) < 1) || (strlen(itemname) > 20))
{
valid = 0 ;
gotoxy(3,24) ;
cout <<"\7 Range = 1..20" ;
getch() ;
}
}
do
{
gotoxy(20,16) ; clreol() ;
cout <<"Change (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
if (ch == '0')
return ;
} while (ch != 'N' && ch != 'Y') ;
valid = 0 ;
while (ch == 'Y' && !valid)
{
valid = 1 ;
gotoxy(1,16) ; clreol() ;
gotoxy(1,24) ; clreol() ;
gotoxy(1,25) ; clreol() ;
42

gotoxy(3,25) ;
cout <<"ENTER ITEM COST TO ADD IN THE MENU" ;
gotoxy(5,16) ;
cout <<"Item Cost : " ;
gets(t_itemcost) ;
itemcost = atof(t_itemcost) ;
if (t_itemcost[0] == '0')
return ;
if (itemcost < 1 || itemcost > 800)
{
valid = 0 ;
gotoxy(3,24) ;
cout <<"\7 Range = 1..800" ;
getch() ;
}
}
do
{
gotoxy(20,18) ; clreol() ;
cout <<"Change (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
if (ch == '0')
return ;
} while (ch != 'N' && ch != 'Y') ;
valid = 0 ;
while (ch == 'Y' && !valid)
{
valid = 1 ;
gotoxy(1,18) ; clreol() ;
gotoxy(1,24) ; clreol() ;
gotoxy(1,25) ; clreol() ;
gotoxy(3,25) ;
cout <<"ENTER ITEM PRICE TO ADD IN THE MENU" ;
gotoxy(5,18) ;
cout <<"Item Price : " ;
gets(t_itemprice) ;
itemprice = atof(t_itemprice) ;
if (t_itemprice[0] == '0')
return ;
if (itemprice < itemcost || itemprice > 1000)
{
43

valid = 0 ;
gotoxy(3,24) ;
cout <<"\7 Range = " <<itemcost <<"..1000" ;
getch() ;
}
}
do
{
gotoxy(1,21) ; clreol() ;
gotoxy(1,24) ; clreol() ;
gotoxy(1,25) ; clreol() ;
gotoxy(5,21) ;
cout <<"Do you want to save this record (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
if (ch == '0')
return ;
} while (ch != 'N' && ch != 'Y') ;
if (ch == 'N')
return ;
itemcode = t_code ;
cout <<"\n" <<itemname ;
cout <<itemcost ;
cout <<itemprice ;
getch() ;
fstream file ;
file.open("FOOD.DAT", ios::out | ios::ate) ;
int location ;
location = (recno-1) * sizeof(food) ;
file.seekp(location) ;
file.write((char *) this, sizeof(food)) ;
file.close() ;
sort() ;
clrscr() ;
gotoxy(5,15) ;
cout <<"\7Record Modified" ;
getch() ;
}
//**********************************************************
// THIS FUNCTION GIVES THE CODE NO. TO MODIFY RECORD FROM
44

// THE FOOD FILE (FOOD.DAT)

//**********************************************************
void food :: modify_item(void)
{
clrscr() ;
char t_code[5], ch ;
int t, tcode ;
gotoxy(3,25) ;
cout <<"Press <ENTER> to see the list" ;
gotoxy(5,3) ;
cout <<"Enter Item Code of the item to be Modify : " ;
gets(t_code) ;
t = atoi(t_code) ;
tcode = t ;
if (t_code[0] == '0')
return ;
if (tcode == 0)
{
list_of_item() ;
gotoxy(1,25) ; clreol() ;
gotoxy(3,25) ;
cout <<"Press <ENTER> to Exit" ;
gotoxy(5,24) ;
cout <<"Enter Item Code of the item to be modify : " ;
gets(t_code) ;
t = atoi(t_code) ;
tcode = t ;
if (tcode == 0)
return ;
}
clrscr() ;
if (!item_found(tcode))
{
gotoxy(5,5) ;
cout <<"\7Record not found" ;
getch() ;
return ;
}
display_record(tcode) ;
do
{
45

gotoxy(5,8) ;
cout <<"Do you want to Modify this record (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
} while (ch != 'N' && ch != 'Y') ;
if (ch == 'N')
return ;
modify_record(tcode) ;
}
//**********************************************************
// THIS FUNCTION SORT THE RECORD IN THE FOOD FILE (FOOD.DAT)
// ACCORDING TO THE CODE NOS.
//**********************************************************
void food :: sort(void)
{
int i=0,j ;
food arr[100] ;
food temp ;
fstream file ;
file.open("FOOD.DAT", ios::in) ;
file.seekg(0,ios::beg) ;
while (file.read((char *) &arr[i], sizeof(food)))
i++ ;
int size ;
size = i ;
file.close() ;
for (i=1; i<size; i++)
for (j=0; j<size-i; j++)
{
if (arr[j].itemcode > arr[j+1].itemcode)
{
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
file.open("FOOD.DAT", ios::out) ;
for (i=0; i<size; i++)
file.write((char *) &arr[i], sizeof(food)) ;
46

file.close() ;
}
//**********************************************************
// THIS FUNCTION PURCHASES THE FOOD ITEM IN THE MENU
//**********************************************************
void food :: purchase(void)
{
clrscr() ;
account a ;
int t_billno, purchased=0 ;
t_billno = a.last_billno() ;
t_billno++ ;
char t_code[5], ch, t_quantity[5] ;
int t, tcode, i=0, valid ;
float qty ;
int t_itemcode ;
float t_qty, t_cost, t_price ;
char t_itemname[30] ;
struct date d;
int d1, m1, y1 ;
getdate(&d);
d1 = d.da_day ;
m1 = d.da_mon ;
y1 = d.da_year ;
do
{
clrscr() ;
gotoxy(3,25) ;
cout <<"Press <ENTER> to see the list" ;
gotoxy(5,3) ;
cout <<"Enter Item Code of the item to be Purchase : " ;
gets(t_code) ;
t = atoi(t_code) ;
tcode = t ;
if (t_code[0] == '0')
{
if (purchased)
a.prepare_bill(t_billno) ;
return ;
47

}
if (tcode == 0)
{
list_of_item() ;
gotoxy(1,25) ; clreol() ;
gotoxy(3,25) ;
cout <<"Press <ENTER> to Exit" ;
gotoxy(5,24) ;
cout <<"Enter Item Code of the item to be Purchase : " ;
gets(t_code) ;
t = atoi(t_code) ;
tcode = t ;
if (tcode == 0)
{
if (purchased)
a.prepare_bill(t_billno) ;
return ;
}
}
clrscr() ;
if (!item_found(tcode))
{
gotoxy(5,5) ;
cout <<"\7Item Code not found" ;
getch() ;
if (purchased)
a.prepare_bill(t_billno) ;
return ;
}
gotoxy(60,2) ;
cout <<"Date:" <<d1 <<"/" <<m1 <<"/" <<y1 ;
display_record(tcode) ;
do
{
valid = 1 ;
gotoxy(1,8) ; clreol() ;
gotoxy(1,24) ; clreol() ;
gotoxy(1,25) ; clreol() ;
gotoxy(3,25) ;
cout <<"ENTER QUANTITY TO BE PURCHASE IN Kg." ;
gotoxy(5,8) ;
cout <<"Quantity : " ;
48

gets(t_quantity) ;
qty = atoi(t_quantity) ;
if (t_quantity[0] == '0')
{
if (purchased)
a.prepare_bill(t_billno) ;
return ;
}
if (qty < 1 || qty > 800)
{
valid = 0 ;
gotoxy(3,24) ;
cout <<"\7 Range = 1..800" ;
getch() ;
}
} while (!valid) ;
do
{
gotoxy(5,10) ; clreol() ;
gotoxy(5,10) ;
cout <<"Do you want to cancel this purchase (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
} while (ch != 'N' && ch != 'Y') ;
if (ch == 'N')
{
purchased = 1 ;
fstream file ;
file.open("FOOD.DAT", ios::in) ;
file.seekg(0,ios::beg) ;
while (file.read((char *) this, sizeof(food)))
{
if (itemcode == tcode)
{
t_itemcode = itemcode ;
strcpy(t_itemname,itemname) ;
t_cost = itemcost ;
t_price = itemprice ;
t_qty = qty ;
a.add_bill(t_billno,t_itemcode,t_itemname,t_qty,t_cost,t_price) ;
i++ ;
49

break ;
}
}
file.close() ;
}
do
{
gotoxy(5,12) ; clreol() ;
gotoxy(5,12) ;
cout <<"Do you want to purchase more (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
} while (ch != 'N' && ch != 'Y') ;
} while (ch == 'Y') ;
a.prepare_bill(t_billno) ;
}
//**********************************************************
// THIS FUNCTION RETURNS THE BILL NO. OF THE LAST RECORD
// IN THE BILL FILE (BILL.DAT)
//**********************************************************
int account :: last_billno(void)
{
fstream file ;
file.open("BILL.DAT", ios::in) ;
file.seekg(0,ios::beg) ;
int t=0 ;
while (file.read((char *) this, sizeof(account)))
t = billno ;
file.close() ;
return t ;
}
//**********************************************************
// THIS FUNCTION ADDS THE RECORD IN THE BILL FILE (BILL.DAT)
//**********************************************************
void account :: add_bill(int t_billno, int t_itemcode, char t_itemname[30], float t_qty, float
t_cost, float t_price)
50

{
struct date d;
int d1, m1, y1 ;
getdate(&d);
d1 = d.da_day ;
m1 = d.da_mon ;
y1 = d.da_year ;
dd = d1 ;
mm = m1 ;
yy = y1 ;
code = t_itemcode ;
strcpy(name,t_itemname) ;
cost = t_cost ;
price = t_price ;
quantity = t_qty ;
billno = t_billno ;
fstream file ;
file.open("BILL.DAT", ios::out | ios:: app ) ;
file.write((char *) this, sizeof(account)) ;
file.close() ;
}
//**********************************************************
// THIS FUNCTION PREPARES AND DISPLAYS THE BILL FOR THE
// GIVEN BILL NO. ACCORDING TO PURCHASES MADE.
//**********************************************************
void account :: prepare_bill(int t_billno)
{
clrscr() ;
struct date d;
int d1, m1, y1 ;
getdate(&d);
d1 = d.da_day ;
m1 = d.da_mon ;
y1 = d.da_year ;
float total=0.0, total_bill=0.0 ;
gotoxy(33,3) ;
cout <<"CUSTOMER BILL" ;
gotoxy(32,4) ;
51

cout <<"~~~~~~~~~~~~~~~" ;
gotoxy(55,5) ;
cout <<"Date:" <<d1 <<"/" <<m1 <<"/" <<y1 ;
gotoxy(8,7) ;
cout <<"ITEMS PURCHASED" ;
gotoxy(8,8) ;
cout <<"~~~~~~~~~~~~~~~" ;
gotoxy(8,9) ;
cout <<"Item code Item name
Cost Price Qty Total" ;
gotoxy(8,10) ;
cout
<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" ;
int row=11 ;
fstream file ;
file.open("BILL.DAT", ios::in) ;
file.seekg(0) ;
while (file.read((char *) this, sizeof(account)))
{
if (billno == t_billno)
{
gotoxy(8,5) ;
cout <<"BILL NO. # " <<billno ;
gotoxy(8,6) ;
cout <<"~~~~~~~~~~~~~~~" ;
gotoxy(10,row) ;
cout <<code ;
gotoxy(18,row) ;
cout <<name ;
gotoxy(39,row) ;
cout <<cost ;
gotoxy(47,row) ;
cout <<price ;
gotoxy(56,row) ;
cout <<quantity ;
total = quantity * price ;
gotoxy(63,row) ;
cout <<total ;
total_bill = total_bill + total ;
row++ ;
}
}
file.close() ;
52

gotoxy(39,row+1) ;
cout <<"TOTAL BILL: Rs." <<total_bill <<" /=" ;
getch() ;
}
//**********************************************************
// THIS FUNCTION DISPLAYS THE LIST OF THE BILLS
//**********************************************************
void account :: bill_list(void)
{
clrscr() ;
fstream file ;
file.open("BILL.DAT", ios::in) ;
file.seekg(0) ;
int row=5, found=0, pageno=1, prev_billno=0, flag=0 ;
float total=0.0, total_bill=0.0 ;
gotoxy(30,2) ;
cout <<"LIST OF BILLS" ;
gotoxy(29,3) ;
cout <<"~~~~~~~~~~~~~~~" ;
gotoxy(3,4) ;
cout <<"Billno. Date
Item Code Item name
Cost Price Qty Total" ;
gotoxy(3,5) ;
cout
<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~" ;
while (file.read((char *) this, sizeof(account)))
{
row++ ;
delay(20) ;
found = 1 ;
if (prev_billno != billno)
{
if (flag)
{
gotoxy(52,row) ;
cout <<"TOTAL BILL: Rs." <<total_bill <<"/=" ;
total_bill = 0.0 ;
row++ ;
}
53

gotoxy(4,row) ;
cout <<billno ;
}
flag = 1 ;
gotoxy(11,row) ;
cout <<dd <<"/" <<mm <<"/" <<yy ;
gotoxy(24,row) ;
cout <<code ;
gotoxy(32,row) ;
cout <<name ;
gotoxy(52,row) ;
cout <<cost ;
gotoxy(59,row) ;
cout <<price ;
gotoxy(67,row) ;
cout <<quantity ;
total = quantity * price ;
gotoxy(73,row) ;
cout <<total ;
total_bill = total_bill + total ;
if ( row >= 23 )
{
row = 5 ;
gotoxy(66,1) ;
cout <<"Page no. : " <<pageno ;
pageno++ ;
gotoxy(1,25) ;
cout <<"Press any key to continue..." ;
getche() ;
clrscr() ;
gotoxy(30,2) ;
cout <<"LIST OF BILLS" ;
gotoxy(3,4) ;
cout <<"Billno. Date
Item Code Item name

Cost Price Qty

Total" ;
gotoxy(3,5) ;
cout
<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~" ;
}
prev_billno = billno ;
}
54

row++ ;
gotoxy(52,row) ;
cout <<"TOTAL BILL: Rs." <<total_bill <<"/=" ;
if ( !found )
{
gotoxy(5,10) ;
cout <<"\7Records not found" ;
}
gotoxy(66,1) ;
cout <<"Page no. : " <<pageno ;
gotoxy(1,25) ;
cout <<"Press any key to continue..." ;
getche() ;
file.close () ;
}
//**********************************************************
// THIS FUNCTION IS THE MAIN FUNCTION CALLING THE MAIN MENU
//**********************************************************
void main(void)
{
clrscr() ;
menu m ;
m.main_menu() ;
}

55

Input / Output Screens

Main Menu

56

See Menu

Edit

57

Add Item

Modify Item

58

Delete Item

Purchase

59

Total Bill

60

Testing
Testing is the only phase in the whole software development process that is
regarded as a destructive process rather than a constructive one. During the
testing phase, the engineer creates a series of test cases that are intended to
demolish the software that has been built. The basic testing principle that is
software engineer must understand before applying methods to design effective
test cases are:
All tests should be traceable to customer requirements.
Test should be planned long before testing begins.
Testing should begin in the small and progress toward testing in the
large.
To be most effective, an independent third party should conduct testing.
There are mainly two fundamental approaches to testing. These are:

Black Box: These check for the fundamental aspect of a system with the
little regard for the internal logic structure of the software. Black Box tests
are used to demonstrate that software function are operational, that input is
properly accepted and output is correctly produced, and the integrity of

external information is maintained.

White Box: These check for the correctness of the procedural details at
the grass root level of the code. White box testing is used to ensure that
internal operations are performed according to specification and all internal
components have been adequately exercised. White box testing of software
61

is predicated on close examination of procedural detail. Providing test cases,

which exercise set of conditions, exercise specific of conditions and or loop,
tests logical paths through the software.
The overall strategy for software testing may also be viewed in the context of the
spiral. The spiral model of software development has following types of testing:
Unit Testing: Unit testing begins at the vortex of the spiral and
concentrates on each unit (i.e., component) of the software as implemented
in source code. Using the component level design description as a,
important control paths are tested to uncover errors within the boundary of
the module. The unit test is White-box oriented and the step can be
conducted in parallel for multiple components. Tests of flow across a module
interface are required before any other test is initiated. In addition, local
data structures should be exercised and local impact on global data should
be ascertained during unit testing.
Integration Testing: Integration testing focuses on the design and the
construction of the software architecture. Integration testing is a systematic
technique constructing the program structure while at the same time
conducting test to uncover error associated with interfacing. The objecting is
to take unit tested component and build a program structure that has been
dictated by design.

Validation Testing: In validation testing, requirements established as

part of software requirement analysis are validated against the software that
has been constructed. Software validation is achieved through a series of
black box tests that demonstrate conformity with requirements. A test plan
outlines the classes of tests to be conducted and a test procedure. Hence,
special care was taken while performing validation testing.
Define specific test case that will be use to demonstrate conformity
requirement. Both the plan and the procedure are designed to ensure that
all requirements are satisfied, all behavioral characteristic are achieved, all
62

performance requirements are attained, documentation is correct, and

human engineered and other requirement are met.
System Testing: In system testing, the software and other system
elements are tested as whole. System testing is actually a series of tests
whose primary purpose is to fully exercise the computer-base system.
Although each test has a different purpose, all work to verify that system
elements have been properly integrated and perform allocated function. This
is the last test before the system can be declared successful.

Debugging
Debugging occurs as a consequence of successful testing. That is, when a test
case uncovers an error, debugging is the process that results in the removal of the
error. Debugging process begins with the execution of a test case. Results are
assessed

and

lack

of

correspondence

between

expected

and

actual

performance encountered. There are basically three approaches for debugging:

Brute Force: This category of debugging is probable the most common

and least efficient method for isolating the cause of a software error. We
apply Brute Force debugging method when all else fails. Using the let the
computer find the error memory dumps are taken, run-time traces are
invoked, and the program is loaded with WRITE statements.

Backtracking: Backtracking is a fairly common debugging approach

that can be used successfully in small programs. Beginning at the site where
a symptom has been uncovered, the code is traced backward until the site
of the cause is found.
63

Cause Elimination: This approach is manifested by induction and

deduction and introduces the concept of binary portioning. Data related to
the error occurrence are organized to isolate potential causes. A cause
hypothesis is devised and the aforementioned data are used to prove or
disprove the hypothesis.

Implementation Issues
The

implementation

fields

of

software

development

are

concerned

with

translating design specifications into source code. The primary goal of software
implementation is to write source code and internal documentation, so that the
conformance of the code to its design specification can be verified easily and
debugging, testing and modification of the written code can be easily carried out.
This goal can be achieved by making the source code as clear and straightforward
as possible. Simplicity, clarity and refinement are the distinctive features of a
good program.
Source-code clarity is enhanced not only by structured coding technique, but also
by appropriate supporting documents, by good coding style, by good internal
comments and by features provided in modern programming languages.
Production of a high quality software require that the program team have a good
designative leader, a well defined organizational structure and complete
64

understanding of the duties and responsibilities of each team member. The

implementation team should be provided with well-defined sets of software
requirements and architectural design specification and a detailed designed
specification.

User Manual
This program is specially designed keeping in view all the basic necessities of an
restaurant, which has keep track of hundreds of passenger along with their status
and general information, every day.
Starting from the option screen it gives seven options as shown below:

**********************FAST FOOD**********************
1.
2.
3.
4.

Purchase
See Menu
Edit
Total Bill
65

5.

Exit

1.Purchase
This option is used to purchase any item from the menu. You need to enter the
item code and the quantity to purchase any item.

2.See Menu
This option is used to see the menu available in the restaurant. It shows the
Item Code, Item Name, Item Cost, Item price.

3.Edit
This option has some sub-menus. They are the following:
a) Add Item: This option is used to add a new item in the menu.
b) Modify Item: This option is used to modify an existing item. This can be
done either by changing the Item code or Item Name or Item cost or Item
Price.
c) Delete Item: This option is used to delete a particular item from the menu.
d) Exit: This option is used to return the main menu.

4. Total Bill
This option is used to view the total bill of the customers. This shows the Bill
No, Date, Item Code, Item Name, Cost, Price, Quantity & Total.

5. Exit
This option is used to come out of the main menu.

66

Future Enhancements
A software package should always have enough accommodation to meet the
demand

for

future

aspects.

The

system

should

be

flexible

enough

to

accommodate changes. The system can be made more user-friendly by

introducing more facilities in it. Main menu, bill generation menu, and purchase
menu can be further improved by introducing some more facilities in them. Some
more ways of query can be added later on, according to the changing needs of
the system. We can also add a customer details menu.
The objective of the project work was to computerize the billing system, item
details system, purchase details system, in order to access the records easily and
to maintain the owners and accountants queries in an efficient manner. This has
been achieved by this software to quite an extent but can be improved upon.
67

Bibliography

1. Thinking in C++

- By Bruce Eckel

2. Complete Reference C++

- By Herbert Schild

3. Object Oriented Analysis & Design - By Grady Booch

4. Let us C++

- By Y. Kanetkar

68

69