ACKNOWLEDGEMENT

I owe a deep sense of gratitude to my Computer

science teacher Mr. Vivek Shrivastava whose
valuable advice, guidance helped me in doing this
project from conception to completion.
At the same time I can't forget to express my
thankfulness to Principal of our School for extending
his
generous
patronage
and
constant
encouragement.
Finally, Im thankful to my parents for helping me
economically and my friends for giving me a helping
hand at every step of the project.

Dated: January 2015

Pandya

Parth Sharma & Nitesh

XII
2014-2015

CERTIFICATE
This is to certify that Master Parth Sharma of class
XII of this Vidyalaya have successfully completed
the project entitled BANK MANAGEMENT SYSTEM.
The project has accomplished the satisfaction of
faculty concerned.

Dated: January 2015

Mr. Vivek Shrivastava

Chaturvedi
(P.G.T. Computer Science)
Principal)

Mr.

S.K.
(In

charge

Externals signature

CERTIFICATE
This is to certify that Master Nitesh Pandya of
class XII of this Vidyalaya have successfully
completed
the
project
entitled
BANK
MANAGEMENT
SYSTEM.
The
project
has
accomplished
the
satisfaction
of
faculty
concerned.

Dated: January 2015

Mr. Vivek Shrivastava

Chaturvedi

Mr.

S.K.

(P.G.T. Computer Science)

Principal)

