Unit Structure:
1.1 Software crisis
1.2 Software Evaluation
1.3 POP (Procedure Oriented Programming)
1.4 OOP (Object Oriented Programming)
1.5 Basic concepts of OOP
1.5.1 Objects
1.5.2 Classes
1.5.3 Data Abstraction and Data Encapsulation
1.5.4 Inheritance
1.5.5 Polymorphism
1.5.6 Dynamic Binding
1.5.7 Message Passing
1.6 Benefits of OOP
1.7 Object Oriented Language
1.8 Application of OOP
1.9 Introduction of C++
1.9.1 Application of C++
1.10 Simple C++ Program
1.10.1 Program Features
1.10.2 Comments
1.10.3 Output Operators
1.10.4 Iostream File
1.10.5 Namespace
1.10.6 Return Type of main ()
1.11 More C++ Statements
1.11.1 Variable
1.11.2 Input Operator
1.11.3 Cascading I/O Operator
1.12 Example with Class
1.13 Structure of C++
1.14 Creating Source File
1.15 Compiling and Linking
1.1 Software Crisis
Developments in software technology continue to be dynamic. New tools and techniques
are announced in quick succession. This has forced the software engineers and industry to
continuously look for new approaches to software design and development, and they are
becoming more and more critical in view of the increasing complexity of software
systems as well as the highly competitive nature of the industry. These rapid advances
appear to have created a situation of crisis within the industry. The following issued need
to be addressed to face the crisis:
• How to represent real-life entities of problems in system design?
• How to design system with open interfaces?
• How to ensure reusability and extensibility of modules?
• How to develop modules that are tolerant of any changes in future?
• How to improve software productivity and decrease software cost?
• How to improve the quality of software?
• How to manage time schedules?
1.2 Software Evaluation
Ernest Tello, A well known writer in the field of artificial intelligence, compared the
evolution of software technology to the growth of the tree. Like a tree, the software
evolution has had distinct phases “layers” of growth. These layers were building up one
by one over the last five decades as shown in fig. 1.1, with each layer representing and
improvement over the previous one. However, the analogy fails if we consider the life
of these layers. In software system each of the layers continues to be functional,
whereas in the case of trees, only the uppermost layer is functional
Object Oriented Programming
Procedure- Oriented
Assembly Language
Machine Language
1, 0
Alan Kay, one of the promoters of the object-oriented paradigm and the principal
designer of Smalltalk, has said: “As complexity increases, architecture dominates the
basic materials”. To build today’s complex software it is just not enough to put together a
sequence of programming statements and sets of procedures and modules; we need to
incorporate sound construction techniques and program structures that are easy to
comprehend implement and modify.
With the advent of languages such as c, structured programming became very popular
and was the main technique of the 1980’s. Structured programming was a powerful tool
that enabled programmers to write moderately complex programs fairly easily. However,
as the programs grew larger, even the structured approach failed to show the desired
result in terms of bug-free, easy-to- maintain, and reusable programs.
Object Oriented Programming (OOP) is an approach to program organization and
development that attempts to eliminate some of the pitfalls of conventional programming
methods by incorporating the best of structured programming features with several
powerful new concepts. It is a new way of organizing and developing programs and has
nothing to do with any particular language. However, not all languages are suitable to
implement the OOP concepts easily.
1.3 Procedure-Oriented Programming
In the procedure oriented approach, the problem is viewed as the sequence of things to
be done such as reading, calculating and printing such as cobol, fortran and c. The
primary focus is on functions. A typical structure for procedural programming is shown
in fig.1.2. The technique of hierarchical decomposition has been used to specify the tasks
to be completed for solving a problem.
Function-1 Function-2
Function-8
Function-5
Function-7
Function-4
Function-3
Main Program
Function-6
Fig. 1.2 Typical structure of procedural oriented programs
Procedure oriented programming basically consists of writing a list of instructions for the
computer to follow, and organizing these instructions into groups known as functions. We
normally use flowcharts to organize these actions and represent the flow of control from
one action to another.
In a multi-function program, many important data items are placed as global so that
they may be accessed by all the functions. Each function may have its own local data.
Global data are more vulnerable to an inadvertent change by a function. In a large
program it is very difficult to identify what data is used by which function. In case we
need to revise an external data structure, we also need to revise all functions that access
the data. This provides an opportunity for bugs to creep in.
Another serious drawback with the procedural approach is that we do not model real
world problems very well. This is because functions are action-oriented and do not really
corresponding to the element of the problem.
Some Characteristics exhibited by procedure-oriented programming are:
• Emphasis is on doing things (algorithms).
• Large programs are divided into smaller programs known as functions.
• Most of the functions share global data.
• Data move openly around the system from function to function.
• Functions transform data from one form to another.
• Employs top-down approach in program design.
1.4 Object Oriented Paradigm
The major motivating factor in the invention of object-oriented approach is to remove
some of the flaws encountered in the procedural approach. OOP treats data as a critical
element in the program development and does not allow it to flow freely around the
system. It ties data more closely to the function that operate on it, and protects it from
accidental modification from outside function. OOP allows decomposition of a problem
into a number of entities called objects and then builds data and function around these
objects. The organization of data and function in object-oriented programs is shown in
fig.1.3. The data of an object can be accessed only by the function associated with that
object. However, function of one object can access the function of other objects.
Organization of data and function in OOP
Object A Object B
Communication
DATA
FUNCTION
DATA
FUNCTION
Object
FUNCTION
DATA
Some of the features of object oriented programming are:
• Emphasis is on data rather than procedure.
• Programs are divided into what are known as objects.
• Data structures are designed such that they characterize the objects.
• Functions that operate on the data of an object are ties together in the data
structure.
• Data is hidden and cannot be accessed by external function.
• Objects may communicate with each other through function.
• New data and functions can be easily added whenever necessary.
• Follows bottom up approach in program design.
Object-oriented programming is the most recent concept among programming
paradigms and still means different things to different people.
1.5 Basic Concepts of Object Oriented Programming
It is necessary to understand some of the concepts used extensively in object-oriented
programming. These include:
• Objects
• Classes
• Data abstraction and encapsulation
• Inheritance
• Polymorphism
• Dynamic binding
• Message passing
We shall discuss these concepts in some detail in this section.
1.5.1 Objects
Objects are the basic run time entities in an object-oriented system. They may represent a
person, a place, a bank account, a table of data or any item that the program has to
handle. They may also represent user-defined data such as vectors, time and lists.
Programming problem is analyzed in term of objects and the nature of communication
between them. Program objects should be chosen such that they match closely with the
real-world objects. Objects take up space in the memory and have an associated address
like a record in Pascal, or a structure in c.
When a program is executed, the objects interact by sending messages to one another.
Foe example, if “customer” and “account” are to object in a program, then the customer
object may send a message to the count object requesting for the bank balance. Each
object contain data, and code to manipulate data. Objects can interact without having to
know details of each other’s data or code. It is a sufficient to know the type of message
accepted, and the type of response returned by the objects. Although different author
represent them differently fig 1.5 shows two notations that are popularly used in objectoriented analysis and design.
OBJECTS: STUDENT
DATA
Name
Date-of-birth
Marks
FUNCTIONS
Total
Average
Display
………
Fig. 1.5 representing an object
1.5.2 Classes
We just mentioned that objects contain data, and code to manipulate that data. The entire
set of data and code of an object can be made a user-defined data type with the help of
class. In fact, objects are variables of the type class. Once a class has been defined, we
can create any number of objects belonging to that class. Each object is associated with
the data of type class with which they are created. A class is thus a collection of objects
similar types. For examples, Mango, Apple and orange members of class fruit. Classes
are user-defined that types and behave like the built-in types of a programming language.
The syntax used to create an object is not different then the syntax used to create an
integer object in C. If fruit has been defines as a class, then the statement
Fruit Mango;
Will create an object mango belonging to the class fruit.
1.5.3 Data Abstraction and Encapsulation
The wrapping up of data and function into a single unit (called class) is known as
encapsulation. Data and encapsulation is the most striking feature of a class. The data is
not accessible to the outside world, and only those functions which are wrapped in the
class can access it. These functions provide the interface between the object’s data and
the program. This insulation of the data from direct access by the program is called data
hiding or information hiding.
Abstraction refers to the act of representing essential features without including the
background details or explanation. Classes use the concept of abstraction and are defined
as a list of abstract attributes such as size, wait, and cost, and function operate on these
attributes. They encapsulate all the essential properties of the object that are to be created.
The attributes are some time called data members because they hold information. The
functions that operate on these data are sometimes called methods or member function.
1.5.4 Inheritance
Inheritance is the process by which objects of one class acquired the properties of objects
of another classes. It supports the concept of hierarchical classification. For example,
the bird, ‘robin’ is a part of class ‘flying bird’ which is again a part of the class ‘bird’.
The principal behind this sort of division is that each derived class shares common
characteristics with the class from which it is derived as illustrated in fig 1.6.
In OOP, the concept of inheritance provides the idea of reusability. This means that we
can add additional features to an existing class without modifying it. This is possible by
deriving a new class from the existing one. The new class will have the combined feature
of both the classes. The real appeal and power of the inheritance mechanism is that it
Fig. 1.6 Property inheritances
BRD
Attributes
Features
Lay Eggs
Non Flying Bird
Attributes
………..
………..
Flying Bird
Attributes
…………
………...
Robin
Attributes
…………
………...
Swallow
Attributes
…………
………...
Penguin
Attributes
…………
………...
Kiwi
Attributes
…………
………...
Allows the programmer to reuse a class i.e almost, but not exactly, what he wants, and to
tailor the class in such a way that it does not introduced any undesirable side-effects into
the rest of classes.
1.5.5 Polymorphism
Polymorphism is another important OOP concept. Polymorphism, a Greek term, means
the ability to take more than on form. An operation may exhibit different behavior is
different instances. The behavior depends upon the types of data used in the operation.
For example, consider the operation of addition. For two numbers, the operation will
generate a sum. If the operands are strings, then the operation would produce a third
string by concatenation. The process of making an operator to exhibit different behaviors
in different instances is known as operator overloading.
Fig. 1.7 illustrates that a single function name can be used to handle different number
and different types of argument. This is something similar to a particular word having
several different meanings depending upon the context. Using a single function name to
perform different type of task is known as function overloading.
Shape
Draw
Circle Object
Draw (Circle)
Box object
Draw (box)
Triangle Object
Draw (triangle)
Fig. 1.7 Polymorphism
Polymorphism plays an important role in allowing objects having different internal
structures to share the same external interface. This means that a general class of
operations may be accessed in the same manner even though specific action associated
with each operation may differ. Polymorphism is extensively used in implementing
inheritance.
1.5.6 Dynamic Binding
Binding refers to the linking of a procedure call to the code to be executed in response to
the call. Dynamic binding means that the code associated with a given procedure call is
not known until the time of the call at run time. It is associated with polymorphism and
inheritance. A function call associated with a polymorphic reference depends on the
dynamic type of that reference.
Consider the procedure “draw” in fig. 1.7. by inheritance, every object will have this
procedure. Its algorithm is, however, unique to each object and so the draw procedure
will be redefined in each class that defines the object. At run-time, the code matching the
object under current reference will be called.
1.5.7 Message Passing
An object-oriented program consists of a set of objects that communicate with each other.
The process of programming in an object-oriented language, involves the following basic
steps:
1. Creating classes that define object and their behavior,
2. Creating objects from class definitions, and
3. Establishing communication among objects.
Objects communicate with one another by sending and receiving information much the
same way as people pass messages to one another. The concept of message passing
makes it easier to talk about building systems that directly model or simulate their realworld counterparts.
A Message for an object is a request for execution of a procedure, and therefore will
invoke a function (procedure) in the receiving object that generates the desired results.
Message passing involves specifying the name of object, the name of the function
(message) and the information to be sent. Example:
Employee. Salary (name);
Object
Information
Message
Object has a life cycle. They can be created and destroyed. Communication with an
object is feasible as long as it is alive.
1.6 Benefits of OOP
OOP offers several benefits to both the program designer and the user. ObjectOrientation contributes to the solution of many problems associated with the
development and quality of software products. The new technology promises greater
programmer productivity, better quality of software and lesser maintenance cost. The
principal advantages are:
• Through inheritance, we can eliminate redundant code extend the use of existing
• Classes.
• We can build programs from the standard working modules 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 principle of data hiding helps the programmer to build secure program that
can not be invaded by code in other parts of a programs.
• It is possible to have multiple instances of an object to co-exist without any
interference.
• It is possible to map object in the problem domain to those in the program.
• It is easy to partition the work in a project based on objects.
• The data-centered design approach enables us to capture more detail of a model
can implemental form.
• Object-oriented system can be easily upgraded from small to large system.
• Message passing techniques for communication between objects makes to
interface descriptions with external systems much simpler.
• Software complexity can be easily managed.
While it is possible to incorporate all these features in an object-oriented system, their
importance depends on the type of the project and the preference of the programmer.
There are a number of issues that need to be tackled to reap some of the benefits stated
above. For instance, object libraries must be available for reuse. The technology is still
developing and current product may be superseded quickly. Strict controls and protocols
need to be developed if reuse is not to be compromised.
1.7 Object Oriented Language
Object-oriented programming is not the right of any particular languages. Like structured
programming, OOP concepts can be implemented using languages such as C and Pascal.
However, programming becomes clumsy and may generate confusion when the programs
grow large. A language that is specially id designed to support the OOP concepts makes
it easier to implement them.
The languages should support several of the OOP concepts to claim that they are
object-oriented. Depending upon the features they support, they can be classified into the
following two categories:
1. Object-based programming languages, and
2. Object-oriented programming languages.
Object-based programming is the style of programming that primarily supports
encapsulation and object identity. Major feature that are required for object based
programming are:
• Data encapsulation
• Data hiding and access mechanisms
• Automatic initialization and clear-up of objects
• Operator overloading
Languages that support programming with objects are said to the objects-based
programming languages. They do not support inheritance and dynamic binding. Ada is a
typical object-based programming language.
Object-oriented programming language incorporates all of object-based
programming features along with two additional features, namely, inheritance and
dynamic binding. Object-oriented programming can therefore be characterized by the
following statements:
Object-based features + inheritance + dynamic binding
1.8 Application of OOP
OOP has become one of the programming buzzwords today. There appears to be a great
deal of excitement and interest among software engineers in using OOP. Applications of
OOP are beginning to gain importance in many areas. The most popular application of
object-oriented programming, up to now, has been in the area of user interface design
such as window. Hundreds of windowing systems have been developed, using the OOP
techniques.
Real-business system are often much more complex and contain many more objects
with complicated attributes and method. OOP is useful in these types of application
because it can simplify a complex problem. The promising areas of application of OOP
include:
• Real-time system
• Simulation and modeling
• Object-oriented data bases
• Hypertext, Hypermedia, and expertext
• AI and expert systems
• Neural networks and parallel programming
• Decision support and office automation systems
• CIM/CAM/CAD systems
The object-oriented paradigm sprang from the language, has matured into design, and has
recently moved into analysis. It is believed that the richness of OOP environment will
enable the software industry to improve not only the quality of software system but also
its productivity. Object-oriented technology is certainly going to change the way the
software engineers think, analyze, design and implement future system.
1.9 Introduction of C++
C++ is an object-oriented programming language. It was developed by Bjarne Stroustrup
at AT&T Bell Laboratories in Murray Hill, New Jersey, USA, in the early 1980’s.
Stroustrup, an admirer of Simula67 and a strong supporter of C, wanted to combine the
best of both the languages and create a more powerful language that could support
object-oriented programming features and still retain the power and elegance of C. The
result was C++. Therefore, C++ is an extension of C with a major addition of the class
construct feature of Simula67. Since the class was a major addition to the original C
language, Stroustrup initially called the new language ‘C with classes’. However, later in
1983, the name was changed to C++. The idea of C++ comes from the C increment
operator ++, thereby suggesting that C++ is an augmented version of C.
C+ + is a superset of C. Almost all c programs are also C++ programs. However, there
are a few minor differences that will prevent a c program to run under C++ complier. We
shall see these differences later as and when they are encountered.
The most important facilities that C++ adds on to C care classes, inheritance, function
overloading and operator overloading. These features enable creating of abstract data
types, inherit properties from existing data types and support polymorphism, thereby
making C++ a truly object-oriented language.
1.9.1 Application of C++
C++ is a versatile language for handling very large programs; it is suitable for virtually
any programming task including development of editors, compilers, databases,
communication systems and any complex real life applications systems.
• Since C++ allow us to create hierarchy related objects, we can build special
object-oriented libraries which can be used later by many programmers.
• While C++ is able to map the real-world problem properly, the C part of C++
gives the language the ability to get closed to the machine-level details.
• C++ programs are easily maintainable and expandable. When a new feature needs
to be implemented, it is very easy to add to the existing structure of an object.
• It is expected that C++ will replace C as a general-purpose language in the near
future.
1.10 Simple C++ Program
Let us begin with a simple example of a C++ program that prints a string on the
screen.
Printing A String
#include<iostream>
Using namespace std;
int main()
{
cout<<” c++ is better than c \n”;
return 0;
}
Program 1.10.1
This simple program demonstrates several C++ features.
1.10.1 Program feature
Like C, the C++ program is a collection of function. The above example contain only one
function main(). As usual execution begins at main(). Every C++ program must have a
main(). C++ is a free form language. With a few exception, the compiler ignore carriage
return and white spaces. Like C, the C++ statements terminate with semicolons.
1.10.2 Comments
C++ introduces a new comment symbol // (double slash). Comment start with a double
slash symbol and terminate at the end of the line. A comment may start anywhere in the
line, and whatever follows till the end of the line is ignored. Note that there is no closing
symbol.
The double slash comment is basically a single line comment. Multiline comments can
be written as follows:
// This is an example of
// C++ program to illustrate
// some of its features
The C comment symbols /*,*/ are still valid and are more suitable for multiline
comments. The following comment is allowed:
/* This is an example of
C++ program to illustrate
some of its features
*/
1.10.3 Output operator
The only statement in program 1.10.1 is an output statement. The statement
Cout<<”C++ is better than C.”;
Causes the string in quotation marks to be displayed on the screen. This statement
introduces two new C++ features, cout and <<. The identifier cout(pronounced as C out)
is a predefined object that represents the standard output stream in C++. Here, the
standard output stream represents the screen. It is also possible to redirect the output to
other output devices. The operator << is called the insertion or put to operator.
1.10.4 The iostream File
We have used the following #include directive in the program:
#include <iostream>
The #include directive instructs the compiler to include the contents of the file enclosed
within angular brackets into the source file. The header file iostream.h should be
included at the beginning of all programs that use input/output statements.
1.10.5 Namespace
Namespace is a new concept introduced by the ANSI C++ standards committee. This
defines a scope for the identifiers that are used in a program. For using the identifier
defined in the namespace scope we must include the using directive, like
Using namespace std;
Here, std is the namespace where ANSI C++ standard class libraries are defined. All
ANSI C++ programs must include this directive. This will bring all the identifiers defined
in std to the current global scope. Using and namespace are the new keyword of C++.
1.10.6 Return Type of main()
In C++, main () returns an integer value to the operating system. Therefore, every main ()
in C++ should end with a return (0) statement; otherwise a warning an error might occur.
Since main () returns an integer type for main () is explicitly specified as int. Note that
the default return type for all function in C++ is int. The following main without type and
return will run with a warning:
main ()
{
…………..
………….
}
1.11 More C++ Statements
Let us consider a slightly more complex C++ program. Assume that we should like to
read two numbers from the keyboard and display their average on the screen. C++
statements to accomplish this is shown in program 1.11.1
AVERAGE OF TWO NUMBERS
#include<iostream.h> // include header file
Using namespace std;
Int main()
{
Float number1, number2,sum, average;
Cin >> number1; // Read Numbers
Cin >> number2; // from keyboard
Sum = number1 + number2;
Average = sum/2;
Cout << ”Sum = “ << sum << “\n”;
Cout << “Average = “ << average << “\n”;
Return 0;
} //end of example
The output would be:
Enter two numbers: 6.5 7.5
Sum = 14
Average = 7
Program 1.11.1
1.11.1 Variables
The program uses four variables number1, number2, sum and average. They are declared
as type float by the statement.
float number1, number2, sum, average;
All variable must be declared before they are used in the program.
1.11.2 Input Operator
The statement
cin >> number1;
Is an input statement and causes the program to wait for the user to type in a number. The
number keyed in is placed in the variable number1. The identifier cin (pronounced ‘C in’)
is a predefined object in C++ that corresponds to the standard input stream. Here, this
stream represents the keyboard.
The operator >> is known as extraction or get from operator. It extracts (or takes) the
value from the keyboard and assigns it to the variable on its right fig 1.8. This
corresponds to a familiar scanf() operation. Like <<, the operator >> can also be
overloaded.
Object Execution operator Variable
Keyboard
Fig
Cin >>
45.5
1.8 Input using extraction operator
1.11.3 Cascading of I/O Operators
We have used the insertion operator << repeatedly in the last two statements for printing
results.
The statement
Cout << “Sum = “ << sum << “\n”;
First sends the string “Sum = “ to cout and then sends the value of sum. Finally, it sends
the newline character so that the next output will be in the new line. The multiple use of
<< in one statement is called cascading. When cascading an output operator, we should
ensure necessary blank spaces between different items. Using the cascading technique,
the last two statements can be combined as follows:
Cout << “Sum = “ << sum << “\n”
<< “Average = “ << average << “\n”;
This is one statement but provides two line of output. If you want only one line of output,
the statement will be:
Cout << “Sum = “ << sum << “,”
<< “Average = “ << average << “\n”;
The output will be:
Sum = 14, average = 7
We can also cascade input iperator >> as shown below:
Cin >> number1 >> number2;
The values are assigned from left to right. That is, if we key in two values, say, 10 and
20, then 10 will be assigned to munber1 and 20 to number2.
1.12 An Example with Class
• One of the major features of C++ is classes. They provide a method of binding
together data and functions which operate on them. Like structures in C, classes are
user-defined data types.
Program 1.12.1 shows the use of class in a C++ program.
USE OF CLASS
#include<iostream.h> // include header file
using namespace std;
class person
{
char name[30];
Int age;
public:
void getdata(void);
void display(void);
};
void person :: getdata(void)
{
cout << “Enter name: “;
cin >> name;
cout << “Enter age: “;
cin >> age;
}
Void person : : display(void)
{
cout << “\nNameame: “ << name;
cout << “\nAge: “ << age;
}
Int main()
{
person p;
p.getdata();
p.display();
Return 0;
} //end of example
PROGRAM 1.12.1
The output of program is:
Enter Name: Ravinder
Enter age:30
Name:Ravinder
Age: 30
The program define person as a new data of type class. The class person includes two
basic data type items and two function to operate on that data. These functions are called
member function. The main program uses person to declare variables of its type. As
pointed out earlier, class variables are known as objects. Here, p is an object of type
person. Class object are used to invoke the function defined in that class.
1.13 Structure of C++ Program
As it can be seen from program 1.12.1, a typical C++ program would contain four
sections as shown in fig. 1.9. This section may be placed in separate code files and then
compiled independently or jointly.
It is a common practice to organize a program into three separate files. The class
declarations are placed in a header file and the definitions of member functions go into
another file. This approach enables the programmer to separate the abstract specification
of the interface from the implementation details (member function definition).
Finally, the main program that uses the class is places in a third file which “includes: the
previous two files as well as any other file required.
Include Files
Class declaration
Member functions definitions
Main function program
Fig 1.9 Structure of a C++ program
This approach is based on the concept of client-server model as shown in fig. 1.10. The
class definition including the member functions constitute the server that provides
services to the main program known as client. The client uses the server through the
public interface of the class.
Fig. 1.10 The client-server model
Server
Class Definition
Member Function
Client
Main function Program
1.14 Creating the Source File
Like C programs can be created using any text editor. Foe example, on the UNIX, we can
use vi or ed text editor for creating using any text editor for creating and editing the
source code. On the DOS system, we can use endlin or any other editor available or a
word processor system under non-document mode.
Some systems such as Turboc C++ provide an integrated environment for developing
and editing programs
The file name should have a proper file extension to indicate that it is a C++
implementations use extensions such as .c,.C, .cc, .cpp and .cxx. Turboc C++ and
Borland C++ use .c for C programs and .cpp(C plus plus) for C++ programs. Zortech
C++ system use .cxx while UNIX AT&T version uses .C (capital C) and .cc. The
operating system manuals should be consulted to determine the proper file name
extension to be used.
1.15 Compiling and Linking
The process of compiling and linking again depends upon the operating system. A few
popular systems are discussed in this section.
Unix AT&T C++
This process of implementation of a C++ program under UNIX is similar to that of a C
program. We should use the “cc” (uppercase) command to compile the program.
Remember, we use lowercase “cc” for compiling C programs. The command
CC example.C
At the UNIX prompt would compile the C++ program source code contained in the file
example.C. The compiler would produce an object file example.o and then automatically
link with the library functions to produce an executable file. The default executable
filename is a. out.
A program spread over multiple files can be compiled as follows:
CC file1.C file2.o
The statement compiles only the file file1.C and links it with the previously compiled
file2.o file. This is useful when only one of the files needs to be modified. The files that
are not modified need not be compiled again.
Turbo C++ and Borland C++
Turbo C++ and Borland C++ provide an integrated program development environment
under MS DOS. They provide a built-in editor and a menu bar includes options such as
File, Edit, Compile and Run.
We can create and save the source files under the File option, and edit them under the
Edit option. We can then compile the program under the compile option and execute it
under the Run option. The Run option can be used without compiling the source code.
Summary
• Software technology has evolved through a series of phases during the last five
decades.
• POP follows top-down approach where problem is viewed as sequence of task to
be performed and functions are written for implementing these tasks.
• POP has two major drawbacks:
• Data can move freely around the program.
• It does not model very well the real-world problems.
• OOP was inventing to overcome the drawbacks of POP. It follows down -up
approach.
• In OOP, problem is considered as a collection of objects and objects are instance
of classes.
• Data abstraction refers to putting together essential features without including
background details.
• Inheritance is the process by which objects of one class acquire properties of
objects of another class.
• Polymorphism means one name, multiple forms. It allows us to have more than
one function with the same name in a program.
• Dynamic binding means that the code associated with a given procedure is not
known until the time of the run time.
• Message passing involves specifying the name of the object, the name of the
function and the information to be sent.
• C++ is a superset of C language.
• C++ ads a number of features such as objects, inheritance, function overloading
and operator overloading to C.
• C++ supports interactive input and output features and introduces anew comment
symbol // that can be used for single line comment.
• Like C programs, execution of all C++ program begins at main() function.
Keywords:
• Assembly Language
• Bottom up Programming
• C++
• Classes
• Data Abstraction
• Data Encapsulation
• Data Hiding
• Data Member
• Dynamic Binding
• Early Binding
• Function overloading
• Functions
• Global Data
• Hierarchical Classification
• Inheritance
• Late Binding
• #include
• Main( )
• Local data
• Machine Language
• Member Function
• Message Passing
• Methods
• Modular Programming
• Multiple Inheritances
• Object Based Programming
• Objective C
• Object Oriented Language
• Object Oriented Programming
• Objects
• Operator Overloading
• Polymorphism
• Procedure Oriented Programming
• Reusability
• Top down Programming
• Extraction Operator
• Cascading
• Namespace
• Class
• Object
• Operator overloading
• Comments
• Output operator
• cout
• edlin
• return ()
• Float
• Get from Operator
• Input operator
• Turbo c++
• iostream
• int
• using
• iostream.h
• windows
• Keyboard
Questions
1. What are the major issues facing the software industry today?
2. What is POP? Discuss its features.
3. Describe how data are shared by functions in procedure-oriented programs?
4. What is OOP? What are the difference between POP and OOP?
5. How are data and functions organized in an object-oriented program?
6. What are the unique advantages of an object-oriented programming paradigm?
7. Distinguish between the following terms:
(a) Object and classes
(b) Data abstraction and data encapsulation
(c) Inheritance and polymorphism
(d) Dynamic binding and message passing
8. Describe inheritance as applied to OOP.
9. What do you mean by dynamic binding? How it is useful in OOP?
10. What is the use of preprocessor directive #include<iostream>?
11. How does a main () function in c++ differ from main () in c?
12. Describe the major parts of a c++ program.
13. Write a program to read two numbers from the keyboard and display the larger
value on the screen.
14. Write a program to input an integer value from keyboard and display on screen
“WELL DONE” that many times.
References:
1. Object –Oriented –Programming in C++ by E Balagurusamy.
2. Object –Oriented –Programming with ANSI & Turbo C++ by Ashok N. Kamthane.
3. OO Programming in C++ by Robert Lafore, Galgotia Publications Pvt. Ltd.
4. Mastering C++ By K R Venugopal, Rajkumar Buyya, T Ravishankar.
5. Object Oriented Programming and C++ By R. Rajaram.
6. Object –Oriented –Programming in C++ by Robert Lafore.

