You are on page 1of 97

LIST OF FIGURES

No. Figure no. Description of the figure Page no.

1. 1.1 Water fall model 20


. 34
3. 3.1 E-R Diagram 37
4. 4.1 Context level DFD 39

5. 4.2 First level DFD 40


6. 5.1 Flow chart for main menu 41

7. 5.2 Flow chart for opening new account 42


8. 5.3 Flow chart for performing transactions 43
9. 6.1 Use case diagram 46
10. 7.1 Testing process 52
11.. 7.2 Black box testing 53

LIST OF TABLES

Sno. Table no. Description of the table Page no.


1. 1.1 COST CATEGORIES 14
2. 1.2 BENEFIT CATEGORIES 15
3. 1.3 HARDWARE ENVIONMENT 23
4. 1.4 PERT PROCESS 35

6
LIST OF ABBREVATIONS

SNO. Abbreviations Description


1. E-R diagram Entity relationship diagram
2. DFD Data flow diagram
3 SDLC Software development Life Cycle

7
TABLE OF CONTENTS

I List of figures
II List of tables
III List of abbreviations

S.NO TOPIC Page No.

1. Introduction……………………………………….……………..10
1.1 Objective
2. Purpose ………………………………………………………….12
3. Problem Selection………………………………………………12
2.1 Problem definition
4. Need…………………………………………………………………...13
4.1 Hardware and Software used
5. Project Monitoring System……………………………………..…14
5.1 System maintenances
5.2 module description
6. System study…………………………………………………..…….18
6.1 feasibility study
a Technical Feasibility
b Operational Feasibility
c Economical Feasibility
7. System analysis….............................................................................21
7.1 System analysis phase
a Requirement analysis
a.1 Waterfall model.
a.2 Use case
b Problem analysis

8
c proposed system analysis
8. System design…………………………………………….31
8.1 Physical design
8.2 Input design
8.3 Data base and file design
8.4 Data flow diagram
8.5 Flow chart
9. System Testing and Implementation……………………….……….56
Introduction to Testing
Testing Objective
Testing and Quality Assurance
Testing and Types of testing
Manual Testing
Automated Testing
Testing Terminology
10. Evaluation of system………………………………………57
11. Limitation……………………………………………….....62
12. Documentation…................................................................................62
9.1Coding
9.2 Output
13. Conclusion….......................................................................................104
14. Scope of the Project………………………………………………….104
15. Bibliography………………………………………………........105
16. Appendices………………………………………………….......106

1 INTRODUCTION
Now days IT is backbone of business sector. In today‘s scenario all the sectors are adopting the IT
techniques for simplifying their work and solving the day-to-day Problems. Technology is serious
stuff. It empowers your organization and its stake holders to be effective. But it can‘t be defined

9
simply by bells and whistles. Efffective Technology requires a caring, functional relationship
behind it. As more-robust technology is implemented, it improves an enterprise‘s ability to adapt to
market charges.

Business organization these days concentrate on accountability, responsibility and communication


to increase throughput and maximum utilization of resources. People working in different
departments all should see same information. When one department finishes with the data entry it is
automatically routed to the next department. These all are also the requirements of publishing
houses.If we talk about manual or semi-automated system. Manual system is very time consuming
and prone to errors and later is less time consuming as compare to manual but it‘s also prone to
errors. In today‘s fast-track era where ‖Time is money‖ one has to fully automate the existing
system to beat the competitive world.
Since the advent of computers in the last two decades, every organization is going under the process
of computerization. The computerization has many benefits. Primarily, a computer is helpful in four
major aspects of any kind of organization:
• Time Efficiency
• Cost Effective
• Huge data storage capacity and
• Simple operation

10
1.1OBJECTIVE
Airlines mainly deal in providing the basic amenities of hospitalities to their customers. An airlines
system consists of many departments, and they deal in various services for their customers. In this
project I am trying to capture the functioning of a reservation system of airlines that is an integral
part of airlines management system.

This program shows you an insight into the reservation system of airlines. The whole
process of reservation process is shown with the help of this project. This software is used to
maintain the details of airlines and details of passenger with traveling details.
This project provides facility to keep details of airlines such as flight number, source, destination,
economic and executive charges etc.
This project also lets you keep the details of customers when he/she reserves a seat in
any flight such as name of customers, address, gender etc.
This project also provides you facility to edit the customers and flight information. You can
also delete existing entries.
This project also allows you to cancel a ticket, cancel all reservation of any flight.
This project also displays the waiting list of the passengers.

Section 1.01 This project also allows you to generate reports like passengers details, flight details
etc.
Section 1.02

2 PURPOSE
It is very important for creating a successful and robust project that the problem or need of the
client for which the project has to be developed should be clearly defined to the programmer.
Unless, the programmer does not clearly understand the problem for the solution of which the
project is to develop, he/she cannot develop a successful and bugs free software. Hence, relating to
our project named Airways Management System, the problem for the solution of which the project
has been developed is that of turning a big manual Air Reservation into a fully computerized one.

11
This software maintaining the details of passenger and airplanes.This also maintaining the
reservation & cancellation of ticket of passengers.

3 PROBLEM
One of the most difficult tasks of system analysis is developing a clear, in-depth under- standing of
the problem being investigated, without which it becomes impossible to specify the requirements
for a new project with any accuracy. Several questions should be posed for this.
Some of those may be:
What is the problem?
How complex is it?
What are its likely causes?
Why is it important that the problem be solved?
What are possible solutions to the problem?
What types of benefits can be expected once the problem is solved?
It takes considerable skill to determine the true cause of a systems problem. A systems analyst
might begin to define the problem by determining if the problem can be classified ac- cording to
one or more common types of systems problems. With knowledge of the Common types of
problems, the analyst can diagnose a problem by examining its characteristics.
Organizations usually face problems or have opportunity due to the following:
a new product or plant or branch
a new market or new process
failure of an existing system
inefficiency of an existing system
structural error in the existing system, etc.

For identifying problems/opportunities, we scan the following:


The performance of the system
The information being supplied and its form
The economy of processing
The control of the information processing

12
The efficiency of the existing system
The security of the data and software
The security of the equipment and personnel, etc.

After identification of the problem, it is defined and a general direction or method for solving this
problem is also determined. Then project boundaries are defined. The management establishes the
term of reference as well as the resources to be provided for the project. System development is an
iterative process and the first identifiable stage of it is Problem Definition, whose final output is
Terms of Reference.

Careful analysis of this system suggests a number of different problems:


1. Problem of Reliability: Current system is not reliable. It seems to vary in quality and results
from one month to the, next. Some times it gives good output, but some times the output is
worst.
2. Problem of Accuracy: There are too many mistakes in reports and calculations.
3. Problem of timeliness: In the current system the reports and output produced is mostly late and
in most of the cases it is useless because it is not on time.
4. Problem of Validity: The output and reports mostly contains misleading information. The
transactions and calculations are sometimes not valid.
5. Problem of Economy: The current system is very costly. We have to spend lots of money in
manual filing, calculations and remembering the information, but still not get the desired results.
6. Problem of Capacity: The current system is suffering from problem of capacity also. The
workload is too much. Few peoples cannot handle all the working.

4 NEEDS

4.1HARDWARE AND SOFTWARE USED


Whenever we develop software or project certain hardware and the programmer for developing the
project is using software. The hardware and software to be used by the programmer for developing
the project should be such that it would result in the development of a project, which would satisfy
all the basic needs for which the programmer has created the project.

13
HARDWARE USED:-
The Hardware used by the programmer for developing our project named ― Airlines
Management System‖ is as follows: -
(i) Pentium III computer – 700 mhz
(ii) Motherboard – Intel Chipset 800
(iii) Hard Disk capacity – 10 GB
(iv) RAM – 64 MB
SOFTWARE USED: -
The Software used by the programmer for developing our project named ― Airlines Management
System ‖ is as follows: -
1. Coding of the project – C++
2. Components of the project – C++
3. Maintenance and recording of data - Data Files
4. Documentation of the Project – MS WORD

5 PROJECT MONITORING SYSTEM

After the software has been developed, it is very important and essential to evaluate the project for
it‘s level of performance and to know whether it fulfills all the basic needs for which it has been
developed or not. The evaluation of the developed project can be done by compiling and running
the project on the same hardware platform, which is being used at the client site.

5.1SYSTEM MAINTENANCE: -
The maintenance phase of a system is the phase after implementation and before the system is
―terminated‖ or ―retired‖. The maintenance phase of the project is the phase where the system is
being run ―live ― and is actually being used by the users. In this phase, users ―use‖ the system – they
enter data, generate reports, run queries etc.
Maintenance phase of a system is typically 70% of the entire life cycle. It is the largest phase in the
life cycle. This phase is particularly ―challenging‖.
When the system is being run regularly, problems are faced which may require changes to the
system e.g. ―Bugs‖ which had not surfaced earlier or lack of understanding of some of the features

14
of the system, certain change in the requirements of client. Maintenance teams have to depend
heavily on the available documentation to understand the system.

After developing the software it is very essential to maintain the software in a proper way. The
programmer has also maintained the project named ―Hotel Management System‖ in a proper way.
For the maintenance of the software the programmer has used the following steps :-
(i) User Authentication :-The programmer has provided a high level of security to the software
by using the concept of User Authentication.
The programmer has provided for a separate password for the user of the project.

Authorization is the act of granting the permission to a person or a group or a program so that the
required activity can be done.

A password is a unique string of characters that a user types in as an identification code. For
example, when a user wishes to start work on a system, he has to enter a password. The system
compares the code against a stored password. If the code is legitimate, the system allows the user
access, at whatever security level has been approved for the owner of the password. Passwords are
used for checking (authenticating) the user and granting access only to authorized users.

No one can trespass the security of the project by entering the false user information. If the
password entered by the user were not correct, he/she would not be allowed to use the software.

(ii) Hiding of Logic used :- As the software has been created in C++, the programmer has been
successful in hiding the logic used in creating the project from the user. This ensures that the user
would not be able to make any changes to the coding of the project.

The whole project has been made of small functions, which are called by the different functions or
modules. So, unless and until the user is aware of the language he can‘t make any changes in the
project.

Since the work of making changes to the coding of project is that of programmer and not of user.
All this ensures the maintenance of the software at the highest level without sacrificing its security.

15
5.2MODULE DISCRIPTION
Air is the command to run this software from command prompt. You can also create a shortcut on
your desktop if you are using Windows.

After the program is started, the User is prompted for a password. The User has to enter the correct
password only then he would be granted access into the package otherwise not.
After entering the correct password, the User is shown the Main menu of the program.
The following pages show the various options available to the User. After this you will find details
about the various menus.
The details of the options is given below :-
Reservation
Cancellation
Passenger Records
Enquiries
List of Passenger
Waiting List
Quit

RESERVATION :-
In this module Airlines Management System is display the flight list and give prompt to enter the
serial no. of flight. When enter the s.no., system check whether this flight exists or not. If flight
number not exists then show error-message and give prompt to re-enter the flight number. If flight
number exist then system give prompt for enter the reservation details and passenger details. After
entering the information of passenger, system check
whether the seats are available in that flight or not. If the seats are available then system will show
you reservation details with unique ticket number. In case the seats are filled, system reserves the
seat on the basis of waiting list.
CANCELLATION :-
In this module system prompt to enter ticket number, system checks the ticket number. If ticket
number exists then system will cancel the reservation of ticket otherwise give error message
"Ticket no. is invalid" and exit from this module.
PASSENGER INFORMATION :-

16
In this module Airlines Management System show the information of the passenger. In this module
system prompt to enter ticket number, system checks the ticket number. If ticket number exist then
system display all the details related to the specified ticket no. If the specified ticket number do not
exist then system show error-message "Ticket not found".

ENQUIRIES :-
In this module Airlines Management System show the details of all flights, their flight no., source,
destination, charges etc.
LIST OF PASSENGERS :-
In this module Airlines Management System show the details of all flights and give prompt to enter
flight Number. When entering the flight Number, system checks whether flight Number exist or not
in data file.
After entering the flight number, system get ticket number and display all the details related to the
specified ticket no. If the specified ticket number do not exist then system show error-message
"Record not found".
WAITING LIST:-
In this module system display the waiting list of the passengers.
QUIT:-
In this module Airlines Management System allow you to exit the program.

6 SYSTEM STUDY

FEASIBILITY STUDY
Feasibility is the determination of whether or not the project at hand is worthwhile. The
process followed in making this determination is called a feasibility study. Feasibility study
determines whether a project can and should be done.
A. ECONOMIC FEASIBILITY: -
Economic analysis is the most frequently used technique for evaluating the effectiveness of
a proposed system. More commonly known as cost / benefit analysis; in this procedure we
determine the benefits and savings that are expected from a proposed system and compare them
with costs. We found the benefits outweigh the costs; we take a decision to design and implement
the new proposed system.

17
It is very essential to ascertain the cost, which is to incur for developing the project, before
starting the development of the project. If the benefit, which is to be accrued by developing the
software, exceeds the cost to be incurred for developing the project by a fair amount of margin, then
only the software should be developed. The process of cost and benefit analysis is not only limited
prior to the time period of development of the project, but this process is a continuous process, and
it keeps on going during the entire life cycle of the software.