(In

charge

Externals signature

INTRODUCTION TO
C++
C++ (pronounced as cee plus plus) is a generalpurpose
programming
language.
It
has
imperative,
object-oriented
and
generic
programming features, while also providing the
facilities for low-level memory manipulation.

It is designed with a bias toward system

programming (e.g., for use in embedded systems
or operating system kernels), with performance,
efficiency and flexibility of use as its design
requirements. C++ has also been found useful in

many
other
contexts,
including
desktop
applications, servers (e.g. e-commerce, web
search or SQL servers), performance-critical
applications (e.g. telephone switches or space
probes), and entertainment software. C++ is a
compiled language, with implementations of it
available on many platforms and provided by
various organizations, including the FSF, LLVM,
Microsoft and Intel.

C++ is standardized by the International

Organization for Standardization (ISO), with the
latest (and current) standard version ratified and
published by ISO in September 2011 as ISO/IEC
14882:2011 (informally known as C++11). The
C++
programming
language
was
initially
standardised in 1998 as ISO/IEC 14882:1998,
which was then amended by the C++03, ISO/IEC
14882:2003, standard. The current C++11
standard supersedes these, with new features and
an enlarged standard library. Before the initial
standardization in 1998, C++ was developed by
Bjarne Stroustrup at Bell Labs, starting in 1979,
who wanted an efficient flexible language (like the
C language), which also provided high-level
features for program organization.

Many other programming languages have been

influenced by C++, including C#, Java, and newer
versions of C (after 1998).
The C++ programming language was developed
at AT&T Bell Laboratories in the early 1980s by
Bjarne Stroustrup. He found C lacking for
simulations and decided to extend the languages
by adding features from his favourite language,
Simula 67. Simula 67 was one of the earliest
object oriented languages. Bjarne Stroustrup
called it C with classes originally. The name C+
+ (pronounced C plus plus) was coined by Rick
Mascitti where ++ is the increment operator.
Even since its birth, C++ evolved to cope with
problems encountered by users, and through
discussions at AT&T. However, the maturation of
the C++ language is attested to by two recent
events:

1. The formation of ANSI (American

Standard Institute) C++ Committee.

National

2. The publication of The Annotated

reference Manual by Ellis and Stroustrup.

C++

A programming language should serve two related

purposes:

1. It should provide a vehicle for the programmer

to specify actions to be executed.
2. It should provide a set of concepts for the
programmer to use when thinking about what
can be done.

Programming Paradigms:
A paradigm means organizing principle of a
program. It is an approach to programming.
Since the invention of the computer, many
programming approaches have been tried such as
procedural programming, modular programming,
structural
programming
etc.
The
primary
motivation in each case has been the concern to
handle the increasing complexity of programs that
are reliable and maintainable.

Procedural Programming:
A program in a procedural language is a list of
instructions where each statement tells the
computer to do something. The focus is on the

processing, the algorithm needed to perform

the desired computation. Languages support
this paradigm by providing facilities for passing
arguments to functions (subprograms) and
returning values from functions (subprograms).
In procedural programming, the emphasis is on
doing things. What to happen to data? Data is,
after all, the reason for a program existence.

Modular Programming:
With the increase in program size, a single list
of instruction becomes unwieldy. Thus a large
program is broken into smaller units i.e.
functions (sub-programs). The idea of breaking
program can be further extended by grouping a
number of functions together into a larger entity
called a module, but the basic principle remains
similar: grouping of components that carry out
specific task.
Module: A set of related procedure with the data
they manipulate is called a module.

Basic concepts of OOP:

The OOP has been developed with a view to

overcome
the
drawbacks
of
conventional
programming approaches. The OOP approach is
based on certain concepts that help in attaining
its goal. These general concepts of OOP are given
below:
Encapsulation
Polymorphism
Modularity

Encapsulation
Encapsulation is the hiding of information to
ensure that data structures and operators are
used as intended and to make the usage model
more obvious to the developer. C++ provides the
ability to define classes and functions as its
primary encapsulation mechanisms. Within a
class, members can be declared as either public,
protected, or private to explicitly enforce
encapsulation. A public member of the class is
accessible to any function. A private member is
accessible only to functions that are members of
that class and to functions and classes explicitly
granted access permission by the class

("friends"). A protected member is accessible to

members of classes that inherit from the class in
addition to the class itself and any friends.

The OO principle is that all of the functions (and

only the functions) that access the internal
representation of a type should be encapsulated
within the type definition. C++ supports this (via
member functions and friend functions), but does
not enforce it: the programmer can declare parts
or all of the representation of a type to be public,
and is allowed to make public entities that are not
part of the representation of the type. Therefore,
C++ supports not just OO programming, but other
weaker decomposition paradigms, like modular
programming.

It is generally considered good practice to make

all data private or protected, and to make public
only those functions that are part of a minimal
interface for users of the class. This can hide the
details of data implementation, allowing the
designer to later fundamentally change the
implementation without changing the interface in
any way.

SYNTAX
Suppose the class I discussed earlier, the class would be
called employee. A class name is defined by the keyword
class and then the name. For our employee class that would
be:

class employee
Notice that there is no semicolon following employee. This is
because after the class name comes the class definition.
Here's our class definition (including the class name):

const int SIZE = 40;

class employee
{
private:
char name[SIZE];
public:
void set_name(char arg_name[SIZE])
{
strncpy(name, arg_name, SIZE);
}
void display_name(void)
{
cout << name;
}
};
The first line has nothing to do with the class, it just specifies
the
number
of
characters name has
as
it's
maximum.class employee tells the compiler the class name
and that a class definition follows. Notice that the final
delimiter has a semicolon after it, this is necessary to tell the
compiler that the class definition ended. Now the

keywords public and private are access specifiers, which I'll

explain in a minute. name is a member of the class
while set_name and display_name are member functions of
the class. This is the BASIC class syntax, classes can and
often will do more than this, this is just to explain the basic
syntax. I'll get on to constructors and theinline/outline part
later.

Objects
Instances of classes are called objects. You can create an
instance of a class by doing the following:
classname objectname;
This will allocate the memory needed for a class to exist
because when the class is defined it will not be created yet.
It will be created when you declare an instance of the class,
thus the name object. To create an object ofemployee we
would do this:
employee mechanic;
Creating objects is done in main, WinMain, or any other
function that is non-related to the class.

Using objects
The example above showed us how to create an object. This
part of the article will show you how to use an object. We
declared the object mechanic, now we want to use it to
set name in our class. We can access a member or member
function in the class by using the class member access
operator or also called the dot operator (.). However, we
cannot get direct access to private data, I'll explain more
about that later on. So we'll have to use a member function.
Using the dot operator we can invoke this. The syntax is as
follows:
mechanic.set_name("John Doe");

This will call set_name of the object mechanic with the

argument "John Doe". The following however (as said before)
is NOT possible from within main or WinMain or any other
function non-related to the class:
mechanic.name = "John Doe"; //wrong
This is because name was defined under a private access
specifier which I'll discuss later. But this method does work
if name was declared under a public access specifier.

Pointer notation
Well then what's the deal with a pointer to an object? It's
practically the same except that the dot operator is being
replaced by the member access operator (->). Here's an
example:
employee mechanic;
employee* ptrmechanic;
ptrmechanic = &mechanic;
ptrmechanic->set_name("John Doe");
This cannot be used by objects! Only by pointers to objects.

Access specifiers
public and private are access specifiers. Simply put, they
exist for the sake of security. They specify the kind of access
given to the members and member functions of the class. In
our
class, name is
a private member
ofemployee while set_name and display_name are public me
mber functions of employee. The access specifierpublic gives
the entire program access to the data that follows it. While
the access specifier private only gives the member functions
in the class access to the data that follows it. There is one
other access specifier: protectedbut it only becomes useful in
inheritance, which will be what part 2 is all about.

Syntax of access specifiers

The syntax of access specifiers is as follows:
access_specifier:
//access_specifier data
new_access_specifier:
//new_access_specifier data
Note about new_access_specifier, new must not be treated
as the standard keyword new in C++. Why did I put two
access
specifiers
there?
Well,
it's
like
this:
after new_access_specifier, the data that follows it has the
access rules of new_access_specifier. What I'm trying to say
is: the access rules of the access specifier go for the data
that follows it before a new access specifier is stated. So the
following
access
rules
go
in
our employeeclass: name is private data, set_name and displ
ay_name are public data.

Tips on when which access specifiers to

use
When to use private:
//On class variables to keep them from alteration outside
the class.
When to use protected:
//On private data return functions in combination with
inheritance.
When to use public:
//On general member functions.

CONSTRUCTORS AND
DESTRUCTORS

Constructors
One of the many cases in which the constructor will be used
is when it is preferred to have the members of the class
being initialized to certain values immediately when the
object is declared. Constructors are functions that have no
return types and have exactly the same name as the
class, this must always be how a constructor is
defined! Why you ask? Because a constructor has no need
to return a value, and by giving it the same name as the
class the compiler can directly see if it is a constructor or
not. However, there is always a constructor, even if you not
define one. One of the constructor's functions (functions not
to be taken as a programming term) is to allocate the
amount of memory needed for the class when the object is
declared. This is why there is always a constructor.
Constructors can take arguments though. A good example of
when an argument is taken by a constructor is the copy
constructor which takes an object of the same class and
copies it's members' values into it's own members' values.