-------------------------------------------------------------------------------------------------------------------
Subject: Object Oriented Programming using C++
Paper Code: MCA-302 Author: Mr. Ganesh Kumar
Lesson: Function in c++ &Object and classes Vetter: Dr. Pradeep Bhatia
Lesson No. : 2
-------------------------------------------------------------------------------------------------------------------
STRUCTURE
2.1 Introduction
4.2 Function Definition and Declaration
4.3 Arguments to a Function
4.3.1 Passing Arguments to a Function
4.3.2 Default Arguments
4.3.3 Constant Arguments
4.4 Calling Functions
4.5 Inline Functions
4.6 Scope Rules of Functions and Variables
4.7 Definition and Declaration of a Class
4.8 Member Function Definition
4.8.1 Inside Class Definition
4.8.2 Outside Class Definition Using Scope Resolution Operator (::)
4.9 Declaration of Objects as Instances of a Class
4.10 Accessing Members From Object(S)
4.11 Static Class Members
4.11.1 Static Data Member
4.11.2 Static Member Function
4.12 Friend Classes
4.13 Summary
4.14 Keywords
4.15 Review Questions
4.16 Further Readings
4.1 INTRODUCTION
Functions are the building blocks of C++ programs where all the program activity
occurs. Function is a collection of declarations and statements.
Need for a Function
Monolethic program (a large single list of instructions) becomes difficult to
understand. For this reason functions are used. A function has a clearly defined objective
(purpose) and a clearly defined interface with other functions in the program. Reduction in
program size is another reason for using functions. The functions code is stored in only one
place in memory, even though it may be executed as many times as a user needs.
The following program illustrates the use of a function :
//to display general message using function
#include<iostream.h>
include<conio.h>
void main()
{
void disp(); //function prototype
clrscr(); //clears the screen
disp(); //function call
getch(); //freeze the monitor
}
//function definition
void disp()
{
cout<<”Welcome to the GJU of S&T\n”;
cout<<”Programming is nothing but logic implementation”;
}
PROGRAM 4.1
In this Unit, we will also discuss Class, as important Data Structure of C++. A
Class is the backbone of Object-Oriented Computing. It is an abstract data type.
We can declare and define data as well as functions in a class. An object is a
replica of the class to the exception that it has its own name. A class is a data
type and an object is a variable of that type. Classes and objects are the most
important features of C++. The class implements OOP features and ties them together.
4.2 FUNCTION DEFINITION AND DECLARATION
In C++, a function must be defined prior to it’s use in the program. The function definition
contains the code for the function. The function definition for display_message () in program 6.1
is given below the main () function. The general syntax of a function definition in C++ is shown
below:
Type name_of_the_function (argument list)
{
//body of the function
}
Here, the type specifies the type of the value to be returned by the function. It may be
any valid C++ data type. When no type is given, then the compiler returns an integer value from
the function.
Name_of_the_function is a valid C++ identifier (no reserved word allowed) defined by
the user and it can be used by other functions for calling this function.
Argument list is a comma separated list of variables of a function through which the
function may receive data or send data when called from other function. When no parameters,
the argument list is empty as you have already seen in program 6.1. The following function
illustrates the concept of function definition :
//function definition add()
void add()
{
int a,b,sum;
cout<<”Enter two integers”<<endl;
cin>>a>>b;
sum=a+b;
cout<<”\nThe sum of two numbers is “<<sum<<endl;
}
The above function add ( ) can also be coded with the help of arguments of
parameters as shown below:
//function definition add()
void add(int a, int b) //variable names are must in definition
{
int sum;
sum=a+b;
cout<<”\nThe sum of two numbers is “<<sum<<endl;
}
4.3 ARGUMENTS TO A FUNCTION
Arguments(s) of a function is (are) the data that the function receives when
called/invoked from another function.
4.3.1 PASSING ARGUMENTS TO A FUNCTION
It is not always necessary for a function to have arguments or parameters. The
functions add ( ) and divide ( ) in program 6.3 did not contain any arguments. The following
example illustrates the concept of passing arguments to function SUMFUN ( ):
// demonstration of passing arguments to a function
#include<iostream.h>
void main ()
{
float x,result; //local variables
int N;
formal parameters
Semicolon here
float SUMFUN(float x, int N); //function declaration
return type
………………………….
………………………….
result = SUMFUN(X,N); //function declaration
}
//function SUMFUN() definition
No semicolon here
float SUMFUN(float x,int N) //function declaration
{
………………………….
…………………………. Body of the function
………………………….
}
No semicolon here
4.3.2 DEFAULT ARGUMENTS
C++ allows a function to assign a parameter the default value in case
no argument for that parameter is specified in the function call. For example.
// demonstrate default arguments function
#include<iostream.h>
int calc(int U)
{
If (U % 2 = = 0)
return U+10;
Else
return U+2
}
Void pattern (char M, int B=2)
{
for (int CNT=0;CNT<B; CNT++)
cout<calc(CNT) <<M;
cout<<endl;
}
Void main ()
{
Pattern(‘*’);
Pattern (‘#’,4)’
Pattern (;@;,3);
}
4.3.3 CONSTANT ARGUMENTS
A C++ function may have constant arguments(s). These arguments(s) is/are treated
as constant(s). These values cannot be modified by the function.
For making the arguments(s) constant to a function, we should use the keyword const
as given below in the function prototype :
Void max(const float x, const float y, const float z);
Here, the qualifier const informs the compiler that the arguments(s) having
const should not be modified by the function max (). These are quite useful when call by
reference method is used for passing arguments.
4.4 CALLING FUNCTIONS
In C++ programs, functions with arguments can be invoked by :
(a) Value
(b) Reference
Call by Value: - In this method the values of the actual parameters (appearing in the
function call) are copied into the formal parameters (appearing in the function definition), i.e., the
function creates its own copy of argument values and operates on them. The following program
illustrates this concept :
//calculation of compound interest using a function
#include<iostream.h>
#include<conio.h>
#include<math.h> //for pow()function
Void main()
{
Float principal, rate, time; //local variables
Void calculate (float, float, float); //function prototype
clrscr();
Cout<<”\nEnter the following values:\n”;
Cout<<”\nPrincipal:”;
Cin>>principal;
Cout<<”\nRate of interest:”;
Cin>>rate;
Cout<<”\nTime period (in yeaers) :”;
Cin>>time;
Calculate (principal, rate, time); //function call
Getch ();
}
//function definition calculate()
Void calculate (float p, float r, float t)
{
Float interest; //local variable
Interest = p* (pow((1+r/100.0),t))-p;
Cout<<”\nCompound interest is : “<<interest;
}
Call by Reference: - A reference provides an alias – an alternate name – for the
variable, i.e., the same variable’s value can be used by two different names : the original name
and the alias name.
In call by reference method, a reference to the actual arguments(s) in the calling program is
passed (only variables). So the called function does not create its own copy of original value(s)
but works with the original value(s) with different name. Any change in the original data in the
called function gets reflected back to the calling function.
It is useful when you want to change the original variables in the calling function by the called
function.
//Swapping of two numbers using function call by reference
#include<iostream.h>
#include<conio.h>
void main()
{
clrscr();
int num1,num2;
void swap (int &, int &); //function prototype
cin>>num1>>num2;
cout<<”\nBefore swapping:\nNum1: “<<num1;
cout<<endl<<”num2: “<<num2;
swap(num1,num2); //function call
cout<<”\n\nAfter swapping : \Num1: “<<num1;
cout<<endl<<”num2: “<<num2;
getch();
}
//function fefinition swap()
void swap (int & a, int & b)
{
Int temp=a;
a=b;
b=temp;
}
4.5 INLINE FUNCTIONS
These are the functions designed to speed up program execution. An inline function is
expanded (i.e. the function code is replaced when a call to the inline function is made) in the line
where it is invoked. You are familiar with the fact that in case of normal functions, the compiler
have to jump to another location for the execution of the function and then the control is
returned back to the instruction immediately after the function call statement. So execution time
taken is more in case of normal functions. There is a memory penalty in the case of an inline
function.
The system of inline function is as follows :
inline function_header
{
body of the function
}
For example,
//function definition min()
inline void min (int x, int y)
cout<< (x < Y? x : y);
}
Void main()
{
int num1, num2;
cout<<”\Enter the two intergers\n”;
cin>>num1>>num2;
min (num1,num2; //function code inserted here
------------------
------------------
}
An inline function definition must be defined before being invoked as shown in the above
example. Here min ( ) being inline will not be called during execution, but its code would be
inserted into main ( ) as shown and then it would be compiled.
If the size of the inline function is large then heavy memory pentaly makes it not so
useful and in that case normal function use is more useful.
The inlining does not work for the following situations :
1. For functions returning values and having a loop or a switch or a goto
statement.
2. For functions that do not return value and having a return statement.
3. For functions having static variable(s).
4. If the inline functions are recursive (i.e. a function defined in terms of itself).
The benefits of inline functions are as follows :
1. Better than a macro.
2. Function call overheads are eliminated.
3. Program becomes more readable.
4. Program executes more efficiently.
4.6 SCOPE RULES OF FUNCTIONS AND VARIABLES
The scope of an identifier is that part of the C++ program in which it is accessible.
Generally, users understand that the name of an identifier must be unique. It does not mean
that a name can’t be reused. We can reuse the name in a program provided that there is some
scope by which it can be distinguished between different cases or instances.
In C++ there are four kinds of scope as given below :
1. Local Scope
2. Function Scope
3. File Scope
4. Class Scope
Local Scope:- A block in C++ is enclosed by a pair of curly braces i.e., ‘{‘ and ‘}’. The
variables declared within the body of the block are called local variables and can be used only
within the block. These come into existence when the control enters the block and get destroyed
when the control leaves the closing brace. You should note the variable(s) is/are available to all
the enclosed blocks within a block.
For example,
int x=100;
{ cout<<x<<endl;
Int x=200;
{
cout<<x<<endl;
int x=300;
{
cout<<x<<endl;
}
}
cout<<x<<endl;
}
Function Scope : It pertains to the labels declared in a function i.e., a label can be used
inside the function in which it is declared. So we can use the same name labels in different
functions.
For example,
//function definition add1()
void add1(int x,int y,int z)
{
int sum = 0;
sum = x+y+z;
cout<<sum;
}
//function definition add2()
coid add2(float x,float y,float z)
{
Float sum = 0.0;
sum = x+y+z;
cout<<sum;
}
Here the labels x, y, z and sum in two different functions add1 ( ) and add2 ( ) are
declared and used locally.
File Scope : If the declaration of an identifier appears outside all functions, it is available to all
the functions in the program and its scope becomes file scope. For Example,
int x;
void square (int n)
{
cout<<n*n;
}
void main ()
{
int num;
…………...........
cout<<x<<endl;
cin>>num;
squaer(num);
…………...........
}
Here the declarations of variable x and function square ( ) are outside all the functions
so these can be accessed from any place inside the program. Such variables/functions are
called global.
Class Scope : In C++, every class maintains its won associated scope. The class members are
said to have local scope within the class. If the name of a variable is reused by a class member,
which already has a file scope, then the variable will be hidden inside the class. Member
functions also have class scope.
4.7 DEFINITION AND DECLARATION OF A CLASS
A class in C++ combines related data and functions together. It makes a data type
which is used for creating objects of this type.
Classes represent real world entities that have both data type properties
(characteristics) and associated operations (behavior).
The syntax of a class definition is shown below :
Class name_of _class
{
private : variable declaration; // data member
Function declaration; // Member Function (Method)
protected: Variable declaration;
Function declaration;
public : variable declaration;
Function declaration;
};
Here, the keyword class specifies that we are using a new data type and is followed by the class
name.
The body of the class has two keywords namely :
(i) private (ii) public
In C++, the keywords private and public are called access specifiers. The data
hiding concept in C++ is achieved by using the keyword private. Private data and functions can
only be accessed from within the class itself. Public data and functions are accessible outside
the class also. This is shown below :
Class
Can only be accessed from
within the class
Can only be accessed from
outside the class
Private
Public
data members
and
member functions
data members
member functions
and
Data hiding not mean the security technique used for protecting computer databases.
The security measure is used to protect unauthorized users from performing any operation
(read/write or modify) on the data.
The data declared under Private section are hidden and safe from accidental
manipulation. Though the user can use the private data but not by accident.
The functions that operate on the data are generally public so that they can be
accessed from outside the class but this is not a rule that we must follow.
4.8 MEMBER FUNCTION DEFINITION
The class specification can be done in two part :
(i) Class definition. It describes both data members and member functions.
(ii) Class method definitions. It describes how certain class member functions
are coded.
We have already seen the class definition syntax as well as an example.
In C++, the member functions can be coded in two ways :
(a) Inside class definition
(b) Outside class definition using scope resolution operator (::)
The code of the function is same in both the cases, but the function header is
different as explained below :
4.8.1 Inside Class Definition:
When a member function is defined inside a class, we do not require to place a
membership label along with the function name. We use only small functions inside the class
definition and such functions are known as inline functions.
In case of inline function the compiler inserts the code of the body of the function at
the place where it is invoked (called) and in doing so the program execution is faster but
memory penalty is there.
4.8.2 Outside Class Definition Using Scope Resolution Operator (::) :
In this case the function’s full name (qualified_name) is written as shown:
Name_of_the_class :: function_name
The syntax for a member function definition outside the class definition is :
return_type name_of_the_class::function_name (argument list)
{
body of function
}
Here the operator::known as scope resolution operator helps in defining the member
function outside the class. Earlier the scope resolution operator(::)was ised om situations where
a global variable exists with the same name as a local variable and it identifies the global
variable.
4.9 DECLARATION OF OBJECTS AS INSTANCES OF A CLASS
The objects of a class are declared after the class definition. One must remember
that a class definition does not define any objects of its type, but it defines the properties of a
class. For utilizing the defined class, we need variables of the class type. For example,
Largest ob1,ob2; //object declaration
will create two objects ob1 and ob2 of largest class type. As mentioned earlier, in
C++ the variables of a class are known as objects. These are declared like a simple variable
i.e., like fundamental data types.
In C++, all the member functions of a class are created and stored when the class is
defined and this memory space can be accessed by all the objects related to that class.
Memory space is allocated separately to each object for their data members. Member
variables store different values for different objects of a class.
The figure shows this concept
A class, its member functions and objects in memory.
Object 1 Object 2
Memory allocated when
objects declared
data member 2
data member 1
data member
data member
Member
f ti 1
Memory allocated when
member functions are defined
Common for all objects
Member Member function3
f ti 2
4.10 ACCESSING MEMBERS FROM OBJECT(S)
After defining a class and creating a class variable i.e., object we can access the data
members and member functions of the class. Because the data members and member
functions are parts of the class, we must access these using the variables we created. For
functions are parts of the class, we must access these using the variable we created. For
Example,
Class student
{
private:
char reg_no[10];
` char name[30];
int age;
char address[25];
public :
void init_data()
{
- - - - - //body of function
- - - - -
}
void display_data()
}
};
student ob; //class variable (object) created
- - - - -
- - - - -
Ob.init_data(); //Access the member function
ob.display_data(); //Access the member function
- - - - -
- - - - -
Here, the data members can be accessed in the member functions as these have private
scope, and the member functions can be accessed outside the class i.e., before or after the
main() function.
4.11 STATIC CLASS MEMBERS
Data members and member functions of a class in C++, may be qualified as static.
We can have static data members and static member function in a class.
4.11.1 Static Data Member: It is generally used to store value common to
the whole class. The static data member differs from an ordinary data member in the following
ways :
(i) Only a single copy of the static data member is used by all the objects.
(ii) It can be used within the class but its lifetime is the whole program.
For making a data me