ANALYSIS OF COST: -
The programmer has done the analysis of cost of the project named ―…………………….‖
in a very effective manner. According to the programmer, the total cost involved in the
development and implementation of the software at the client site would be around Rs. 50000. This
is so, as the ………………..is manual, a computer system is to be purchased to implement the
project at the……………. The computer system would cost around Rs.50000, the cost involved in
the development of the project would be around Rs.10000, the cost involved in the purchase of
software required for implementing the project would be around Rs.5000, and above all the cost of
training the manager to use the software is around Rs.5000 as the manager is not familiar with
computers.

ANALYSIS OF BENEFIT: -
As it is necessary to do cost analysis of the developed project, it is also very essential to do benefit
analysis along with it. The programmer has done the analysis of the benefit arising from the use of
the software named ―AIRWAYS TICKETING.‖ in a very effective way. The points which the
programmer has kept in mind while performing the task of benefit analysis of the software are as
follows:-
Stationery Cost: -
The use of stationery in the day-to-day functioning of the restaurant is on a large scale. Thus, the
cost of purchasing the stationery for the TICKETING is also very high. But, since after the
implementation of software it would become fully computerized, this step would save a big amount
of money, which is previously used for purchasing the stationery for the TICKETING Now, all the
work for which a large amount of stationery was being used previously can now be done on the
computer.
Manager Assistants Salary: -

18
In a restaurant, as there are number of activities involved in the day-to-day working, the workload
becomes so much that the owner of the TICKETING AGENCY has to keep two or more assistants
along with the Manager. This step increases the financial burden of the owner. Now, the owner has
to pay the salary of assistants along with the Manager‘s salary. But, since after the implementation
of the software, the whole of the work, which is previously spread over large number of files,
becomes computerized and centralized to a single computer, the work can now be handled by a
single person thus saving the cost of employing the manager assistants.
Thus, by doing the cost and benefit analysis of the software, we find that there are more
benefits arising by using the software as compared to the cost involved in the development and
implementation of the software.

B. TECHNICAL FEASIBILITY: -
This is concerned with specifying equipment and software that will successfully satisfy the user
requirement.
The technical needs of the system may vary considerably, but might include:
The facility to produce outputs in a given time.
Response time under certain conditions.
Ability to process a certain volume of transaction at a particular speed.
Facility to communicate data to distant location.

After examining technical feasibility, we give more importance to the configuration of the
system than the actual make of hardware. The configuration gives the complete picture about the
system's requirements: Twenty to thirty workstations are required; these units should be
interconnected through LAN so that they could operate and communicate smoothly. They should
have enough speeds of input and output to achieve a particular quality of printing.

C. OPERATIONAL FEASIBILITY: -
It is mainly related to human organizational and political aspects. The points to be considered are:
What changes will be brought with the system?
What organizational structures are disturbed?
What new skills will be required? Do the existing staff members have these skills?

19
If not, can they be trained in due course of time?

Generally project will not be rejected simply because of operational infeasibility but such
considerations are likely to critically affect the nature and scope of the eventual recommendations.
For operational feasibility study we appointed a small group of people who are familiar with
information system techniques, who understand the parts of the business that are relevant to the
project and are skilled in system analysis and design process.

7 SYSTEM ANALYSIS

7.1 SYSTEM ANALYSIS PHASE: -


The analysis phase defines the requirements of the system, independent of how these requirements
will be accomplished. This phase defines the problem that the customer is trying to solve. The
deliverable result at the end of this phase is a requirement document. Ideally, this document states
in a clear and precise fashion what is to be built. This analysis represents the ―what‖ phase. The
requirement document tries to capture the requirements from the customer's perspective by defining
goals and interactions at a level removed from the implementation details.
The analysis phase is a problem-solving phase. The problem is that in manual restaurant record
keeping system, excessive staff employment is required, extremely time consuming process is
involved, inconveniences to both customers as well as to the manager. So, while analyzing I found
many requirements expected from the system like: - to save time of both the manager as well as the
customer of the restaurant, to perform automatic calculation of bill according to the purchased made
by the customer. To reduce the whole paper work involved in restaurant, which otherwise without
computerization would very tedious to maintain and keeping it update. To make easy work
procedure which otherwise monotonous and tedious and involves at least two staff members, now
can be managed and handled by only one person.

So, the above description was the requirements of the system and the proposed system was
expected to perform these functions.
The requirement document may be expressed in formal language. Traditionally, the
requirement document is written in English or another written language.The requirement document

20
does not specify the architectural or implementation details, but specifies information at the higher
level of description.
The problem statement, the customer's expectations, and the criteria for success are examples
of high-level descriptions. There is a fuzzy line between high-level descriptions and low-level
details. Sometimes, if an exact engineering detail needs to be specified, this detail will also appear
in the requirement document. This is the exception and should not be the rule. These exceptions
occur for many reasons including maintaining the consistency with other established systems,
availability of particular options, customer's demands, and to establish, at the requirement level, a
particular architecture vision. An example of a low-level detail that might appear in the requirement
document is the usage of a particular vendor's product line, or the usage of some accepted computer
industry standard, or a constraint on the image size of the application. There is a fundamental
conflict between high levels and low levels of details. The requirement document states what the
system should accomplish, independent of many of the details. The discovery process used in
establishing the requirements during the analysis phase is best described as a refinement process
than as a levels-of-detail process.
Top-down and bottom-up approaches force a greater distinction between high levels and low levels
of detail. Interactive approaches lead to the refinement of those details.
Traditionally, the requirement document describes the things in the system and the actions that can
be done on these things. Things might be expressed as objects in an object-based technology where
data and algorithms are hidden behind hierarchical-polymorphic methods. Alternatively, things
might be expressed as services accessing databases in a functional approach where data is a
fundamentally different concept than functions. In general, the description of things in the system
can be much more general and not confined to a particular technology. In a more general sense, this
document describes the ontology that is the noun phrases and the verb phrases that will become the
guidelines for defining the application specific protocol.
The requirement descriptions of the things in the system and their actions do not imply an
architecture design rather a description of the artifacts of the system and how they behave, from the
customer's perspective. Later, in the design phase, these requirement descriptions are mapped into
computer science based primitives, such as lists, stacks, trees, graphs, algorithms, and data
structures.
The description of the abstraction of the noun phrases and the verb phrases are not bound to
the use of a written human language. Most written human languages are too vague to capture the
precision necessary to build a system. Alternative descriptive mechanisms based on mathematical

21
logic are sometimes more suitable but much more difficult to accomplish. Mathematical logic
provides a scientific foundation for precisely expressing information. However, frequently in the
real world, a precise description is not attainable. Again the requirement document should state in a
clear and precise fashion what is to be built. The definitive mechanism to author such a document,
either formally or informally, has yet to be developed, although reasonable success has been
achieved with existing methods including CASE tools and tools based on mathematical logic.
Later, in the design phase, the very important decomposition of the problem leads to the
development of data structures and algorithms. A functional decomposition for a distributed
environment leads to a natural split of the data structures and algorithms. Examples include
distributed client-server systems, where a database holds the data in a server while the algorithms
manipulating the data reside on the client. An object-based decomposition leads to a natural joining
of data structures and algorithms forming objects with methods. The requirement documents should
be independent of the decomposition technique. The analysis team develops the requirement
document, which talks about things and actions on things. This document should also include states,
events, typical scenarios of usage, and atypical scenarios of usage.

i. REQUIREMENT ANALYSIS: -
A software project is initiated by the client‘s need. In the beginning these needs are in the
minds of various people in the client organization. The requirement analyst has to identify the
requirement by talking to these people and understanding their needs.
Hence identifying requirements necessarily involves a specifying what some people have in their
minds. As the information in their minds by nature is not formally stated or organized, the input to
the software requirement specification is inherently informal and imprecise, and it is likely to
incomplete when inputs from multiple people are to be gather, as is often the case these inputs are
likely to be inconsistent as well.
Regardless of how the requirement process precedes it ultimately ends with the software
requirement specification.

a) Waterfall Model

Waterfall Model is the simplest model with each phase having a well defined starting and ending
point, with identifiable deliveries to the next phase.

The model consists of six distinct stages, namely:

22
Requirement Analysis Phase:
The problem is specified along with the desired service objective (goals) also the constraints are
identified.

Specification Phase:
The system specification is produced from the detailed definitions requirement analysis phase. This
document should clearly define the product ―to do‘s‖.

System and Software design Phase:


The system specifications are translated into a software representation.
The software engineer at this stage is concerned with:
 Data structure
 Software architecture
 Algorithmic detail, and
 Interface representations
The hardware requirements are also determined at this stage along with a picture of the overall
system architecture. By the end of this stage the software engineer should be able to identify the
relationship between the hardware, software and the associated interfaces. Any faults in the
specification should ideally not be passed ‗Down stream‘.

Implementation and Testing Phase:

The designs are translated into the software domain also detailed documentation from the design
phase can significantly reduce the coding effort. Testing at this stage focused on making sure that
any errors are identified and that the software meets its required specification.

Integration and System Testing Phase:


All the program units are integrated and tested to ensure that the complete system meets the
software requirements. After this stage the Software is delivered to the customer. The software
product is delivered to the client for acceptance testing.
Maintenance Phase:

23
This is usually the longest and the last stage of the software. In this phase the software is updated to
meet the changing customer needs, ability to accommodate changes in the external environment,
correct errors and oversights previously undetected in the testing phases, enhancing the efficiently
of the software.

The methodology that had been chosen from those previously studied methodologies is WATER
FALL MODEL as mentioned before also. The rational to it is that this method provides a
disciplined approach to assigning tasks and responsibilities within a development organization.
Estimates (i.e. budget, schedule, etc.) become more realistic as work progresses, because important
issues are discovered earlier. It is more able to cope with the changes that software development
generally entails. Its goal is to ensure the production of high-quality software that meets the needs
of its end-users, within a predictable schedule and budget. It helps to emphasize on alternatives and
constraints that supports the reuse of existing solutions. Maintenance is just another phase of the
spiral model. It is treated in the same way as development.

This will ensure that everybody that is involved in the project will get the same idea and pursuit to
the same path towards achieving the same goal.

PHASES IN WATERFALL MODEL :

Requirements

Design

Implementation

Verification

Fig.5.1 Maintenance

1.

24
b) USE CASE

Fig 5.2 Use case diagram

Login

BUYING A
TICKET

Status
Delivered

List of
members

Reservation pessenger

clerk clerk
Modification

Booking report

Exit

25
ii. PROBLEM ANALYSIS: -
In this project we have tried to simulate the functioning of ―…AIRWAYS‖ using C++. This system
automates the process of ―……AIRWAYS ‖. The system allows user to add items into the system
and provide list of all items in the system. The system also allows user to modify and delete into the
system.
iii. PROPOSED SYSTEM ANALYSIS: -
In this system Analysis, we have carefully study all the requirements of a … AIRWAYS
TICKETING and the system is designed in such a manner so the system should be user friendly.

(c) ADVANTAGES OF THE PROJECT: -


This project on AIRWAYS TICKETING.system tries to provide some amount of automation in
TICKETING .system. The objective of the project is to help AIRLINES TICKETING .in making
their business more efficient. It is also believed that automated system might be an added attraction
for their potential customers. It will also show the attitute of the management that they are aware to
the newly introduced technologies and ready to adopt them.

The system provides a very good user interface to make the system user friendly. The system also
provides features to gracefully come out from the system at any time to the main menu and select
any other game or can exit from the system.

26
TECHNICAL REVIEW
Software Life Cycle: -
It correspond broadly to the phases of the software life cycle namely:
User Requirements definition
Software Requirements definition
Architectural Design
Detailed Design and construction
Delivery to the user
Operations

To consider that the life cycle phases are disjoint in time (waterfall model) is a simplification.
Frequently the tasks of different phases are performed somewhat in parallel (concurrent
engineering). It is however important to distinguish them logically, and identify documents that are
the outcome of the various phases.

The Software Process :


A process is the set of actions, tasks and procedures involved in producing a software system,
throughout its life cycle. A "good" software process must be predictable: cost estimates and
schedules must be met, and the resulting product should be robust and offer the required
functionality.
The objectives of software management are to produce according to plan and to improve the
capability to produce better systems. The basic principles are those of statistical process control,
used successfully in many fields of industry. A process is under statistical control if its future
performance is predictable within established statistical limits. The cornerstone of statistical process
control is measurement, and measuring the software process is not easy. One needs to define the
appropriate reliable metrics, provide the infrastructure, and consider that people are involved and
may resent being "measured".

Maintenance :
Once the software is developed, tested and delivered, users will start to work with it, and
suggestions and bug reports will come in. The maintenance team will sort this input and set

27
priorities. After improving the software the development team carries out regression tests (i.e. old
tests still work and no new bugs are introduced). They may also have to introduce new test
programs for the newly detected bug.