Destructors
Destructors are used to destroy an object at the end of the
program. Like the constructor, the destructor is always there,
even if you not define one. BUT when there is a written
constructor, it is a general good practice to also write a
destructor for it.

Syntax
The best way to explain the syntax of constructors and
destructors is by changing our employee class definition:
const int SIZE = 40;
class employee
{
private:
char name[SIZE];

public:
//constructor, note: wrong initializtion list (array as string)
employee() : name("Unemployed")
{
}
~employee() //destructor
{
}
void set_name(char arg_name[SIZE])
{
strncpy(name, arg_name, SIZE);
}
void display_name(void)
{
cout << name;
}
};
Notice that after the employee() part in the constructor there
is a colon, after that comes the so called initialization list.
This is used to initialize variables with certain values (which
can of course also be the arguments of a constructor). The
initialization list is widely used in constructors. In
our employee class the body of the constructor is empty, this
does not have to be the case. You can also leave the
initialization list out and put the part in the initialization list
in the body, like this:
employee() //constructor
{
strncpy(name, "Unemployed", SIZE);
}
This one will work UNLIKE the other one above, because
when you're dealing with arrays you cannot specify an
explicit initializer. In other words, the initialization list will not
work on arrays treated as strings. I put it in anyway because
I wanted to show you the basic use of the initialization list.

Syntax of the initialization list

: member(value), member(value) etc.
The member will be initialized with value, this can of course
also be a variable or the return value of a function. The basic
point is that the member will be initialized with the value
between parentheses.

The destructor
The destructor destroys everything created by the class
automatically, you can say it was a last will of the class. You
do not have to put any delete keywords in it, except if you
allocated any memory with the new keyword. For everything
else it does the work for you. It has the same name as the
class preceded by a tilde (~). Unlike the constructor, the
destructor takes no arguments. That sounds logical because
you would never need arguments when everything is
destroyed. However, the function body does not have to be
empty in a destructor. Why you ask? Well there is one good
reason why, for example when you want to debug your
program you could state something like this:
~employee() //destructor
{
cout << "Destructor called.";
/*the following would be required IF the variable name
was allocated with the new keyword*/
delete[] name;
}
There is always only one destructor in an entire class, unlike
the constructors which there can be more of.

