Академический Документы
Профессиональный Документы
Культура Документы
LIST OF TABLES
6
LIST OF ABBREVATIONS
7
TABLE OF CONTENTS
I List of figures
II List of tables
III List of abbreviations
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.
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.
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.
4 NEEDS
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
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
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.
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‖.
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.
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.
Requirements
Design
Implementation
Verification
Fig.5.1 Maintenance
1.
24
b) USE CASE
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.
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.
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?
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
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: -
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:-
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.
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.
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.
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.
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 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.
MODULE 1
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.
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.
a) Database Design: -
TICKET.DAT:
35
Detailed structure
Name Description
Fltno Flight No
S_time Flight Time
From From
To To
Ecofair Economic Fare
Exefair Executive Fare
Pas.DAT:
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:-
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)
37
Class PASSANGER:-
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.
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.
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.
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
Airlines
42
Add
DFD (IInd Level)
1 Air 2 Passenger
2 Passenger 2 Passenger
2 Passenger 1 Air
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.
A typical flowchart from older Computer Science textbooks may have the following kinds of
symbols:
(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.
(iv) Input/Output
Represented as a parallelogram. Examples: Get X from the user; display X.
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:
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
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.
(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
Return
48
B
Declare variables
Do
Yes
Return
49
C
Passenger 1) F
Information
2) G
Delete
Return
50
F
Declare variables
Do
Yes
Return
51
G
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.
Return
53
E
Enter S.No. of
the flight
If No
Enter correctly.
Found?
Yes
Declare variables
and open file.
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.
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:
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:
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.
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.
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, 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
Goto should be used sparingly and in discipline manner. Only when the alternative of using goto is
more complex should the goto be used.
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
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.
//----------------------------------------------------------
// 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.
//----------------------------------------------------------
//----------------------------------------------------------
// FUNCTION TO DRAW HORIZONTAL LINE
//----------------------------------------------------------
//----------------------------------------------------------
// FUNCTION TO DRAW VERTICAL LINE
//----------------------------------------------------------
//----------------------------------------------------------
// 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
//**********************************************************
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
//**********************************************************
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
//----------------------------------------------------------
//----------------------------------------------------------
// FUNCTION TO GIVE DATA TO ADD RECORDS IN TICKET FILE
//----------------------------------------------------------
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
//----------------------------------------------------------
69
}
file.close() ;
}
//----------------------------------------------------------
// FUNCTION TO RESERVE TICKET FOR THE PASSENGER
//----------------------------------------------------------
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
//----------------------------------------------------------
//----------------------------------------------------------
// 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
//----------------------------------------------------------
//----------------------------------------------------------
// THIS FUNCTION RETURNS PASSENGER'S NAME FOR THE GIVEN
// TICKET NO.
//----------------------------------------------------------
//----------------------------------------------------------
75
// THIS FUNCTION DISPLAYS THE LIST OF THE PASSENGERS
//----------------------------------------------------------
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() ;
}
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.
//----------------------------------------------------------
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.
//----------------------------------------------------------
80
file.close() ;
temp.close() ;
return found ;
}
//----------------------------------------------------------
// THIS FUNCTION CANCELS PASSENGER'S TICKET
//----------------------------------------------------------
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
//----------------------------------------------------------
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 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
90
MAIN WELCOME WINDOW
91
MENU WINDOW
92
ENQUIRY WINDOW
RESERVATION WINDOW
93
TICKET SAMPLE WINDOW
CANCELLATION OUTPUT
94
PASSENGER RECORDS WINDOW
95
EDIT PASSANGER RECORDS WINDOW
96
WAITING LIST WINDOW
13 CONCLUSION
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
Bjarne Stroustrup, The C++ Programming Language, 3rd edition, Addison-Wesley, 1997.
99
12. APPENDICES
Article III.
Article IV. 2. BILL.DAT: Keeps record of bills.
100
This program is having 3 classes:
MENU
AIRLINES
BOOKING
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.
102