User Requirements: -
The UR phase is the `problem definition phase' of a software project. The scope of the system must
be defined. The user requirements must be captured. This may be done by interview or survey, or
by building prototypes. Specific user requirements must be identified and documented in the User
Requirements Document (URD).

The involvement of the developers in this phase varies according to the familiarity of the users with
software. Some users can produce a high quality URD, while others may need help from the
developers.

The URD must always be produced. The review of the URD is done by the users, the software and
hardware engineers and the managers concerned."

System Requirements: -
The SR phase is the `analysis' phase of a software project. A vital part of the analysis activity is the
construction of a `model' describing `what' the software has to do, and not `how' to do it. Building
prototypes to clarify the software requirements may be necessary.

The principal deliverable of this phase is the Software Requirements Document (SRD). An SRD
must always be produced for every software project. Implementation terminology should be
omitted from the SRD."

They contain the traceability matrix that proves the SRD's completeness: System Requirements
cover all User Requirements and nothing more.
To formulate the User and System Requirements according to a given framework, one may use
specialized tools such as DOORS. These tools check the consistency between Requirements and
automatically maintain traceability information.

28
Questionnaire: -
The Manual Procedure of a …AIRWAYS TICKETING .management System was observed. This
was essential to analyze the flow of information and the actual usage of software programs. There
may customize procedure adapted by the AIRWAYS .management. Those procedures must study
deeply, to satisfy the client. This was helpful to design the reporting requirements from the
software.

For the purpose of designing an effective software package, a Questionnaire was prepared and
different Management Staff were interviewed to access their requirement and how the proposed
software can benefit them.

Given below are the questions that were put to different people: -
A) Does it take more time to register .?
B) Is the payment made is valid during the year, visible?
C) How long does it take to process takes.?
D) Is it possible for different level of staff to view related information?
E) Can one get the list of all employees in different departments?
F) Do you think Computerization will improve things?

Different people had different answers to the above questions.

However a ‗YES‘ was received as an answer to the final question. This boosted our confidence in
the selection of the project.

8 SYSTEM DESIGN

8.1 PHYSICAL DESIGN

Design Methodology: -
Database and database systems have become an essential component of everyday life in modern
society. In the course of a day, most of us encounter several activities that involve some interaction
with the database. For example, if we go to the bank to deposit or withdraw funds or if we make a

29
Hotel or Railways Reservation, chances are that our activities will involve someone accessing a
database.

The above interactions are examples of what we may call traditional database applications, where
most of the application that is stored and accessed is either textual or numeric. In our project we
will concentrate on this aspect of computer application.

There are several ways to implement databases. Some of them are file handling mechanism,
relational database, object-relational database or object-oriented databases. In our project we will
use file-handling feature provided by C++ Language.

The name of the project is airways ticketing System. This project is made in C++. The project is
developed in such a way to provide very efficient and effective user interface of the project. I got
inspiration to make this project from my cousine doing job in airlines agency to book airtickets
where all the work of record keeping is done manually.
This project has a facility of maintaining records of……airways tickets.
We can book the ticket. from the menu list, display all the existing records etc. to modify and
delete any existing item. We can generate ticket booked / purchased by the customer from the main
menu This option minimizes the risk of less or wrong collection of amount from the customer as
this option prepares a fair ……….for the ……………………
8.2 INPUT DESIGN: -

Meaning of Input Design:


Once the analysis and design of the system has been done, it would be necessary to identify the data
that are required to be processed to produce the outputs. Input is one of the most expensive phases
of the operation of a computerized system and creates sometimes a major problem. Different type
of problems with a system can usually be tracked back to faulty input design method. Needless, to
say, therefore, that the input data are the lifeblood of a system and have to be analyzed and designed
with utmost care and consideration. Input design features can ensure the reliability of the system
and generate correct reports from the accurate data. The input design also determines whether the
user can interact efficiently with the system.

30
Objective of Input Design
The design of input play very significant role in getting the correct output. It covers all phases of
input from creation of initial data to actual entering the data to the system for processing. The input
design is the link that ties the information system into the world of its users. Some features of
design may vary depending on whether the system is batch-oriented or on-line. The various
objectives of input design are:-

Controlling amount of input :


An effective design controls the quantity of data for input. Data preparation and data entry
operations depend on people. Since labour costs are high, the cost of preparing and entering data is
also high. It is quite evident, then, that reducing data requirements mean lowering costs through
reduced labor expense. The input phase of computing can be a slow process and take many times
longer than that needed by computers to carry out their tasks. In fact, the computer itself may sit
idle until data is prepared and input for processing. By reducing input requirements, the analyst will
speed the entire process from data capture to processing to provide results to users.

1) Avoiding Delay :
When the processing is delayed owing to data preparation or data entry, the cause is called a
bottleneck. Avoid bottlenecks when designing input should always be one of the objectives of the
analyst.

2) Avoiding Errors in Data :


The third objective deals with errors. In one sense, the rate at which errors occur is dependent on
the quantity of data. Since the lower the amount of data is inputted, there are fewer opportunities for
the error to occur. The analyst can reduce this number by reducing the volume of data that must be
entered for each transaction. The analyst can also affect error rates of an operation through design.
The manner in which data must be entered can reduce the chance of errors. Still, a third aspect of
error control is the need to detect errors when they occur. Checks and balances in the data entry
programs, called input validation techniques, also detect errors in input.

31
3) Avoiding Extra Steps :
Sometimes the volume of transactions and the amount of data preparation or data entry jobs
resulting from them cannot be controlled. For example, in bank cheque processing runs or in large
retail sales firms, the number of transactions to process runs into the tens of thousands. When the
volume cannot be reduced, the analyst must be sure that the process is efficient. The experienced
analyst will also avoid input designs that cause extra steps. The effect of saving a single step when
feeding details of cheque into the banking process is multiplied many times over in the course of a
working day. So is the additions of a single step.

4) Keeping the Process Simple :


Perhaps the best advice to analysis is to achieve all of the objectives mentioned in the simplest
manner possible.

The best designed system fits the people who will use it in the way that is comfortable to them, and
at the same time it provides the error control methods management acceptable to the users. In
contrast, one will have to work to get users to accept complex or confusing input designs, and there
is no guarantee he will succeed in installing and running complex system. So it is advisable to avoid
complexity when there are simple alternatives.

Major Concerns Regarding Input: -

1) The Inputs Needed :-


The input needed for any program is determined by the output desired. Any time the use of a
transaction file is being considered, or the data is to be entered from a terminal, the analyst must
check each field to determine whether the data is already in a master file or might be included in a
table. The analyst must be concerned that all of the data required to produce that output is entered
into the program in the most efficient and cost effective manner.

32
2) How and where is the input created :-
How the input is generated, and where it is generated, has a direct impact on a number of other
questions. In a cost accounting system, much of the data is generated when material is put into
production. The analyst should attempt to provide a reliable means of entering data directly into the
system from the factory. Data collection devices or special terminals can be used to enter some of
the data.

3) Designing the source document and the Input Format :-


The formats for the input records and the source documents should be determined. The source
document can be designed as soon as it is determined what data is needed and where and how it is
to be entered into the system. The analyst should work with the data entry supervisor. The design of
the documents should permit the personnel recording the data to do so as easily and rapidly as
possible. Check Boxes can be used, which reduce the time needed to fill out documents and
minimize recording errors.

4) Input Medium: -
An input method that requires a minimal amount of data conversion should be selected. If
punched-card recorders, diskette recorders, key-to—key tape recorders, or terminals are used, the
data is usually recorded on a source document and then transferred to the machine processable
medium. In case of process control however, these media based programs directly control the target
machines.

M E T HO D O LO GY A D OP T ED
Process of designing a program consisting of a hierarchical structure can be viewed in two ways:

 TOP - DOWN
 BOTTOM – UP

a. TOP - DOWN APPROACH

A design is said to be top – down if it consists of a hierarchy of modules with each module having a
single entry and a single exit subroutine. Design starts with the specification of the function to be

33
performed by a program and then breaking it down into progressively subsidiary functions.
Division progresses with increasing level of details and the function at each level results in a
module.

This approach usually adopts a concept of designing a calling module before the called module. At
the time of designing a called module, broad functions / tasks to be carried out by it‘s immediate
subordinate modules are assumed. The details of that called subordinate functions are not taken into
consideration until those modules are taken up for designing. Hence, top-down design involves
successive refining the functions and this continues until the subordinate modules reduce to such a
state that they can be designed without further analysis i.e. the terminal modules assume a shape of
such simplicity that they can be easily programmed in source language.

Top-down approach can be interpreted as tree structure / hierarchical structure as:

MODULE 1

MODULE 2 MODULE 3 MODULE 4

MODULE 5 MODULE 6 MODULE 7 MODULE 8 MODULE 9

BOTTOM-UP APPROACH

Bottom-up approach is another face of top-down approach. Design begins with identification of a
set of modules which are either available or to be constructed. An attempt is made to combine lower
level modules to form modules of a high level. This process of assembling continues until the
program is realised. Bottom-up approach always assumes that the lowest level modules are
completely specified and designed before hand, which in reality is seldom possible. Hence,
generally this bottom-up approach does not meet all the requirements of the desired program.

34
a) Design Methodology:-

Database and database systems have become an essential component of everyday life in modern
society. In the course of a day, most of us encounter several activities that involve some interaction
with the database. For example, if we go to the bank to deposit or withdraw funds or if we make a
Hotel or Railways Reservation, chances are that our activities will involve someone accessing a
database.

The above interactions are examples of what we may call traditional database applications, where
most of the application that is stored and accessed is either textual or numeric. In our project we
will concentrate on this aspect of computer application.
There are several ways to implement databases. Some of them are file handling mechanism,
relational database, object-relational database or object-oriented databases. In our project we will
use file-handling feature provided by C++ Language.

The name of the project is Airways Management System. This project is made in C++. The project
is developed in such a way to provide very efficient and effective user interface of the project. I got
inspiration to make this project from IGI Airport, New Delhi.

This project has facility of maintaining records of Flights and Passengers.

One seat can reserve only for one passenger. Passenger can cancel the reserved ticket. Ticket can
reserve only if flight exists. This project also generates the report of passengers.

8.3DATABASE AND FILE DESIGN

a) Database Design: -

TICKET.DAT:

Used to store the information related to ticket.

35
Detailed structure

Name Description
Fltno Flight No
S_time Flight Time
From From
To To
Ecofair Economic Fare
Exefair Executive Fare

Pas.DAT:

Used to store the information related to passenger.


Detailed structure

Class Travelling Class


Name Passenger Name
Address Address
Sex Sex
Category Passenger Category
Slno Passenger Sl. No.
Age Age
TicketNo Ticket No
SeatNo Seat No

b) Program File Design: -


As I have stated earlier, the programming language used for developing ―Airway Management
System‖ software is C++. The programmer in developing the ―Airway Management System‖

36
project is using a very fine and step-by-step methodology. While making this project I kept in my
mind, that user should not face any difficulty while using this software. The user of the project has
been provided with nine simple and well-formed options to use the project. The options very much
clear and produce no confusion in mind of the user. This project contains basically four classes
namely as

Class DRAW:-
The functions which are declared public are:-

void LINE_HOR(int, int, int, char)


void LINE_VER(int, int, int, char)
void BOX(int,int,int,int,char)
void ENTER_PASSWORD()
void BOX_PASSWORD(void)

Class TICKET:-
This class contains all important functions relating to the ticket like the function which are declared
as public:

void ADDITION(void)
void ENQUIRY(void)
char *FLIGHTNO(int)

The functions which are declared as private are:-

void ADD_RECORD(char[10],char[15],char[15],char[15],int, int)

37
Class PASSANGER:-

This class includes basically those function relating to the passenger.

The public declaration as:

void ADD_RECORD(int, int, char[26], char[36], int, int, char, char,char) ;


void DELETE_TICKET(int) ;
int DELETE_FLIGHT(int) ;
void LIST(void) ;
void WLIST(void) ;
int LAST_TICKETNO(void) ;
int SEATS(int) ;
int FOUND(int) ;
char *NAME(int) ;

Class RESERVE: - This class contains public functions as:-

void RESERVATION(void) ;
void CANCELLATION(void) ;
void DISPLAY_TICKET(void) ;
void DELETE_ALL(void) ;

SYSTEM IMPLEMENTATION: -

As we know, creating software is one thing and the implementation of the created software is
another. The process of implementing software is much difficult as compared to the task of creating
the project. First we have to implement the software on a small scale for removing the bugs and
other errors in the project and after removing them we can implement the software on a large scale.
We have also implemented our project named ―Airlines Management System‖ on a small scale

38
now, to see whether it is working fine or not without any errors, and after testing and evaluating the
software we will implement it on a large scale.

Before we think in terms of implementing the Software on a large basis, we must consider the
Hardware requirements.

Whenever we develop software or project certain hardware and the programmer for developing the
project is using software. The hardware and software to be used by the programmer for developing
the project should be such that it would result in the development of a project, which would satisfy
all the basic needs for which the programmer has created the project. The Hardware should be such
that cost constraints of the Client should also be taken into account without affecting the
performance.