Argumented constructors
When a constructor is argumented, the syntax for the object
declaration changes to:

employee(char arg_name[SIZE]) //constructor

{
strncpy(name, arg_name, SIZE);
}
employee mechanic; //wrong object declaration
employee mechanic("John Doe"); //right object declaration
This
is
one
useful
method
because
the set_name function wouldn't be necessary anymore.

now

Multiple constructors
You can also define multiple constructors for use in one class,
like this:
employee() //no argument constructor
{
strncpy(name, "Unemployed", SIZE);
}
employee(char arg_name) //one argument constructor
{
strncpy(name, arg_name, SIZE);
}
You can also define multiple constructors which have the
same amount of arguments, however, you cannot define
multiple constructors that take the same types of arguments.
The compiler simply wouldn't know which constructor to call.
This way you can choose how to declare your object. The
methods showed in the Argumented constructors part will
now both work.

Inline and outline member functions

Note: the following part assumes you know what
inline/outline
means
and
what
it
does.
Functions definedwithin a class (as in all the examples so far)
are inline by default! As a matter of fact, the compiler makes
it inline for you, whether you want to, or not. This is a

disadvantage if you have a short member function that is

called many times, or a very complex member function.
There is however one solution to this, using the scope
resolutionoperator.
Consider
our employee class:
the
member function display_name may be called many times. It
is not crucial when this member function is defined inside
the class, but it takes up a lot of memory because it's
automatically defined as inline by the compiler. Here's how
we solve this:
const int SIZE = 40;
class employee
{
private:
char name[SIZE];
public:
employee() //constructor
{
strncpy(name, "Unemployed", SIZE);
}
~employee() //destructor
{
}
void set_name(char[SIZE]); //function declarations only
void display_name(void);
};
// the :: is the scope resolution operator
void employee::set_name(char arg_name[SIZE])
{
strncpy(name, arg_name, SIZE);
}
void employee::display_name(void)
{
cout << name;
}
Now the functions are not inline because they
are defined outside the class and only declared within it.
However, do watch out for the following: if the function is

declared inside the class using the keyword inline and

defined outside the class, the function still is inline, but doing
this is wasting time because this is the same as declaring
and defining the function inside the class.

The scope resolution operator

The scope resolution operator is used to incorporate the
member function's name with the class name, or else the
compiler won't have a single clue of which class the function
was a member of. So it uses the scope resolution operator to
bind these names, this way the compiler knows in which
class to look for the declaration of the member function.
However, from within main, WinMain, or any other nonrelated function of the class, the scope resolution
operator cannot be used to call upon the member function of
a class. For our employee example:
employee::display_name(); // from within main would do no
good
To do this generates a compile error because the compiler
doesn't know with which object to access the member
function. Just use the dot operator or the member access
operator for pointers.

HISTORY OF C++
Bjarne Stroustrup, a Danish computer scientist,
began his work on C++'s predecessor "C with
Classes" in 1979. The motivation for creating a
new language originated from Stroustrup's
experience in programming for his Ph.D. thesis.
Stroustrup found that Simula had features that
were very helpful for large software development,
but the language was too slow for practical use,
while BCPL was fast but too low-level to be
suitable for large software development. When
Stroustrup started working in AT&T Bell Labs, he
had the problem of analyzing the UNIX kernel with
respect to distributed computing. Remembering
his Ph.D. experience, Stroustrup set out to
enhance the C language with Simula-like features.
C was chosen because it was general-purpose,
fast, portable and widely used. As well as C and
Simula's influences, other languages also
influenced C++, including, ALGOL 68, Ada, CLU
and ML.

Initially, the class, derived class, strong typing,

inlining, and default argument features were

added to C via Stroustrup's "C with Classes" to C

compiler, Cpre.

In 1983, it was renamed from C with Classes to