For the Development of the Software program, we have selected ‗C++‘ because ‗C++‘ has a wider
acceptance in the Industry. Operators cannot makes changes in the Database structure, and hence a
great deal of security is maintained. Everything has to be operated through the software itself. Also
an EXE file can be created and the same can be delivered to the User.

No additional software is required for this Package. The User need have only the basic Operating
Software (OS) on his computer.

The developed software runs under DOS as well as WINDOWS OS.

Whenever we develop software or project certain hardware and the programmer for developing the
project is using software. The hardware and software to be used by the programmer for developing
the project should be such that it would result in the development of a project, which would satisfy
all the basic needs for which the programmer has created the project.

8.4 DATA FLOW DIAGRAM


Data flow diagrams are commonly used during problem analysis. Data flow diagrams are quite
general and not limited to problem analysis for software requirement specification.

39
A DFD shows the flow of data through a system. It views a system a function that transforms the
inputs into desired outputs. Any complex system does not perform this transformation into a single
step and a data will typically undergo a series of transformation before it becomes an output. The
DFD aims to capture the transformations that take place within a system to the input data so that
eventually the output data is produced.
The agent that performs the transformation of data from one state to another is called a process. So,
a DFD shows the movement of data through the different transformations or processes in the
system. Named circles show the processes and data named arrows entering or leaving the bubbles
represent flows.

Process Activity

The rectangle represents a source and sink and is a net originator or consumer of data. A source or
sink is typically outside the main system of study.

Originator or Consumer of data

All external files are shown as a labeled straight line.

File name

The need ofr multiple data flows by a process is represented by a ―*‖ between the data flows.the
symbol represents the AND relationship.for example, if there is a ―*‖ between the two input data
flows A and B for a process,it means that A AND B are needed for the process.
A

*
B

40
DFD OF THE PROJECT

CLERK
TICKET.DAT
Information Data

Data
Level DFD (IstRESERVATION
Information
Context Level) PAS.DAT

Ticket

Data PASSENGER
Airlines
CANCELLATION Refund

Data Air
Database Access Reservation Reports
Data System
Storage

Passenger

41
DFD(0th level)

AIR REPORT
RESERVATION
DATA SYSTEM
BASE

PASSENGER

DFD (Ist Level)

Airlines

42

Add
DFD (IInd Level)

1 Air 2 Passenger

2 Passenger 2 Passenger
2 Passenger 1 Air

Reservation Cancellation Waiting list Reports

1 Air

Passenger

43
8.5 FLOW CHART
A flowchart is a common type of diagram, that represents an algorithm or process, showing the
steps as boxes of various kinds, and their order by connecting these with arrows. Flowcharts are
used in analyzing, designing, documenting or managing a process or program in various fields.

Section 1.03 Flowchart building blocks


(a) Symbols

A typical flowchart from older Computer Science textbooks may have the following kinds of
symbols:

(i) Start and end symbols


Represented as circles, ovals or rounded rectangles, usually containing the word "Start" or "End", or
another phrase signaling the start or end of a process, such as "submit enquiry" or "receive product".

(ii) Arrows
Showing what's called "flow of control" in computer science. An arrow coming from one symbol
and ending at another symbol represents that control passes to the symbol the arrow points to.

(iii) Processing steps


Represented as rectangles. Examples: "Add 1 to X"; "replace identified part"; "save changes" or
similar.

(iv) Input/Output
Represented as a parallelogram. Examples: Get X from the user; display X.

(v) Conditional or decision


Represented as a diamond (rhombus). These typically contain a Yes/No question or True/False test.
This symbol is unique in that it has two arrows coming out of it, usually from the bottom point and
right point, one corresponding to Yes or True, and one corresponding to No or False. The arrows
should always be labeled. More than two arrows can be used, but this is normally a clear indicator

44
that a complex decision is being taken, in which case it may need to be broken-down further, or
replaced with the "pre-defined process" symbol.

A number of other symbols that have less universal currency, such as:

A Document represented as a rectangle with a wavy base;


A Manual input represented by parallelogram, with the top irregularly sloping up from left to
right. An example would be to signify data-entry from a form;
A Manual operation represented by a trapezoid with the longest parallel side at the top, to
represent an operation or adjustment to process that can only be made manually.
A Data File represented by a cylinder.

Flowcharts may contain other symbols, such as connectors, usually represented as circles, to
represent converging paths in the flowchart. Circles will have more than one arrow coming into
them but only one going out. Some flowcharts may just have an arrow point to another arrow
instead. These are useful to represent an iterative process (what in Computer Science is called a
loop). A loop may, for example, consist of a connector where control first enters, processing steps,
a conditional with one arrow exiting the loop, and one going back to the connector. Off-page
connectors are often used to signify a connection to a (part of another) process held on another sheet
or screen. It is important to remember to keep these connections logical in order. All processes
should flow from top to bottom and left to right.

45
(b) Examples

A simple flowchart for computing factorial N (N!)


A flowchart for computing factorial N (N!) where N! = (1 * 2 * 3 * ... * N). This flowchart
represents a "loop and a half" — a situation discussed in introductory programming textbooks that
requires either a duplication of a component (to be both inside and outside the loop) or the
component to be put inside a branch in the loop.

Section 1.04 Types of flowcharts


There are many different types of flowcharts. On the one hand there are different types for different
users, such as analysts, designers, engineers, managers, or programmers. On the other hand those
flowcharts can represent different types of objects. Sterneckert (2003) divides four more general
types of flowcharts:

Document flowcharts, showing a document flow through system


Data flowcharts, showing data flows in a system
System flowcharts showing controls at a physical or resource level
Program flowchart, showing the controls in a program within a system

However there are several of these classifications. For example Andrew Veronis (1978) named
three basic types of flowcharts: the system flowchart, the general flowchart, and the detailed
flowchart. That same year Marilyn Bohl (1978) stated "in practice, two kinds of flowcharts are used

46
in solution planning: system flowcharts and program flowcharts. More recently Mark A. Fryman
(2001) stated that there are more differences. Decision flowcharts, logic flowcharts, systems
flowcharts, product flowcharts, and process flowcharts are "just a few of the different types of
flowcharts that are used in business and government.

Section 1.05 Software


(a)
(b) Manual
Any vector-based drawing program can be used to create flowchart diagrams, but these will have no
underlying data model to share data with databases or other programs such as project management
systems or spreadsheets. Some tools offer special support for flowchart drawing, e.g.,
ConceptDraw, SmartDraw, Visio, and OmniGraffle.

(c) Automatic
Many software packages exist that can create flowcharts automatically, either directly from source
code, or from a flowchart description language. For example, Graph::Easy, a Perl package, takes a
textual description of the graph, and uses the description to generate various output formats
including HTML, ASCII or SVG.

(d) Web-based
Recently, online flowchart solutions have become available, e.g., DrawAnywhere. It is easy to use
and flexible but does not meet the power of off-line software like Visio or SmartDraw.
In procedural language program is started with the first line and follow a pre-defined path. Flow
chart is used to define that pre-defined path and it show the flow of control throughout the program.

START

Enquiry

Reservation A

47
Cancellation B
A

Enter S.No. of
the flight

If No
Enter correctly.
Found?

Yes

Enter class (E/X)


you want to travel

Enter the information


of the passenger

Save data into data


file.

Return

48
B

Declare variables

Do

Enter ticket no. of


the passenger

If No Record not found.


found?

Yes

Show the details of


the passenger.

Cancel this ticket and


update file.

Return

49
C

Passenger 1) F
Information

2) G
Delete

Return

50
F

Declare variables

Do

Enter ticket no. of


the passenger.

If No Record not found.


found?

Yes

Show the details of


the passenger.

Return

51
G

Enter S.No. of the flight for


deleted all the records of the
passengers.

If No
Enter correctly.
Found?

Yes

Records deleted.

Return

52
D

Enter S.No. of
the flight

If No
Enter correctly.
Found?

Yes

Declare variables
and open file.

Display the list of the


existing passengers

Return

53
E

Enter S.No. of
the flight

If No
Enter correctly.
Found?

Yes

Declare variables
and open file.

Display the waiting


list of the passengers

Return

54
Implementation

Implementation is the stage of the project where the theoretical design is turned into a working
system. At this stage the main work load, the greatest upheaval and the major impact on the
existing system shifts to the user department. If the implementation is not carefully planned and
controlled, it can cause chaos and confusion. Implementation includes all those activities that take
place to convert from the old system to the new one. The new system may be totally new, replacing
an existing manual or automated system or it may be a major modification to an existing system.
Proper implementation is essential to provide a reliable system to meet the organization
requirements. Successful implementation may not guarantee improvement in the organization
using the new system, but improper installation will prevent it. The process of putting the
developed system in actual use is called system implementation. This includes all those activities
that take place to convert from the old system to the new system. The system can be implemented
only after thorough testing is done and if it is found to be working according to the specifications.
The system personnel check the feasibility of the system.
The most crucial stage is achieving a new successful system and giving confidence on the new
system for the user that it will work efficiently and effectively. It involves careful planning,
investigation of the current system and its constraints on implementation, design of methods to
achieve the changeover. The more complex the system being implemented, the more involved will
be the system analysis and the design effort required just for implementation. The system
implementation has three main aspects. They are education and training, system testing and
changeover. The implementation stage involves following tasks:
Careful planning
Investigation of system and constraints
Design of methods to achieve the changeover
Training of the staff in the changeover phase
Evaluation of the changeover method

The method of implementation and the time scale to be adopted are found out initially. Next the
system is tested properly and the same time users are trained in the new procedures.

55
9 TESTING

Testing is major quality control measure used during software development. Its basic function is to
detect errors in the software. During requirements analysis and design the output is a document that
is usually textual and non-executable after the coding phase, computer programs are available that
can be executed for testing purposes. This implies that testing not only has to uncover errors
introduced during coding, but also errors introduced during the previous phases. Thus the goal of
testing is to uncover requirement, design and coding errors in the programs. Consequently, different
levels of testing are used.

The stating point of testing is Unit Testing. In this, a module is tested separately and is often
performed by the coder himself simultaneously along with the coding of the module. The purpose is
to exercise the different parts of the module code to detect coding errors. After this, the modules are
gradually integrated into sub system, which are then integrated eventually from the entire system.
During integration of modules, integration testing is performed to detect design errors by focusing
on testing the interconnection between modules.

After the system is put together, system testing is performed. Here the system is tested against
system requirements to see if all the requirements are met and if the system performs as specified
by the requirements. Finally, acceptance testing is performed to demonstrate to the client, on the
real life data of the client, the operation of the system.

Testing is an extremely critical and time-consuming activity. It requires proper planning of the
overall testing processes. Frequently the testing process start with a test plan that identifies all the
testing – related activities that must be performed and specifies the schedule allocates the resources,
and specifies guidelines for testing. The test plan specifies conditions that should be tested, different
units to be tested, and the manner in which the modules will be integrated together. Then for
different test units, a test case specification document is produces, which lists all the different test
cases, together with expected outputs. During the testing of the unit, the specified test cases are
executed and the actual result compared with the expected outputs. The final output of the testing
phase is the Test Report and the Error Report, or a set of reports (one for each unit tested). Each test

56
report contains the set of test cases and the result of executing the code with these test cases. The
error report describes the error encountered and the action taken to remove the errors.

Why testing is so hard?


Software testers and developers-two very different functions-play. Assuming that the bugs users
report occur in a software product that really is in error, the answer could be any of these:

The user executed untested code. Because of time constraints, it's not uncommon for developers to
release untested code-code in which users can stumble across bugs.

The order in which statements were executed in actual use differed from that during testing. This
order can determine whether software works or fails.

The user applied a combination of untested input values. The possible input combinations that
thousands of users can make across a given software interface are simply too numerous for testers
to apply them all. Testers must make tough decisions about which inputs to test, and some times we
make the wrong decisions.

The user's operating environment was never tested. We might have known about the environment
but had no time to test it. Perhaps we did not (or could not) replicate the user's combination of
hardware, peripherals, operating system, and applications in our testing lab. For example, although
companies that write networking software are unlikely to create a thousand node network in their
testing lab, users can and do create such networks. Through an overview of the software testing
problem and process, this article investigates the problems that testers face and identifies the
technical issues that any solution must address. I also survey existing classes of solutions used in
practice.

Software testing is arguably the least understood part of the development process. Through a four
phase approach, the author shows why eliminating bugs is tricky and why testing is a constant
tradeoff.

57
Virtually all developers know the frustration of having software bugs reported by users. When this
happens, developers inevitably ask:

How did those bugs escape testing?

Countless hours doubt less went into the careful testing of hundreds or thousands of variables and
code statements, so how could a bug have eluded such vigilance?

The answer requires, first, a closer look at software testing within the context of development.

Second, it requires an understanding of the role practice tutorial to get a clearer view of some of
software testing inherent difficulties, we can approach testing in four phases:

-Modeling the software's environment


-Selecting test scenarios
-Running and evaluating test scenarios
-Measuring testing progress

These phases offer testers a structure in which to group related problems that they must solve before
moving on to the next phase.