C++ (++ being the increment operator in C). New
features were added including virtual functions,
function
name
and
operator
overloading,
references,
constants,
type-safe
free-store
memory allocation (new/delete), improved type
checking, and BCPL style single-line comments
with two forward slashes (//), as well as the
development of a proper compiler for C++,
Cfront.

In 1985, the first edition of The C++ Programming

Language was released, which became the
definitive reference for the language, as there was
not yet an official standard. The first commercial
implementation of C++ was released in October
of the same year.

In 1989 C++ 2.0 was released followed by the

updated second edition of The C++ Programming
Language in 1991. New features in 2.0 included
multiple inheritance, abstract classes, static

member functions, const member functions, and

protected members. In 1990, The Annotated C++
Reference Manual was published. This work
became the basis for the future standard. Late
feature additions included templates, exceptions,
namespaces, new casts, and a boolean type.

In 2011, C++11 was released which added more

features and enlarged the standard library further
(compared to it in 1998), providing more facilities
for C++ programmers to use, with more additions
planned for 2014 and 2017.

Etymology
According to Stroustrup: "the name signifies the
evolutionary nature of the changes from C". This
name is credited to Rick Mascitti (mid-1983) and
was first used in December 1983.

When Mascitti was questioned informally in 1992

about the naming, he indicated that it was given
in a tongue-in-cheek spirit. The name stems from
C's "++" operator (which increments the value of
a variable) and a common naming convention of

using "+" to indicate an enhanced computer

program. A joke goes that the name itself has a
bug: due to the use of post-increment, which
increments the value of the variable but evaluates
to the incremented value, so C++ is no better
than C, and the pre-increment ++C form should
have been used instead, so that C++ is better
than C.

During C++'s development period, the language

had been referred to as "new C", then "C with
Classes", before acquiring its final name.

Philosophy
Throughout C++'s life, its development and
evolution has been informally governed by a set
of rules that its evolution should follow:

It must be driven by actual problems and its

features should be useful immediately in real
world programs.
Every feature should be implementable (with a
reasonably obvious way to do so).

Programmers should be free to pick their own

programming style, and that style should be fully
supported by C++.
Allowing a useful feature is more important than
preventing every possible misuse of C++.
It should provide facilities for organising programs
into well-defined separate parts, and provide
facilities for combining separately developed
parts.
No implicit violations of the type system (but
allow explicit violations that have been explicitly
asked for by the programmer).
Make user created types have equal support and
performance to built in types.
Any features that you do not use you do not pay
for (e.g. in performance).
There should be no language beneath C++
(except assembly language).
C++ should work alongside other pre-existing
programming languages, rather than being part of
its own separate and incompatible programming
environment.
If what the programmer wants to do is unknown,
allow the programmer to specify (provide manual
control).

Standardization
C++ is standardized by an ISO working group,
JTC1/SC22/WG21. So far it has seen three versions
of C++ released and is currently working on
releasing C++14.

In 1998, it standardized C++ for the first time as

ISO/IEC 14882:1998 (informally known as C+
+98). In 2003 it then published a new version of
the C++ standard, ISO/IEC 14882:2003, which
fixed problems which had been identified in C+
+98.

In 2005, a technical report, called the "Library

Technical Report 1" (TR1), was released. While not
an official part of the standard, it specified a
number of extensions to the standard library,
which were then included in the next version of
C++ (then C++0x).

The latest major revision of the C++ standard, C+

+11 (formerly known as C++0x), was approved
and released on the 12 August 2011, as
14882:2011.

A small extension to C++11, C++14 (also known

as C++1y) featuring mainly bug fixes and small
improvements is planned for release in 2014. It
holds similar aims as C++03 did to C++98. The
Draft International Standard ballot procedures
completed in mid-August 2014.

After C++1y, a major revision, informally known

as C++17, is planned for 2017.

As part of the standardization process, the ISO

publishes several kinds of publications. In
particular, technical reports and technical
specifications are published when "there is the
future but not immediate possibility of an
agreement to publish an International Standard."
Until 2011, three technical reports on C++ where
published: TR 19768:2007, also known as the C+
+ Technical Report 1, on library extensions mostly
integrated into C++11, TR 29124:2010 on special
mathematical functions, and TR 24733:2011 on
floating
point
arithmetic.
The
technical
specification DTS 18822:2014 (on file system
operations) was approved in early 2015, and more

technical specifications are in development and

pending.

CONSTRUCTORS

A constructor is a special member function

whose task is to initialize the objects of its
class. It is special because its name is same
as the class name. The constructor is invoked
whenever an object of its associated class is
created. It is called constructor because it
construct the value data members of the class.
//class with a constructor
class Integer
{
int m, n;
public:
Integer(void); / constructor declared
};
Integer :: Integer(void) // constructor defined
{
m = 0; n = 0;
}
};