Every software development organization tests its products, yet delivered software always contains
residual defects of varying severity. Sometimes it's hard to imagine how a tester missed a
particularly glaring fault. In too many organizations, testers are ill equipped for the difficult task of
testing ever more complex software products. Informal surveys of seminar audiences suggest that
few of those who perform testing (either as a profession or as an adjunct to development or other
roles) have been adequately trained in testing or have software testing books on their desks.

The methods described here can help testers provide a sensible answer to the question of what they
really mean when they say they are done testing a software system.

There are three basic approaches to testing.

58
Functional Testing
Structural Testing
System Testing

In Functional Testing the structure of the program is not considered. Test cases are decided solely
on the basic of the requirements or a specification of the program or module, and the internals of
the module or the program are not considered for selection of test cases. Due to its nature,
functional testing is often called ―Black Box Testing ―.
In Structural Testing, test cases are generated based on the actual code of the program or module to
be tested. This structural approach is sometimes called ―Glass Box Testing ―. To test the structure
of the program a structural testing aims to achieve test cases that will force the desired converse of
different structures. Various criteria have been proposed for this. Unlike the criteria for functional
testing, which are frequently imprecise, the criteria for structural testing are generally quite precise
as they are based upon program structures, which are formal and precise

System Testing: In this testing we check whether all the operations of the system is performing
correctly or not. Here we take entire system as a unit and check the system for the correct
functioning of all the modules and their specified interdependence.

Software testing topics


1. Scope
2. Defects & failures
3. Compatibility
4. Input combinations and preconditions
5. Static vs. dynamic testing
6. Software validation and verification

Testing methods
Software testing methods are traditionally divided into black box testing and white box testing.
These two approaches are used to describe the point of view that a test engineer takes when
designing test cases.

59
Black box testing

Black box testing treats the software as a black box without any knowledge of internal
implementation. Black box testing methods include equivalence partitioning, boundary value
analysis, all-pairs testing, fuzz testing, model-based testing, traceability matrix, exploratory testing
and specification-based testing.

White box testing

White box testing, by contrast to black box testing, is when the tester has access to the internal data structures and
algorithms.

10 EVALUATION OF SYSTEM :-

After developing the software it is very essential to evaluate it to know whether it solves the defined
problem for which it has been created or not. By evaluating the software we can also know the
extent to which the created software solves the given problem. The software named ―…………….‖
has also been evaluated by the programmer in the following ways :-

(a) The said project has been compiled and being run on the same hardware platform to be used at
the client site by the programmer. This is very essential to do as the programming language i.e.
C++, in which the software has been created is not platform independent.

(b) The said project has also been compiled and run in the presence of the client for whom the
project has been prepared. The Time period used for evaluating the software has been 2 weeks.

11 LIMITATIONS

At the end of the project we want to put our attention on the some of the limitations of the projects.

In our project we have used C++. it uses the file handling features of C++. It is a very obsolete
techonology for database management. But it doesn‘t support multi user environment.

60
Again our project is highly concentrated on the process on bank transaction done by Banking
system. But it doesn‘t cover other aspect like loans, the issue of cheques, types of accounts etc.

12 CODING

Once the design is complete most of the major decision about the system has been made. However
many of the decision about coding the design, which often depends on the programming language
chosen is not specified during design. The goal of coding phase is to transmit the design of the
system into code in a given programming language. For a given design, the aim in this phase is to
implement the design in the best possible manner.

The coding phase effects both testing and maintenance profoundly. Well-written code can reduce
the testing and maintenance effort. Because the testing and maintenance costs are much higher than
the testing cost, the goal of coding should be to reduce the testing and maintenance effort. Hence,
during coding the focus should be on developing program that are easy to read and understand, and
not simply on developing programs that are easy to read and understand, and not simply on
developing programs that are easy to write. Simplicity and clarity should be striving for during the
coding phase.

An important concept that helps the understandability of programs is structured programming. The
goal of structured programming is to linearize the control flow in the program. That is, the program
text should be organized as a sequence of statements and during execution the statements are
executed in the sequence given the program. For a structured programming a few single - entry –
single – exit construct should be used. These constructs include selection (if-then-else) and iteration
(while-do, repeat-until etc.). With these constructs it is possible to construct a program as a
sequence of single-entry-single-exit constructs.

Programming Styles:

Here we have listed some general guidelines that should be followed while coding: -

61
Names
Variable names should be closely related to the entity they represent and module names should
reflect their activities

Control Constructs

It is desirable that as much as possible single-entry-single-exit constructs to be used. It is also


desirable to use little standard control constructs rather then using a wide variety of constructs just
because they are available in the language.
Goto‘s

Goto should be used sparingly and in discipline manner. Only when the alternative of using goto is
more complex should the goto be used.

User defined types

Most programming language allows users to define types like the enumerated type. When such
facilities are available, they should be exploited where applicable. For example when working with
dates, a type can be defined for the day of the week in Pascal, this can be done as follows

Type days = (Mon, Tue, Wed, Thus, Fri, Sat, Sun).

Nesting

The different control constructs, particularly the If-Then-Else, can be nested. If the nesting becomes
too deep, the program becomes harder to understand. Where possible deep nesting should be
avoided, even if it means a little inefficiency

Robustness

A program is robust if it does something planed even for exceptional conditions. A program should
check for validity of inputs, where possible, and should check for possible overflow of the data

62
structures. If such situation do arise the program should not ―crash‖, it should produce meaningful
message and exit gracefully.

Internal Documentation

In the coding phase the output document is code itself. However, some amount of internal
documentation in the code can be extremely use full in enhancing the understandability of the
programs. Internal documentation of the program is done by the use of comments. The purpose of
comments is to explain what the code is doing, not how it is doing it.

CODING STANDARDS: -
We have used C++ to develop this program. C++ is object oriented language, so we are discussing
some of the concepts of object oriented design.

CODING OF THE PROJECT (AIRMODI.CPP)

//----------------------------------------------------------
// PROJECT AIR TICKET RESERVATION
//----------------------------------------------------------

//----------------------------------------------------------
// INCLUDED HEADER FILES
//----------------------------------------------------------

//#include <iostream.h>
#include <fstream.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <conio.h>

63
#include <dos.h>
#include<time.h>

//----------------------------------------------------------
// THIS CLASS DRAW LINES, BOXES, ETC.
//----------------------------------------------------------

class DRAW
{
public :
void LINE_HOR(int, int, int, char) ;
void LINE_VER(int, int, int, char) ;
void BOX(int,int,int,int,char) ;
void ENTER_PASSWORD();
void BOX_PASSWORD(void);
};

//----------------------------------------------------------
// THIS CLASS CONTROLS ALL THE FUNCTIONS RELATED TO TICKETS
//----------------------------------------------------------

class TICKET
{
public :
void ADDITION(void) ;
void ENQUIRY(void) ;
char *FLIGHTNO(int) ;
private :
void ADD_RECORD(char[10], char[15], char[15], char[15], int, int) ;

protected :
char fltno[10], s_time[15],from[15],to[15] ;
int ecofair, exefair ;
};

//----------------------------------------------------------
// THIS CLASS CONTROLS ALL THE FUNCTIONS RELATED TO PASSENGERS
//----------------------------------------------------------

class PASSANGER
{
public :
void ADD_RECORD(int, int, char[26], char[36], int, char, char,char,int) ;
void DELETE_TICKET(int) ;
int DELETE_FLIGHT(int) ;
void LIST(void) ;
void WLIST(void) ;
int LAST_TICKETNO(void) ;
int SEATS(int) ;
int FOUND(int) ;
char *NAME(int) ;
protected :
char Class, name[26], address[36], sex ,category;
int slno, age, ticketno, mseatno ;
};

64
//----------------------------------------------------------
// THIS IS DERIVED CLASS WHICH CONTROL ALL THE FUNCTIONS
// RELATED TO RESERVATION, CANCELLATION, ETC.
//----------------------------------------------------------

class RESERVE : public TICKET, public PASSANGER


{
public :
void RESERVATION(void) ;
void CANCELLATION(void) ;
void DISPLAY_TICKET(void) ;
void DELETE_ALL(void) ;
};

//----------------------------------------------------------
// FUNCTION TO DRAW HORIZONTAL LINE
//----------------------------------------------------------

void DRAW :: LINE_HOR(int column1, int column2, int row, char c)


{
for ( column1; column1<=column2; column1++ )
{
gotoxy(column1,row) ;
cout <<c ;
}
}

//----------------------------------------------------------
// FUNCTION TO DRAW VERTICAL LINE
//----------------------------------------------------------

void DRAW :: LINE_VER(int row1, int row2, int column, char c)


{
for ( row1; row1<=row2; row1++ )
{
gotoxy(column,row1) ;
cout <<c ;
}
}

//----------------------------------------------------------
// FUNCTION TO DRAW BOX
//----------------------------------------------------------

void DRAW :: BOX(int column1, int row1, int column2, int row2, char c)
{
char ch=218 ;
char c1, c2, c3, c4 ;
char l1=196, l2=179 ;
if (c == ch)
{
c1=218 ;
c2=191 ;
c3=192 ;
c4=217 ;

65
l1 = 196 ;
l2 = 179 ;
}
else
{
c1=c ;
c2=c ;
c3=c ;
c4=c ;
l1 = c ;
l2 = c ;
}
gotoxy(column1,row1) ;
cout <<c1 ;
gotoxy(column2,row1) ;
cout <<c2 ;
gotoxy(column1,row2) ;
cout <<c3 ;
gotoxy(column2,row2) ;
cout <<c4 ;
column1++ ;
column2-- ;
LINE_HOR(column1,column2,row1,l1) ;
LINE_HOR(column1,column2,row2,l1) ;
column1-- ;
column2++ ;
row1++ ;
row2-- ;
LINE_VER(row1,row2,column1,l2) ;
LINE_VER(row1,row2,column2,l2) ;
}
//**********************************************************
// CLASS NAME : DRAW
// FUNCTION NAME : BOX_PASSWORD
// DETAILS : IT DRAWS THE BOX FOR THE PASSWORD
//**********************************************************

void DRAW :: BOX_PASSWORD(void)


{
LINE_HOR(2,79,1,219) ;
LINE_HOR(2,79,24,219) ;
LINE_VER(1,24,2,219) ;
LINE_VER(1,24,79,219) ;
delay(50) ;
LINE_HOR(3,78,2,219) ;
LINE_HOR(3,78,23,219) ;
LINE_VER(2,23,3,219) ;
LINE_VER(2,23,78,219) ;
delay(50) ;
LINE_HOR(4,77,3,219) ;
LINE_HOR(4,77,22,219) ;
LINE_VER(3,22,4,219) ;
LINE_VER(3,22,77,219) ;
delay(50) ;
LINE_HOR(5,76,4,178) ;
LINE_HOR(5,76,21,178) ;
LINE_VER(4,21,5,178) ;
LINE_VER(4,21,76,178) ;
delay(50) ;

66
LINE_HOR(6,75,5,178) ;
LINE_HOR(6,75,20,178) ;
LINE_VER(5,20,6,178) ;
LINE_VER(5,20,75,178) ;
delay(50) ;
LINE_HOR(7,74,6,178) ;
LINE_HOR(7,74,19,178) ;
LINE_VER(6,19,7,178) ;
LINE_VER(6,19,74,178) ;
delay(50) ;
LINE_HOR(8,73,7,177) ;
LINE_HOR(8,73,18,177) ;
LINE_VER(7,18,8,177) ;
LINE_VER(7,18,73,177) ;
delay(50) ;
LINE_HOR(9,72,8,177) ;
LINE_HOR(9,72,17,177) ;
LINE_VER(8,17,9,177) ;
LINE_VER(8,17,72,177) ;
delay(50) ;
LINE_HOR(10,71,9,177) ;
LINE_HOR(10,71,16,177) ;
LINE_VER(9,16,10,177) ;
LINE_VER(9,16,71,177) ;
delay(50) ;
}

//**********************************************************
// CLASS NAME : DRAW
// FUNCTION NAME : ENTER_PASSWORD
// DETAILS : IT ACCEPTS THE PASSWORD AND TERMINATES
// THE PROGRAM IF WRONG ENTERED
//**********************************************************

void DRAW :: ENTER_PASSWORD()


{
clrscr() ;
char pass1, pass2, pass3 ;
BOX_PASSWORD() ;
gotoxy(30,12) ;
cout <<"Enter the password : " ;
pass1 = getch() ;
cout <<"*" ;
pass2 = getch() ;
cout <<"*" ;
pass3 = getch() ;
cout <<"*" ;
sound(500) ;
delay(100) ;
nosound() ;
if (pass1 == '1' && pass2 == '2' && pass3 == '3')
return ;
gotoxy(30,12) ;
cout <<" WRONG PASSWORD ";
gotoxy(2,1) ;
getch() ;

67
exit(0) ;
}

//----------------------------------------------------------
// FUNCTION TO ADD GIVEN DATA IN THE TICKET FILE(TIKET.DAT)
//----------------------------------------------------------