When a class contains a constructor like the one

defined above, it is guaranteed that an object
created by the class will be initialized
automatically. For example, the declaration.
Integer int1; // object int1 created

not only creates the object int1 of type

Integer but also initializes its data members m
and n to 0.There is no need to write any
statement to invoke the constructor function. Pdf
Machine - is a pdf writer that produces quality PDF
files with ease!
Get yours now!
Thank you very much! I can use Acrobat Distiller
or the Acrobat PDFWriter but I consider your
product a lot easier to use and much preferable to
Adobe's" A.Sarras -USA
A constructor that accepts no parameters is
called
the default constructor. The default
constructor for class A is A::A(). If no such
constructor is defined the compiler suppliers
default constructor. Therefore a statement such as
A
a; invokes the default constructor of the
compiler to create the object a.
The constructor functions have some special
characteristics.
They should be declared in the public section.
They are invoked automatically when the
objects are created.

 They do not have return types, not even

void and
values.
They

therefore,

cannot

derived class
constructor.

be
can

they cannot return

inherited,
call

the

though

baseclass

Like other C++ functions, they can have default

arguments.
Constructors cannot be virtual. We cannot refer
to their addresses. An object with a constructor
(or destructor) cannot be used as a member of
a union. They make implicit calls to the
operations new and delete when memory
allocation is required. Remember, when a
constructor is declared for a class initialization
of the class objects become mandatory.

PARAMETERIZED CONSTRUCTORS
The
constructor
Integer(),
defined
above,
initialized the data members of all the objects
to zero. However in practice it may be
necessary
to
initialize
the
various
data
elements of different objects with different
values when they are created. C++ permits
us to achieve this objective by passing
arguments to the constructor function when

the objects are created. The constructors that

can take arguments are called parameterized
constructors.
The constructor integer() may be modified to
take arguments as
shown below :
class integer
{
int m, n;
public:
integer (int x, int y); //parameterized constructor

pdfMachine - is a pdf writer that produces quality

PDF files with ease!
Get yours now!
Thank you very much! I can use Acrobat Distiller
or the Acrobat PDFWriter but I consider your
product a lot easier to use and much preferable to
Adobe's" A.Sarras -USA
};
integer : : integer int x, int y)
{
m = x; n = y;
}

When a constructor has been parameterized,

the object declaration statement such as integer

int1; may not work. We must pass the initial

values
as
arguments
to
the constructor
function when an object is declared. This can
be done in two ways;
By calling the constructor explicitly.
By calling the constructor implicitly.
Integer Int1 = Integer (0, 100); //explicit call

This statement creates in integer object int1

and passes the values
0 and 100 to it.
The second is implemented as follows :
Integer int1 (0, 100); //implicit call.
This method sometimes called the shorthand
method, is used very often as it is shorter, looks
better and is easy to implement. Remember,
when the constructor is parameterized, we must
provide arguments for the constructor.

BENEFITS OF OOPS
OOP offers several benefits to both the program
designer and the user. The principal advantages are.
i)
ii)

iii
)

iv
)
v
)

vi)
vii)
viii)

T
hr
o
u
g
h
in
h
er
it
a
nc
e,
w
e
ca
n
eli
m
in
at
e
re
d
u
n
d
a
nt
co
d
e
a
n
d
ex
te
n
d
th
e
us
e
of
ex
ist
in
g

classes
We can build program from
the standard working module
that communicate with one
another, rather than having to
start writing the code from
scratch. This leads to saving
of development time and
higher productivity.
The principal of data hiding
helps the programmer to
build secure programs that
cannot be invaded by code
in other part of the
program.
It is possible to have multiple
instance of an object to coexist without any interference
It is easy to partition the
work in a project, based on
objects. Object oriented
systems can be easily
upgraded from small to large
systems.
Message passing
techniques for
communication between
objects makes the interface
description with external
systems much simpler.
Software
complexity can be
easily managed.

Submitted by: Parth & Nitesh