void TICKET :: ADD_RECORD(char t_fltno[10], char t_from[15], char t_to[15], char s_tm[15],int t_ecofair, int
t_exefair)
{
fstream file ;
file.open("TIKET.DAT",ios::app|ios::binary) ;
strcpy(fltno,t_fltno) ;
strcpy(from,t_from) ;
strcpy(to,t_to) ;
strcpy(to,t_to) ;
strcpy(s_time,s_tm) ;
ecofair = t_ecofair ;
exefair = t_exefair ;
file.write((char *) this, sizeof(TICKET));
file.close() ;
}

//----------------------------------------------------------
// FUNCTION TO RETURN FLIGHT NO. FOR THE GIVEN S.NO
//----------------------------------------------------------

char *TICKET :: FLIGHTNO(int sno)


{
fstream file ;
file.open("TIKET.DAT", ios::in|ios::binary) ;
int count=1 ;
while (file.read((char *) this, sizeof(TICKET)))
{
if (sno == count)
break ;
count++ ;
}
file.close() ;
return fltno ;
}

//----------------------------------------------------------
// FUNCTION TO GIVE DATA TO ADD RECORDS IN TICKET FILE
//----------------------------------------------------------

void TICKET :: ADDITION(void)


{
fstream file ;
file.open("tiket.DAT", ios::out|ios::binary) ;
file.close() ;
ADD_RECORD("KL146","DELHI","MUMBAI","12:35",1500,1700) ;
ADD_RECORD("KL146","MUMBAI","DELHI","23:40",1500,1700) ;

68
ADD_RECORD("KL156","DELHI","BANGALORE","19.20",1700,1900) ;
ADD_RECORD("KL156","BANGALORE","DELHI","13:02",1700,1900) ;
ADD_RECORD("KL166","DELHI","CHENNAI","10:30",2100,2300) ;
ADD_RECORD("KL166","CHENNAI","DELHI","06:30",2100,2300) ;
ADD_RECORD("KL176","MUMBAI","BANGALORE","08:20",1900,2100) ;
ADD_RECORD("KL176","BANGALORE","MUMBAI","11:35",1900,2100) ;
ADD_RECORD("KL186","MUMBAI","CHENNAI","01:05",1800,2000) ;
ADD_RECORD("KL186","CHENNAI","MUMBAI","14:30",1800,2000) ;
ADD_RECORD("KL196","BANGALORE","CHENNAI","00:40",1600,1800) ;
ADD_RECORD("KL196","CHENNAI","BANGALORE","14:45",1600,1800) ;
}

//----------------------------------------------------------
// FUNCTION TO DISPLAY LIST OF FLIGHTS
//----------------------------------------------------------

void TICKET :: ENQUIRY(void)


{
clrscr() ;
fstream file ;
file.open("TIKET.DAT", ios::in|ios::binary) ;
DRAW d ;
d.BOX(1,2,80,24,218) ;
d.LINE_HOR(2,79,4,196) ;
d.LINE_HOR(2,79,6,196) ;
d.LINE_HOR(2,79,22,196) ;
textcolor(LIGHTGRAY+BLINK) ;
gotoxy(30,3) ;
cprintf("LIST OF THE FLIGHTS") ;
textcolor(LIGHTGRAY) ;
textcolor(BLACK) ; textbackground(WHITE) ;
for (int i=2; i<=79; i++)
{
gotoxy(i,5) ;
cprintf(" ") ;
}
gotoxy(2,5) ;
cprintf("Sno. FLIGHT NO. FROM TO TIME ECO. FARE EXE. FARE") ;
textcolor(11) ; textbackground(20) ;
int row=7, sno=1 ;
while (file.read((char *) this, sizeof(TICKET)))
{
gotoxy(4,row) ;
cout <<sno ;
gotoxy(9,row) ;
cout <<fltno ;
gotoxy(21,row) ;
cout <<from ;
gotoxy(34,row) ;
cout <<to ;
gotoxy(46,row) ;
cout <<s_time ;
gotoxy(54,row) ;
cout <<ecofair ;
gotoxy(67,row) ;
cout <<exefair ;
row++ ;
sno++ ;

69
}
file.close() ;
}

//----------------------------------------------------------
// FUNCTION TO RESERVE TICKET FOR THE PASSENGER
//----------------------------------------------------------

void RESERVE :: RESERVATION(void)


{
clrscr() ;
ENQUIRY() ;
char t1[5], pclass, pname[26], paddress[36], psex, pfltno[10],pcat ;
int t2, valid, page, tno, sno ;
char wname[26], wsex ;
int wage, wtno ;
PASSANGER p ;
tno = p.LAST_TICKETNO() + 1 ;

int d1,m1,y1, d2,m2,y2, d3,m3,y3, d4,m4,y4 ;

do
{
valid = 1 ;
gotoxy(3,23) ;
cout <<" ";
gotoxy(3,23) ;
cout <<"PRESS <ENTER> TO EXIT" ;
gotoxy(3,20) ;
cout <<" ";
gotoxy(3,20) ;
cout <<"Enter Sno. of the FLIGHT : " ;
gets(t1) ;
t2 = atoi(t1) ;
sno = t2 ;
if (strlen(t1) == 0)
return ;
if (sno < 1 || sno > 12)
{
valid = 0 ;
gotoxy(3,23) ;
cout <<" ";
gotoxy(3,23) ;
cout <<"\7ENTER CORRECTLY" ;
getch() ;
}
} while (!valid) ;
int i=1 ;
fstream file ;
file.open("tiket.DAT", ios::in|ios::binary) ;
while (file.read((char *) this, sizeof(TICKET)))
{
if (sno == i)
break ;
i++ ;
}
file.close() ;
strcpy(pfltno,fltno) ;

70
if (p.SEATS(sno) >= 250)
{
gotoxy(5,21) ;
cout <<"\7Sorry! Seats are not available." ;
getch() ;
return ;
}
gotoxy(3,23) ;
cout <<" ";
gotoxy(3,23) ;
cout <<"E=ECONOMIC, X=EXECUTIVE or PRESS <ENTER> TO EXIT" ;
do
{
gotoxy(3,21) ;
cout <<" ";
gotoxy(3,21) ;
cout <<"By which Class you want to travel : " ;
pclass = getche() ;
pclass = toupper(pclass) ;
if (pclass == 13)
return ;
} while (pclass != 'E' && pclass != 'X') ;
clrscr() ;
gotoxy(72,3) ;
cout <<"<0>=EXIT" ;
gotoxy(34,2) ;
cout <<"RESERVATION" ;
gotoxy(5,5) ;
cout <<"NAME : " ;
gotoxy(5,6) ;
cout <<"ADDRESS : " ;
gotoxy(5,7) ;
cout <<"SEX M/F : " ;
gotoxy(5,8) ;
cout <<"AGE :";
gotoxy(5,9) ;
cout <<"CATEGORY : " ;
do
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout <<"ENTER NAME OF THE PASSENGER" ;
gotoxy(15,5) ; clreol() ;
gets(pname) ;
if (pname[0] == '0')
return ;
if (strlen(pname) < 1 || strlen(pname) > 25)
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<"\7Enter Correctly (Range: 1..25)" ;
getch() ;
}
} while (!valid) ;
do
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout <<"ENTER ADDRESS OF THE PASSENGER" ;

71
gotoxy(15,6) ; clreol() ;
gets(paddress) ;
if (paddress[0] == '0')
return ;
if (strlen(paddress) < 1 || strlen(paddress) > 35)
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<"\7Enter Correctly (Range: 1..35)" ;
getch() ;
}
} while (!valid) ;
do
{
gotoxy(5,25) ; clreol() ;
cout <<"ENTER SEX OF THE PASSENGER" ;
gotoxy(15,7) ; clreol() ;
psex = getche() ;
psex = toupper(psex) ;
if (psex == '0')
return ;
} while (psex != 'M' && psex != 'F') ;
do
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout <<"ENTER AGE OF THE PASSENGER" ;
gotoxy(15,8) ; clreol() ;
gets(t1) ;
t2 = atoi(t1) ;
page = t2 ;
if (t1[0] == '0')
return ;
if (page < 1 || page > 100)
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<"\7ENTER CORRECTLY" ;
getch() ;
}
} while (!valid) ;
gotoxy(3,23) ;
cout <<" ";
gotoxy(3,23) ;
cout <<"G=GENERAL, H=HANDICAPT, F=FREQUENT TRAVELLER or PRESS <ENTER> TO EXIT" ;
do
{
gotoxy(3,21) ;
cout <<" ";
gotoxy(3,21) ;
cout <<"ENTER CATEGORY OF PASSENGER : " ;
gotoxy(17,9);
pcat = getche() ;
pcat = toupper(pcat) ;
if (pcat == 13)
return ;
} while (pcat != 'G' && pcat != 'H'&& pcat != 'F') ;

mseatno++;

72
char ch1,ch;
if(mseatno>2)
{
cout<<"\n\nNo more seats available!!!";
cout<<"\n We can reserve tickets on basis of waiting list";
cout<<"\n Do you still want to reserve (y/n): ";
cin>>ch1;
if(ch1=='y')
{
// w.ADD_RECORD(wtno,wname,wage,wsex,wseatno);
cout<<ch1;
}
}
clrscr() ;
DRAW d ;
d.BOX(15,5,66,21,'*') ;
d.LINE_HOR(16,65,7,'*') ;
gotoxy(33,6) ;
cout <<"Ticket no. " <<tno ;

gotoxy(17,9) ;
cout <<from <<" to " <<to ;
gotoxy(48,9) ;
cout <<"Flight no. " <<pfltno ;

gotoxy(48,11) ;
cout <<"Seat no. " <<mseatno ;
gotoxy(17,11) ;
cout <<"Passenger Name : " <<pname ;
gotoxy(17,13) ;
cout <<"Address : " <<paddress ;
gotoxy(17,15) ;
cout <<"Sex : " <<psex ;
gotoxy(17,17) ;
cout <<"Age : " <<page ;
gotoxy(17,19) ;
if(pcat=='G')
cout <<"Category : General";
else if(pcat=='H')
cout <<"Category : Handicap";
else if(pcat=='F')
cout <<"Category : Frequent Traveller";

gotoxy(48,19) ;
if(page<=3)
cout <<"Total Fare: 0";
else
{
if (pclass == 'E')
{
if(pcat=='H')
cout <<"Total Fare: " <<(ecofair-ecofair*0.25) ;
else if(pcat=='F')
cout <<"Total Fare: " <<(ecofair-ecofair*0.10) ;
else
cout <<"Total Fare: " <<ecofair ;
}
else

73
{
if(pcat=='H')
cout <<"Total Fare: " <<(exefair-exefair*0.25) ;
else if(pcat=='F')
cout <<"Total Fare: " <<(exefair-exefair*0.10) ;
else
cout <<"Total Fare: " <<exefair ;
}
}
p.ADD_RECORD(tno,sno,pname,paddress,page,psex,pclass,pcat,mseatno) ;
getch() ;
}

//----------------------------------------------------------
// FUNCTION TO ADD THE GIVEN DATA IN THE PASSENGER'S FILE
//----------------------------------------------------------

void PASSANGER :: ADD_RECORD(int tno, int sno, char pname[26], char paddress[36], int page, char psex, char
pclass,char pcat,int mseatno)

{
fstream file ;
file.open("WLIST.DAT", ios::app|ios::binary) ;
ticketno = tno ;
slno = sno ;
strcpy(name,pname) ;
strcpy(address,paddress) ;
age = page ;
sex = psex ;
Class = pclass ;
category=pcat ;
mseatno=mseatno;
file.write((char *) this, sizeof(PASSANGER)) ;
file.close() ;
}

//----------------------------------------------------------
// THIS FUNCTION RETURNS THE LAST TICKET NO. IN THE PASSENGER
// FILE
//----------------------------------------------------------

int PASSANGER :: LAST_TICKETNO(void)


{
fstream file ;
file.open("PAS.DAT", ios::in|ios::binary) ;
int count=0 ;
while (file.read((char *) this, sizeof(PASSANGER)))
count = ticketno ;
file.close() ;
return count ;
}

//----------------------------------------------------------
// THIS FUNCTION RETURN TOTAL NO. OF SEATS IN THE PASSENGER
// FILE
//----------------------------------------------------------

74
int PASSANGER :: SEATS(int sno)
{
fstream file ;
file.open("PAS.DAT", ios::in|ios::binary) ;
int count=0 ;
while (file.read((char *) this, sizeof(PASSANGER)))
{
if (sno == slno)
count++ ;
}
file.close() ;
return count ;
}

//----------------------------------------------------------
// THIS FUNCTION RETURNS 0 IF THE TICKET NO. NOT FOUND IN
// PASSENGER'S FILE
//----------------------------------------------------------

int PASSANGER :: FOUND(int tno)


{
fstream file ;
file.open("PAS.DAT", ios::in|ios::binary) ;
int found=0 ;
while (file.read((char *) this, sizeof(PASSANGER)))
{
if (tno == ticketno)
{
found = 1 ;
break ;
}
}
file.close() ;
return found ;
}

//----------------------------------------------------------
// THIS FUNCTION RETURNS PASSENGER'S NAME FOR THE GIVEN
// TICKET NO.
//----------------------------------------------------------

char *PASSANGER :: NAME(int tno)


{
fstream file ;
file.open("PAS.DAT", ios::in|ios::binary) ;
while (file.read((char *) this, sizeof(PASSANGER)))
{
if (tno == ticketno)
break ;
}
file.close() ;
return name ;
}

//----------------------------------------------------------

75
// THIS FUNCTION DISPLAYS THE LIST OF THE PASSENGERS
//----------------------------------------------------------

void PASSANGER :: LIST(void)


{
clrscr() ;
char t1[10] ;
int t2, sno, valid ;
TICKET ticket ;
ticket.ENQUIRY() ;
do
{
valid = 1 ;
gotoxy(3,23) ;
cout <<" ";
gotoxy(3,23) ;
cout <<"PRESS <ENTER> TO EXIT" ;
gotoxy(3,20) ;
cout <<" ";
gotoxy(3,20) ;
cout <<"Enter Sno. of the FLIGHT for which you want to see list of passanger " ;
gets(t1) ;
t2 = atoi(t1) ;
sno = t2 ;
if (strlen(t1) == 0)
return ;
if (sno < 1 || sno > 12)
{
valid = 0 ;
gotoxy(3,23) ;
cout <<" ";
gotoxy(3,23) ;
cout <<"\7ENTER CORRECTLY" ;
getch() ;
}
} while (!valid) ;
clrscr() ;
int row=7, found=0, flag=0 ;
char ch ;
DRAW d ;
d.BOX(1,2,80,24,218) ;
d.LINE_HOR(2,79,4,196) ;
d.LINE_HOR(2,79,6,196) ;
d.LINE_HOR(2,79,22,196) ;
gotoxy(3,3) ;
cout <<"Flight no. " <<ticket.FLIGHTNO(sno) ;
gotoxy(32,3) ;
cout <<"LIST OF PASSNGER" ;
textcolor(BLACK) ; textbackground(WHITE) ;
gotoxy(2,5) ;
cprintf(" TICKET NO. NAME CLASS ") ;
textcolor(LIGHTGRAY) ; textbackground(BLACK) ;
fstream file ;
file.open("PAS.DAT", ios::in|ios::binary) ;
file.seekg(0,ios::beg) ;
while (file.read((char *) this, sizeof(PASSANGER)))
{
if (sno == slno)
{

76
flag = 0 ;
delay(20) ;
found = 1 ;
gotoxy(5,row) ;
cout <<ticketno ;
gotoxy(17,row) ;
cout <<name ;
gotoxy(49,row) ;
if (Class == 'X')
cout <<"Executive" ;
else
cout <<"Economic" ;
if ( row == 21 )
{
flag = 1 ;
row = 7 ;
gotoxy(5,23) ;
cout <<"Press any key to continue or Press <ESC> to exit" ;
ch = getch() ;
if (ch == 27)
break ;
clrscr() ;
d.BOX(1,2,80,24,218) ;
d.LINE_HOR(2,79,4,196) ;
d.LINE_HOR(2,79,6,196) ;
d.LINE_HOR(2,79,22,196) ;
gotoxy(32,3) ;
cout <<"LIST OF PASSENGER" ;
textcolor(BLACK) ; textbackground(WHITE) ;
gotoxy(2,5) ;
cprintf(" TICKET NO. NAME FLIGHT NO. CLASS ")
;
textcolor(LIGHTGRAY) ; textbackground(BLACK) ;
}
else
row++ ;
}
}
if (!found)
{
gotoxy(5,10) ;
cout <<"\7Records not found" ;
}
if (!flag)
{
gotoxy(5,23) ;
cout <<"Press any key to continue..." ;
getch() ;
}
file.close() ;
}

void PASSANGER :: WLIST(void)


{
clrscr() ;
char t1[10] ;
int t2, sno, valid ;
TICKET ticket ;

77
ticket.ENQUIRY() ;
do
{
valid = 1 ;
gotoxy(3,23) ;
cout <<" ";
gotoxy(3,23) ;
cout <<"PRESS <ENTER> TO EXIT" ;
gotoxy(3,20) ;
cout <<" ";
gotoxy(3,20) ;
cout <<"Enter Sno. of the FLIGHT for which you want to see list of passanger " ;
gets(t1) ;
t2 = atoi(t1) ;
sno = t2 ;
if (strlen(t1) == 0)
return ;
if (sno < 1 || sno > 12)
{
valid = 0 ;
gotoxy(3,23) ;
cout <<" ";
gotoxy(3,23) ;
cout <<"\7ENTER CORRECTLY" ;
getch() ;
}
} while (!valid) ;
clrscr() ;
int row=7, found=0, flag=0 ;
char ch ;
DRAW d ;
d.BOX(1,2,80,24,218) ;
d.LINE_HOR(2,79,4,196) ;
d.LINE_HOR(2,79,6,196) ;
d.LINE_HOR(2,79,22,196) ;
gotoxy(3,3) ;
cout <<"Flight no. " <<ticket.FLIGHTNO(sno) ;
gotoxy(32,3) ;
cout <<"LIST OF PASSNGER" ;
textcolor(BLACK) ; textbackground(WHITE) ;
gotoxy(2,5) ;
cprintf(" TICKET NO. NAME CLASS ") ;
textcolor(LIGHTGRAY) ; textbackground(BLACK) ;
fstream file ;
file.open("PAS.DAT", ios::in|ios::binary) ;
file.seekg(0,ios::beg) ;
while (file.read((char *) this, sizeof(PASSANGER)))
{
if (sno == slno)
{
if (mseatno > 2)
{
flag = 0 ;
delay(20) ;
found = 1 ;
gotoxy(5,row) ;
cout <<ticketno ;
gotoxy(17,row) ;
cout <<name ;

78
gotoxy(49,row) ;
if (Class == 'X')
cout <<"Executive" ;
else
cout <<"Economic" ;
if ( row == 21 )
{
flag = 1 ;
row = 7 ;
gotoxy(5,23) ;
cout <<"Press any key to continue or Press <ESC> to exit" ;
ch = getch() ;
if (ch == 27)
break ;
clrscr() ;
d.BOX(1,2,80,24,218) ;
d.LINE_HOR(2,79,4,196) ;
d.LINE_HOR(2,79,6,196) ;
d.LINE_HOR(2,79,22,196) ;
gotoxy(32,3) ;
cout <<"LIST OF PASSENGER" ;
textcolor(BLACK) ; textbackground(WHITE) ;
gotoxy(2,5) ;
cprintf(" TICKET NO. NAME FLIGHT NO. CLASS ")
;
textcolor(LIGHTGRAY) ; textbackground(BLACK) ;
}
else
row++ ;
}}
}
if (!found)
{
gotoxy(5,10) ;
cout <<"\7Records not found" ;
}
if (!flag)
{
gotoxy(5,23) ;
cout <<"Press any key to continue..." ;
getch() ;
}
file.close() ;
}

//----------------------------------------------------------
// THIS FUNCTION DELETES PASSENGER RECORDS FOR THE GIVEN
// TICKET NO.
//----------------------------------------------------------

void PASSANGER :: DELETE_TICKET(int tno)


{
fstream file ;
file.open("PAS.DAT", ios::in|ios::binary) ;
fstream temp ;
temp.open("temp.dat", ios::out|ios::binary) ;
file.seekg(0,ios::beg) ;
while (!file.eof())

79
{
file.read((char *) this, sizeof(PASSANGER)) ;
if (file.eof())
break ;
if (tno != ticketno)
temp.write((char *) this, sizeof(PASSANGER)) ;
}
file.close() ;
temp.close() ;
file.open("PAS.DAT", ios::out|ios::binary) ;
temp.open("temp.dat", ios::in|ios::binary) ;
temp.seekg(0,ios::beg) ;
while ( !temp.eof() )
{
temp.read((char *) this, sizeof(PASSANGER)) ;
if ( temp.eof() )
break ;
file.write((char *) this, sizeof(PASSANGER)) ;
}
file.close() ;
temp.close() ;
}

//----------------------------------------------------------
// THIS FUNCTION DELETES ALL PASSENGER RECORDS FOR THE GIVEN
// FLIGHT NO.
//----------------------------------------------------------

int PASSANGER :: DELETE_FLIGHT(int sno)


{
fstream file ;
file.open("PAS.DAT", ios::in|ios::binary) ;
fstream temp ;
temp.open("temp.dat", ios::out|ios::binary) ;
file.seekg(0,ios::beg) ;
int found = 0 ;
while (!file.eof())
{
file.read((char *) this, sizeof(PASSANGER)) ;
if (file.eof())
break ;
if (sno != slno)
temp.write((char *) this, sizeof(PASSANGER)) ;
else
found = 1 ;
}
file.close() ;
temp.close() ;
file.open("PAS.DAT", ios::out|ios::binary) ;
temp.open("temp.dat", ios::in|ios::binary) ;
temp.seekg(0,ios::beg) ;
while ( !temp.eof() )
{
temp.read((char *) this, sizeof(PASSANGER)) ;
if ( temp.eof() )
break ;
file.write((char *) this, sizeof(PASSANGER)) ;
}

80
file.close() ;
temp.close() ;
return found ;
}

//----------------------------------------------------------
// THIS FUNCTION CANCELS PASSENGER'S TICKET
//----------------------------------------------------------

void RESERVE :: CANCELLATION(void)