LANGUAGE
Operators and operator overloading
C++ provides more than 35 operators, covering
basic arithmetic, bit manipulation, indirection,
comparisons, logical operations and others.
Almost all operators can be overloaded for userdefined types, with a few notable exceptions
such as member access (. and .*) as well as the
conditional
operator.
The
rich
set
of
overloadable operators is central to making
user-defined types in C++ seem like built-in
types. Overloadable operators are also an
essential part of many advanced C++
programming techniques, such as smart
pointers. Overloading an operator does not
change the precedence of calculations involving
the operator, nor does it change the number of
operands that the operator uses (any operand
may however be ignored by the operator,
though it will be evaluated prior to execution).
Overloaded "&&" and "||" operators lose their
short-circuit evaluation property.

49

Submitted by: Parth & Nitesh

OBJECT STORAGE
C++ supports four types of memory
management:
Static storage duration objects
Thread storage duration objects
Automatic storage duration objects
Dynamic storage duration objects

49

Submitted by: Parth & Nitesh

WHY OBJECT
ORIENTED
PROGRAMMING?
With the rapidly changing world and the highly
competitive
and
versatile
industry,
the
operations are becoming more and more
complex. In view of increasing complexity of
software systems, the software industry and
software engineering continuously look for the
new approaches to software design and
development. The increased complexity had
become the chief problem with computer
programs in traditional languages. Large
programs due to complexity are more prone to
errors and software errors can be expensive and
even life threatening. The most adopted and
popular programming approach, structured
programming approach, failed to show the
desired results in terms of bug-free, easy-tomaintain, and reusable programs. The latest
programming
approach
Object
Oriented
Programming (OOP), offers a new and powerful
way to cope with complexity. Its goal is clearer,
more
reliable,
more
easily
maintained
49

Submitted by: Parth & Nitesh

programs. This concept includes general OOP

concepts that the traditional languages like C,
Pascal, COBOL and BASIC lack in and new
generation
languages
(Object
Oriented
Languages) support.

INTRODUCTION TO
PROJECT
This program is totally based on new concept
and no part of it is copied from any other
program either from internet or from any book.
The program is specially designed for a bank.

This program will be useful in banks for taking

records and saving them, calculation of amount
etc. Computer, being more reliable than human
can process faster and accurately. This program
performs following functions:

Takes input from the user while creating new

account.

49

Submitted by: Parth & Nitesh

Assigns an account number to the user.

User can either withdraw or deposit money in
his / her account.
User can do his balance enquiry either by his
name or his account number.
Program takes a password while going in bank
database for the purpose that only officials
can see the bank database.
In bank database, it gives all the details of the
user either by his name or account number.
It

removes

the

account

from

database whenever user wishes.

49

the

bank

Submitted by: Parth & Nitesh

SCREENSHOTS FROM
THE PROGRAM
Main Screen :

49

Submitted by: Parth & Nitesh

SCREENSHOTS FROM
THE PROGRAM
New Account Screen:

49

Submitted by: Parth & Nitesh

SCREENSHOTS FROM
THE PROGRAM
Deposit Money Screen:

49

Submitted by: Parth & Nitesh

SCREENSHOTS FROM
THE PROGRAM
Withdraw Money Screen:

49

Submitted by: Parth & Nitesh

SCREENSHOTS FROM
THE PROGRAM
View Details of a Specific Account:

49

Submitted by: Parth & Nitesh

SCREENSHOTS FROM
THE PROGRAM
Bank Database Screen (All Accounts):

49

Submitted by: Parth & Nitesh

SCREENSHOTS FROM
THE PROGRAM
Close An Account Screen:

49

Submitted by: Parth & Nitesh

_____________________________________________________________________

SCREENSHOTS FROM
THE PROGRAM
Modify an Account:

49

Submitted by: Parth & Nitesh

SCREENSHOTS FROM
THE PROGRAM
Exit from the Program:

49

Submitted by: Parth & Nitesh

LIMITATIONS
This Program cannot perform all the functions
of a bank.
It does not have (GUI) Graphical User
Interface.
49

Submitted by: Parth & Nitesh

MINIMUM SYSTEM
REQUIREMENTS
Windows 95, 98, 2000, Me, Xp, 8, 8.1 or more.
Dev C++ compiler.
64 MB RAM.
CD ROM Drive.
1 MB free hard disc space.

BIBLIOGRAPHY
C++ help.

49

Submitted by: Parth & Nitesh

Mr. Vivek Shrivastava (P.G.T. Computer

Science).

Tata Mc-graw Hill E. Balagurusami.

Sumita Arora.

49