{

clrscr() ;
char t1[10], ch ;
int t2, tno, valid ;
do
{
valid = 1 ;
gotoxy(3,23) ; clreol() ;
cout <<"PRESS <ENTER> TO SEE LIST or 0 TO EXIT" ;
gotoxy(3,20) ; clreol() ;
cout <<"Enter Ticket no. of the Passenger " ;
gets(t1) ;
t2 = atoi(t1) ;
tno = t2 ;
if (t1[0] == '0')
return ;
if (strlen(t1) == 0)
{
valid = 0 ;
LIST() ;
clrscr() ;
}
if (!FOUND(tno) && valid)
{
valid = 0 ;
gotoxy(3,23) ; clreol() ;
cout <<"\7Record not found" ;
getch() ;
}
} while (!valid) ;
clrscr() ;
fstream file ;
file.open("PAS.DAT", ios::in|ios::binary) ;
while (file.read((char *) this, sizeof(PASSANGER)))
if (ticketno == tno)
break ;
file.close() ;
int i=1 ;
file.open("TIKET.DAT", ios::in|ios::binary) ;
while (file.read((char *) this, sizeof(TICKET)))
{
if (slno == i)
break ;
i++ ;
}
file.close() ;

81
PASSANGER p ;
DRAW d ;
d.BOX(15,5,66,21,'*') ;
d.LINE_HOR(16,65,7,'*') ;
gotoxy(33,6) ;
cout <<"Ticket no. " <<tno ;
gotoxy(17,9) ;
cout <<from <<" to " <<to ;
gotoxy(48,9) ;
cout <<"Flight no. " <<fltno ;
gotoxy(48,11) ;
cout <<"Seat no. " <<mseatno ;
gotoxy(17,11) ;
cout <<"Passenger Name : " <<p.NAME(tno);
gotoxy(17,13) ;
cout <<"Address : " <<address ;
gotoxy(17,15) ;
cout <<"Sex : " <<sex ;
gotoxy(17,17) ;
cout <<"Age : " <<age ;
gotoxy(17,19) ;
if(category=='G')
cout <<"Category : General";
else if(category=='H')
cout <<"Category : Handicap";
else if(category=='F')
cout <<"Category : Frequent Traveller";

gotoxy(48,19) ;

if(age<=3)
cout <<"Total Fare: 0";
else
{
if (Class == 'E')
{
if(category=='H')
cout <<"Total Fare: " <<(ecofair-ecofair*0.25) ;
else if(category=='F')
cout <<"Total Fare: " <<(ecofair-ecofair*0.10) ;
else
cout <<"Total Fare: " <<ecofair ;
}
else
{
if(category=='H')
cout <<"Total Fare: " <<(exefair-exefair*0.25) ;
else if(category=='F')
cout <<"Total Fare: " <<(exefair-exefair*0.10) ;
else
cout <<"Total Fare: " <<exefair ;
}
}

gotoxy(10,25) ;
cout <<"Press any key to continue..." ;

82
do
{
gotoxy(10,23) ; clreol() ;
cout <<"Cancel this ticket (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
} while (ch != 'Y' && ch != 'N') ;
if (ch == 'N')
return ;
DELETE_TICKET(tno) ;
gotoxy(10,25) ;
cout <<"\7Ticket Cancelled.Pressed Any Key To Continue...." ;
getch() ;

//----------------------------------------------------------
// THIS FUNCTION DISPLAYS THE PASSENGER'S INFORMATION
//----------------------------------------------------------

void RESERVE :: DISPLAY_TICKET(void)


{
clrscr() ;
char t1[10], ch ;
int t2, tno, valid ;
do
{
valid = 1 ;
gotoxy(3,23) ; clreol() ;
cout <<"PRESS <ENTER> TO SEE LIST or 0 TO EXIT" ;
gotoxy(3,20) ; clreol() ;
cout <<"Enter Ticket no. of the Passenger " ;
gets(t1) ;
t2 = atoi(t1) ;
tno = t2 ;
if (t1[0] == '0')
return ;
if (strlen(t1) == 0)
{
valid = 0 ;
LIST() ;
clrscr() ;
}
if (!FOUND(tno) && valid)
{
valid = 0 ;
gotoxy(3,23) ; clreol() ;
cout <<"\7Record not found" ;
getch() ;
}
} while (!valid) ;
clrscr() ;
fstream file ;
file.open("PAS.DAT", ios::in|ios::binary) ;
while (file.read((char *) this, sizeof(PASSANGER)))
if (ticketno == tno)
break ;
file.close() ;

83
int i=1 ;
file.open("TIKET.DAT", ios::in|ios::binary) ;
while (file.read((char *) this, sizeof(TICKET)))
{
if (slno == i)
break ;
i++ ;
}
file.close() ;
PASSANGER p ;
DRAW d ;
d.BOX(15,5,66,21,'*') ;
d.LINE_HOR(16,65,7,'*') ;
gotoxy(33,6) ;
cout <<"Ticket no. " <<tno ;
gotoxy(17,9) ;
cout <<from <<" to " <<to ;
gotoxy(48,9) ;
cout <<"Flight no. " <<fltno ;
gotoxy(48,11) ;
cout <<"Seat no. " <<mseatno ;
gotoxy(17,11) ;
cout <<"Passenger Name : " <<p.NAME(tno);
gotoxy(17,13) ;
cout <<"Address : " <<address ;
gotoxy(17,15) ;
cout <<"Sex : " <<sex ;
gotoxy(17,17) ;
cout <<"Age : " <<age ;
gotoxy(17,19) ;
if(category=='G')
cout <<"Category : General";
else if(category=='H')
cout <<"Category : Handicap";
else if(category=='F')
cout <<"Category : Frequent Traveller";

gotoxy(48,19) ;

if(age<=3)
cout <<"Total Fare: 0";
else
{
if (Class == 'E')
{
if(category=='H')
cout <<"Total Fare: " <<(ecofair-ecofair*0.25) ;
else if(category=='F')
cout <<"Total Fare: " <<(ecofair-ecofair*0.10) ;
else
cout <<"Total Fare: " <<ecofair ;
}
else
{
if(category=='H')
cout <<"Total Fare: " <<(exefair-exefair*0.25) ;
else if(category=='F')
cout <<"Total Fare: " <<(exefair-exefair*0.10) ;

84
else
cout <<"Total Fare: " <<exefair ;
}
}

gotoxy(10,25) ;
cout <<"Press any key to continue..." ;
getch() ;
}

//----------------------------------------------------------
// THIS FUNCTION GIVES FLIGHT NO. TO DELETE ALL PASSANGER
// RECORDS
//----------------------------------------------------------

void RESERVE :: DELETE_ALL(void)


{
clrscr() ;
ENQUIRY() ;
char t1[5] ;
int t2, valid, sno ;
do
{
valid = 1 ;
gotoxy(3,23) ;
cout <<" ";
gotoxy(3,23) ;
cout <<"PRESS <ENTER> TO EXIT" ;
gotoxy(3,20) ;
cout <<" ";
gotoxy(3,20) ;
cout <<"Enter Sno. of the FLIGHT for which all passenger records to be deleted : " ;
gets(t1) ;
t2 = atoi(t1) ;
sno = t2 ;
if (strlen(t1) == 0)
return ;
if (sno < 1 || sno > 12)
{
valid = 0 ;
gotoxy(3,23) ;
cout <<" ";
gotoxy(3,23) ;
cout <<"\7ENTER CORRECTLY" ;
getch() ;
}
} while (!valid) ;
gotoxy(3,23) ;
if (!DELETE_FLIGHT(sno))
cout <<"\7Records not found. Press any key to continue..." ;
else
cout <<"\7Records deleted. Press any key to continue..." ;
getch() ;
}

void start()
{
textmode(1);

85
for(int ai=0,aj=0,ak=34,al=33;ai<10,aj<17,ak>10,al>17;ai++,aj++,ak--,al--)
{
clrscr(); //

gotoxy(ai-1,8);
textbackground(4);
textcolor(2);
cout<<"\tSOFTWARE";
gotoxy(aj,25);
cout<<" ";
gotoxy(ak-2,12);
cout<<"DESIGNED";
gotoxy(ak-2,15);
cout<<" BY ";
gotoxy(al-6,20);
cout<<"SARBJYOT SINGH OBEROI";
delay(50);
}
gotoxy(9,9);
cout<<"*************************";
gotoxy(9,13);
cout<<"*************************";
gotoxy(9,17);
cout<<"*************************";
gotoxy(9,21);
cout<<"*************************";
getch();
delay(100);
textmode(2);
textbackground(0);
textcolor(5);
}

//----------------------------------------------------------
// THIS IS MAIN FUNCTION WHICH DISPLAYS MENU AND CALLS ALL
// THE MAIN FUNCTIONS
//----------------------------------------------------------
void main(void)
{
DRAW d ;
d.ENTER_PASSWORD();
PASSANGER p ;

clrscr();
gotoxy(9,10);
cout<<"\n\n\n\t\t\tWELCOME TO INTERNATIONAL AIRLINES \n\t\t\t************************";
delay(1000);
cout<<"\n\t\t\t HAVE A NICE TIME \n\t\t\t************************";
delay(2000);
int an;
start();

TICKET ticket ;
RESERVE r ;
ticket.ADDITION() ;
char ch ;
while (1)
{
clrscr() ;

86
sound(100);
delay(100);
nosound();
sound(700);
delay(500);
nosound();
sound(200);
delay(50);
nosound();
sound(300);
delay(50);
nosound();
sound(400);
delay(50);
nosound();

time_t t;
time(&t);
gotoxy(27,3);
textcolor(128);
printf(" %s\n", ctime(&t));
gotoxy(27,4);
cout<<" Y2K free !!! ";

d.BOX(19,6,62,25,220) ;
textcolor(1) ;
textbackground(2) ;
for (int i=9; i<=25; i++)
for (int j=20; j<=61; j++)
{
gotoxy(j,i) ;
cprintf("°" ) ;
}

gotoxy(23,8);
cprintf(" ³³ VIRGIN ATLANTIC AIRWAYS ³³ ") ;
textcolor(1);
gotoxy(24,9) ;
cprintf("ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß") ;
gotoxy(30,10) ;
cprintf("Ý1Þ ENQUIRY") ;
gotoxy(30,12) ;
cprintf("Ý2Þ RESERVATION") ;
gotoxy(30,14) ;
cprintf("Ý3Þ CANCELLATION") ;
gotoxy(30,16) ;
cprintf("Ý4Þ PASSENGER RECORDS ->") ;
gotoxy(30,18) ;
cprintf("Ý5Þ LIST OF PASSENGERS") ;
gotoxy(30,20) ;
cprintf("Ý6Þ WAITING LIST") ;
gotoxy(30,22) ;
cprintf("Ý0Þ QUIT") ;
gotoxy(30,24) ;
cprintf("ÞÞÞÞ ENTER YOUR CHOICE : ") ;
ch = getche() ;
textcolor(9) ;
textbackground(BLACK) ;

87
clrscr() ;
if (ch == 27 || ch == '0')
break ;
else
if (ch == '2')
r.RESERVATION() ;

if (ch == '3')
r.CANCELLATION() ;
if (ch == '1')
{
ticket.ENQUIRY() ;
gotoxy(2,23) ;
cout <<"Press any key to continue..." ;
getch() ;
}
else
if (ch == '5')
p.LIST() ;
else
if (ch == '6')
p.WLIST() ;
else
if (ch == '4')
{
while (1)
{
clrscr() ;
d.BOX(19,6,62,20,218) ;
textcolor(BLACK) ;
textbackground(WHITE) ;
for (int i=7; i<=19; i++)
for (int j=20; j<=61; j++)
{
gotoxy(j,i) ;
cprintf(" ") ;
}
gotoxy(29,10) ;
cprintf("EDIT PASSENGER RECORDS") ;
gotoxy(29,11) ;
cprintf("~~~~~~~~~~~~~~~~~~~~~~") ;
gotoxy(33,12) ;
cprintf("1: PASSENGER INFORMATION") ;
gotoxy(33,13) ;
cprintf("2: DELETE") ;
gotoxy(33,14) ;
cprintf("0: EXIT") ;
gotoxy(31,16) ;
cprintf("ENTER YOUR CHOICE ") ;
ch = getche() ;
textcolor(LIGHTGRAY) ;
textbackground(BLACK) ;
clrscr() ;
if (ch == 27 || ch == '0')
break ;
else
if (ch == '1')
r.DISPLAY_TICKET() ;
else

88
if (ch == '2')
r.DELETE_ALL() ;
}
}
}

clrscr();
gotoxy(21,10);
cout<<"THANK YOU FOR USING THIS SOFTWARE";
cout<<"\n\t\t CREATED BY";
cout<<"\n\t\t SARBJYOT SINGH OBEROI";
cout<<"\n\t\t\t\b\b\b\b***************************";
delay(4000);
clrscr();
}

89
OUTPUTS OF THE PROJECT

PASSWORD ENTRY FORM

90
MAIN WELCOME WINDOW

91
MENU WINDOW

92
ENQUIRY WINDOW

RESERVATION WINDOW

93
TICKET SAMPLE WINDOW

CANCELLATION OUTPUT

94
PASSENGER RECORDS WINDOW

RECORDS DELETE WINDOW

95
EDIT PASSANGER RECORDS WINDOW

LIST OF PASSANGERS WINDOW

96
WAITING LIST WINDOW

13 CONCLUSION

This project is designed to meet the requirements of a AIRWAYS TICKETING Management


System. It has been developed in C++ and the database has been built in C++ binary file only,
keeping in mind the specifications of the system.
For designing the system we have used simple data flow diagrams.

Overall the project teaches us the essential skills like:


1. Using system analysis and design techniques like data flow diagram in designing the system.
2. Understanding programming logic and language in C++.

97
14 SCOPE

At the end of the project we want to put our attention on the future perspective of the project. As we
know software development process begin with the interaction with the client. Clients mayn‘t have
clear understanding of his need.

The improvement of software is not a rare scene for software industry. Such are of improvement in
software is called the adaptive maintenance. In this type of maintenance we enhance our software.

In our project we have used C++ language and its file handling feature of C. Our project doesn‘t
also supports multiple clients. But the scope of the project can be dramatically enhanced when we
make this project on line.

Making this project on line allow users to access accounts from a remote area .to make this project
on line we can use ASP technology which is very compatible with the SQL Server.

98
15 REFERENCE

E. Balagrursamy, Programming in ANSI C, Tata McGraw-Hill, 1992.

E. Balagrursamy, Object-Oriented Programming with C++.

Bjarne Stroustrup, The C++ Programming Language, 3rd edition, Addison-Wesley, 1997.

C++, by Yashwant Kanetkar

Software engineering by K. K. Aggarwal & Yogesh Singh.

99
12. APPENDICES

Two files have been used in this project:

Article II. 1. AIRLINES.DAT: Keeps record of food items.

flightcode (Int) : This is7 unique field and generated automatically


by the program.
flightame (Character) : This is name of the flight.
ticketcost (Float) : This is cost of the flight.
ticketprice (Float) : This is price of the flight.

Article III.
Article IV. 2. BILL.DAT: Keeps record of bills.

code (Int) : Code no. of the item.


Ticketno (Int) : ticket no. of the flight, automatically generated
by the program.
ldistance (Int) : No. of items purchased by the customers.
dd,mm,yy (Int) : Date of the flight.
cost (Float) : Cost of the distance.
prince (Float) : Price of the total flight.
quantity (Float) : Quantity purchased.
name (Character) : Name of the flight.

100
This program is having 3 classes:

 MENU
 AIRLINES
 BOOKING

Modules in class MENU:

main_menu() : Function to display main menu.


edit_menu() : Function to display edit menu.
box() : Function to display box.

Modules in class AIRLINES:

add_item() : Function to add new flight in file FLIGHT.DAT.


delete_item() : Function to delete any FLIGHT details.
modify_item() : Function to modify any flight details.
list_of_item() : Function to display list of flight details.
purchase() : Function to do the purchase reservation.
last_code() : Function to return last code in the flight timeing.
delete_record() : Function to delete the record for given flight.
modify_record() : Function to modify record for the given flight.
display_record() : Function to display the record for the given flight
record.
item_found() : Function to return whether the given flight code
found in flight or not.

101
recordno() : Function to return record no. of the given flight
code in the flight record.
sort() : Function to sort list of the flight details according
to item code.

Modules in class ACCOUNT:

bill_list() : Function to display the list of cost.


prepare_bill() : Function to calculate and print customer ticke.
last_billno() : Function to return flight no. from the file
airlines.DAT.
add_bill() : Function to add given data to file-BILL.DAT.

102