1

SRINIVAS UNIVERSITY
COLLEGE OF ALLIED HEALTH SCIENCE
DEPARTMENT OF CYBER FORENSIC
SUBJECT: PROGRAMMING LANGUAGE C++
STUDY MATERIAL
 2

UNIT 3
Object Oriented Programing

“Object oriented programming as an approach that provides a way of modularizing programs by

creating partitioned memory area for both data and functions that can be used as templates for
creating copies of such modules on demand”.

Object A Object B

Data Data

Communication
Functions Functions

Object C

Functions

Data

Features of the Object Oriented programming

1. Emphasis is on doing rather than procedure.

2. programs are divided into what are known as objects.
3. Data structures are designed such that they characterize the objects.
4. Functions that operate on the data of an object are tied together in the data
structure.
5. Data is hidden and can’t be accessed by external functions.
6. Objects may communicate with each other through functions.
7. New data and functions can be easily added.
8. Follows bottom-up approach in program design.
 3

BASIC CONCEPTS OF OBJECTS ORIENTED PROGRAMMING

1. Objects
2. Classes
3. Data abstraction and encapsulation
4. Inheritance
5. Polymorphism
6. Dynamic binding
7. Message passing

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 must handle.

The fundamental idea behind object oriented approach is to combine both data and function
into a single unit and these units are called objects.

The term objects means a combination of data and program that represent some real word
entity. For example: consider an example named Amit; Amit is 25 years old and his salary is 2500.
The Amit may be represented in a computer program as an object. The data part of the object would
be (name: Amit, age: 25, salary: 2500)

The program part of the object may be collection of programs (retrive of data, change age,
change of salary). In general even any user –defined type-such as employee may be used. In the
Amit object the name, age and salary are called attributes of the object.

STUDENT
Object: Student
T otal
DATA
Name
Date-of-birth
Marks Av erage

FUNCTIONS
Total
Average D isplay
Display
CLASS:

A group of objects that share common properties for data part and some program part are
collectively called as class.

In C ++ a class is a new data type that contains member variables and member functions that
operate on the variables.
 4

DATA ABSTRACTION :

Abstraction refers to the act of representing essential features without including the back
ground details or explanations. Classes use the concept of abstraction and are defined as size, width
and cost and functions to operate on the attributes.

DATA ENCAPSALATION :

The wrapping up of data and function into a single unit (called class) is known as
encapsulation. 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 objects data and
the program.

INHERITENCE :

Inheritance is the process by which objects of one class acquire the properties of another
class. In the concept of inheritance provides the idea of reusablity. This mean that we can add
additional features to an existing class with out modifying it. This is possible by desining a new class
will have the combined features of both the classes.

POLYMORPHISIM:

Polymorphism means the ability to take more than one form. An operation may exhibit different
instance. The behaviour depends upon the type of data used in the operation.

A language feature that allows a function or operator to be given more than one definition. The types
of the arguments with which the function or operator is called determines which definition will be
used.

Overloading may be operator overloading or function overloading.

It is able to express the operation of addition by a single operater say ‘+’. When this is possible you
use the expression x + y to denote the sum of x and y, for many different types of x and y; integers ,
float and complex no. You can even define the + operation for two strings to mean the concatenation
of the strings.

DYNAMIC BINDING :

Binding refers to the linking of a procedure call to the code to the executed in
response to the call. Dynamic binding means the code associated with a given procedure call is not
known untill the time of the call at run-time. It is associated with a polymorphic reference depends
upon the dynamic type of that reference.
 5

MESSAGE PASSING :

An object oriented program consists of a set of objects that communicate with each
other.

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 result. Message
passing involves specifying the name of the object, the name of the function (message) and
information to be sent.

Employee . Salary (name)

Object Information
Message
 6

BENEFITS OF OOP:

Oop offers several benefits to both the program designer and the user. Object-oriented contributes to
the solution of many problems associated with the development and quality of software products.
The principal advantages are :

1. Through inheritance we can eliminate redundant code and extend the use of existing
classes.
2. 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.
3. This principle of data hiding helps the programmer to build secure programs that can’t be
invaded by code in other parts of the program.
4. It is possible to have multiple instances of an object to co-exist with out any interference.
5. It is easy to partition the work in a project based on objects.
6. Object-oriented systems can be easily upgraded from small to large systems.
7. Message passing techniques for communication between objects makes the interface
description with external systems much simpler.
8. Software complexity can be easily managed.

APPLICATION OF OOP:

The most popular application of oops up to now, has been in the area of user interface
design such as windows. There are hundreds of windowing systems developed using oop
techniques.

Real business systems are often much more complex and contain many more objects
with complicated attributes and methods. Oop is useful in this type of applications because it
can simplify a complex problem. The promising areas for application of oop includes.

1. Real – Time systems.

2. Simulation and modeling
3. Object oriented databases.
4. Hypertext,hypermedia and expertext.
5. Al and expert systems.
6. Neural networks and parallel programming.
7. Dicision support and office automation systems.
8. CIM / CAM / CAD system.
 7

Basics of C++

C ++ is an object oriented programming language, C ++ was developed by Jarney

Stroustrup at AT & T Bell lab, USA in early eighties. C ++ was developed from c and simula 67
language. C ++ was early called ‘C with classes’.

C++ Comments:

C++ introduces a new comment symbol //(double slash). Comments start with a
double slash symbol and terminate at the end of line. A comment may start any where in the line and
what ever follows till the end of line is ignored. Note that there is no closing symbol.
The double slash comment is basically a single line comment. Multi line comments can be
written as follows:

// this is an example of
// c++ program
// thank you
The c comment symbols /* ….*/ are still valid and more suitable for multi line comments.

/* this is an example of c++ program */

Output Operator:

The statement cout <<”Hello, world” displayed the string with in quotes on the screen. The identifier
cout can be used to display individual characters, strings and even numbers. It is a predefined object
that corresponds to the standard output stream. Stream just refers to a flow of data and the standard
Output stream normally flows to the screen display. The cout object, whose properties are defined in
iostream.h represents that stream. The insertion operator << also called the ‘put to’ operator directs
the information on its right to the object on its left.

Return Statement:

In C++ main ( ) returns an integer type value to the operating system. Therefore every main (
) in C++ should end with a return (0) statement, otherwise a warning or an error might occur.

Input Operator:

The statement
cin>> number
1;
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 is a predefined object in C++ that
corresponds to the standard input stream. Here this stream represents the key board.

The operator >> is known as get from operator. It extracts value from the keyboard
and assigns it to the variable on its right.
 8

Cascading Of I/O Operator:

cout<<”sum=”<<sum<<”\n”; cout<<”sum=”<<sum<<”\
n”<<”average=”<<average<<”\n”;
cin>>number1>>number2;

Structure Of A Program :

Probably the best way to start learning a programming language is by writing a program. Therefore,
here is our first program:
// my first program in C++

#include <iostream>
using namespace std;

int main ()
{
cout << "Hello World!";
return 0;
}
Output:-Hello World!
The first panel shows the source code for our first program. The second one shows the result of the
program once compiled and executed. The way to edit and compile a program depends on the
compiler you are using. Depending on whether it has a Development Interface or not and on its
version. Consult the compilers section and the manual or help included with your compiler if you
have doubts on how to compile a C++ console program.
The previous program is the typical program that programmer apprentices write for the first time,
and its result is the printing on screen of the "Hello World!" sentence. It is one of the simplest
programs that can be written in C++, but it already contains the fundamental components that every
C++ program has. We are going to look line by line at the code we have just written:
// my first program in C++
This is a comment line. All lines beginning with two slash signs (//) are considered comments and do
not have any effect on the behavior of the program. The programmer can use them to include short
explanations or observations within the source code itself. In this case, the line is a brief description
of what our program is.
#include <iostream>
Lines beginning with a hash sign (#) are directives for the preprocessor. They are not regular code
lines with expressions but indications for the compiler's preprocessor. In this case the directive
#include<iostream> tells the preprocessor to include the iostream standard file. This specific file
(iostream) includes the declarations of the basic standard input-output library in C++, and it is
included because its functionality is going to be used later in the program.
using namespace std;
All the elements of the standard C++ library are declared within what is called a namespace, the
namespace with the name std. So in order to access its functionality we declare with this expression
that we will be using these entities. This line is very frequent in C++ programs that use the standard
library, and in fact it will be included in most of the source codes included in these tutorials.
int main ()
This line corresponds to the beginning of the definition of the main function. The main function is
the point by where all C++ programs start their execution, independently of its location within the
source code. It does not matter whether there are other functions with other names defined before or
after it – the instructions contained within this function's definition will always be the first ones to be
 9

executed in any C++ program. For that same reason, it is essential that all C++ programs have a main
function.
The word main is followed in the code by a pair of parentheses (()). That is because it is a function
declaration: In C++, what differentiates a function declaration from other types of expressions are
these parentheses that follow its name. Optionally, these parentheses may enclose a list of parameters
within them.
Right after these parentheses we can find the body of the main function enclosed in braces ({}).
What is contained within these braces is what the function does when it is executed.
cout << "Hello World!";
This line is a C++ statement. A statement is a simple or compound expression that can actually
produce some effect. In fact, this statement performs the only action that generates a visible effect in
our first program.
cout represents the standard output stream in C++, and the meaning of the entire statement is to
insert a sequence of characters (in this case the Hello World sequence of characters) into the standard
output stream (which usually is the screen).
cout is declared in the iostream standard file within the std namespace, so that's why we needed to
include that specific file and to declare that we were going to use this specific namespace earlier in
our code.
Notice that the statement ends with a semicolon character (;). This character is used to mark the end
of the statement and in fact it must be included at the end of all expression statements in all C++
programs (one of the most common syntax errors is indeed to forget to include some semicolon after
a statement).
return 0;
The return statement causes the main function to finish. return may be followed by a return code (in
our example is followed by the return code 0). A return code of 0 for the main function is generally
interpreted as the program worked as expected without any errors during its execution. This is the
most usual way to end a C++ console program.
You may have noticed that not all the lines of this program perform actions when the code is
executed. There were lines containing only comments (those beginning by //). There were lines with
directives for the compiler's preprocessor (those beginning by #). Then there were lines that began
the declaration of a function (in this case, the main function) and, finally lines with statements (like
the insertion into cout), which were all included within the block delimited by the braces ({}) of the
main function.
The program has been structured in different lines in order to be more readable, but in C++, we do
not have strict rules on how to separate instructions in different lines. For example, instead of
int main ()
{
cout << " Hello World!";
return 0;
}

We could have written:

int main ()
{
cout << "Hello World!";
return 0;
}
All in just one line and this would have had exactly the same meaning as the previous code.
In C++, the separation between statements is specified with an ending semicolon (;) at the end of
each one, so the separation in different code lines does not matter at all for this purpose. We can
write many statements per line or write a single statement that takes many code lines. The division of
 10

code in different lines serves only to make it more legible and schematic for the humans that may
read it.

Let us add an additional instruction to our first program:

// my second program in C++
#include <iostream>
using namespace std;

int main ()
{
cout << "Hello World! ";
cout << "I'm a C++ program";
return 0;
}

Output:-Hello World! I'm a C++ program

In this case, we performed two insertions into cout in two different statements. Once again, the
separation in different lines of code has been done just to give greater readability to the program,
since main could have been perfectly valid defined this way:
int main ()
{
cout << " Hello World! ";
cout << " I'm a C++ program ";
return 0;
}

We were also free to divide the code into more lines if we considered it more convenient:
int main ()
{
cout << "Hello World!";
cout << "I'm a C++
program"; return 0;
}
And the result would again have been exactly the same as in the previous examples.
Preprocessor directives (those that begin by #) are out of this general rule since they are not
statements. They are lines read and processed by the preprocessor and do not produce any code by
themselves. Preprocessor directives must be specified in their own line and do not have to end with a
semicolon (;).

STRUCTURE OF C++ PROGRAM

 Include files
 Class declaration
 Class functions, definition
 Main function

program Example :-

# include<iostream.h>

class person
 11

{
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 display()
{
cout<<”\n name:”<<name;
cout<<”\n age:”<<age;
}

int main( )
{

person p;
p.getdata();
p.display();
return(0);

}
 12

TOKENS:

The smallest individual units in program are known as tokens. C++ has the following
tokens.

i. Keywords
ii. Identifiers
iii. Constants
iv. Strings
v. Operators

KEYWORDS:

The keywords implement specific C++ language feature. They are explicitly reserved
identifiers and can’t be used as names for the program variables or other user defined program
elements. The keywords not found in ANSI C are shown in red letter.

C++ KEYWORDS:

Asm double New switch

Auto else operator template

Break enum private this

Case extern protected throw

Catch float public try

Char for register typedef

Class friend return union

Const goto short unsigned

Continue if signed virtual

Default inline sizeof void

Delete long struet while

IDENTIFIERS:

Identifiers refers to the name of variable , functions, array, class etc. created by programmer. Each
language has its own rule for naming the identifiers.

The following rules are common for both C and C++.

 13

1. Only alphabetic chars, digits and under score are permitted.

2. The name can’t start with a digit.
3. Upper case and lower case letters are distinct.
4. A declared keyword can’t be used as a variable name.

In ANSI C the maximum length of a variable is 32 chars but in c++ there is no bar.
 14

BASIC DATA TYPES IN C++

C ++ Data Types

User defined type Built in types Derived type

Structure Array
Union Class Functi
enumeration
Integral type on point
Floating
void pointer

float
int char double

Both C and C++ compilers support all the built in types. With the exception of void the basic
datatypes may have several modifiers preceding them to serve the needs of various situations. The
modifiers signed, unsigned, long and short may applied to character and integer basic data types.
However the modifier long may also be applied to double.

Data types in C++ can be classified under various categories.

TYPE BYTES RANGE

Char 1 -128 to – 127

Usigned 1 0 to 265

sgned char 1 -128 to 127

Int 2 -32768 to 32768

unsigned int 2 0 to 65535

singed int 2 -32768 to 32768

short int 2 -32768 to 32768

 15

long int 4 -2147483648 to 2147483648

signed long int 4 -2147483648 to 2147483648

unsigned long int 4 0 to 4294967295

float 4 3.4E-38 to 3.4E+38

double 8 1.7E -308 to 1.7E +308

long double 10 3.4E-4932 to 1.1E+ 4932

The type void normally used for:

1) To specify the return type of function when it is not returning any value.
2) To indicate an empty argument list to a function.

Example:

Void function(void);

Another interesting use of void is in the declaration of genetic pointer

Example:

Void *gp;

Assigning any pointer type to a void pointer without using a cast is allowed in both C and ANSI C.
In ANSI C we can also assign a void pointer to a non-void pointer without using a cast to non void
pointer type. This is not allowed in C ++.

Example:

void *ptr1;

void *ptr2;

Are valid statement in ANSI C but not in C++. We need to use a cast operator.

ptr2=(char * ) ptr1;

USER DEFINED DATA TYPES:

STRUCTERS AND CLASSES

We have used user defined data types such as struct,and union in C. While these more features have
been added to make them suitable for object oriented programming. C++ also permits us to define
16
 17

another user defined data type known as class which can be used just like any other basic data type to
declare a variable. The class variables are known as objects, which are the central focus of oops.

ENUMERATED DATA TYPE:

An enumerated data type is another user defined type which provides a way for
attaching names to number, these by increasing comprehensibility of the code. The enum keyword
automatically enumerates a list of words by assigning them values 0,1,2 and soon. This facility
provides an alternative means for creating symbolic.

Example:

enum shape {

circle,square,triangle} enum

colour{red,blue,green,yellow} enum

position {off,on}

The enumerated data types differ slightly in C++ when compared with ANSI C. In C++, the
tag names shape, colour, and position become new type names. That means we can declare new
variables using the tag names.

Example:

Shape ellipse;//ellipse is of type shape

colour background ; // back ground is of type colour

ANSI C defines the types of enums to be ints. In C++,each enumerated data type retains its
own separate type. This means that C++ does not allow an int value to be automatically converted to
an enum.

Example:

colour background =blue; //vaid

colour background =7; //error in c+

+ colour background =(colour)

7;//ok

How ever an enumerated value can be used in place of an int value.

Example:

int c=red ;//valid, colour type promoted to int

By default, the enumerators are assigned integer values starting with 0 for the first
enumerator, 1 for the second and so on. We can also write
 18

enum color {red,

blue=4,green=8}; enum color

{red=5,blue,green};
 19

C++ also permits the creation of anonymous enums ( i.e, enums without tag names)

Example:

enum{off,on};

Here off is 0 and on is 1.these constants may be referenced in the same manner as regular constants.

Example:

int switch-1=off;

int switch-2=on;

ANSI C permits an enum defined with in a structure or a class, but the enum is
globally visible. In C++ an enum defined with in a class is local to that class.

SCOPE RESOLUTION OPERATOR:

Like C,C++ is also a block-structured language. Block -structured language. Blocks

and scopes can be used in constructing programs. We know same variables can be declared in
different blocks because the variables declared in blocks are local to that function.
Blocks in C++ are often
nested. Example:

{
Int x =10;

Int x=1; Block2

--------------- Block1

}
Block2 contained in block l .Note that declaration in an inner block hides a declaration of the
same variable in an outer block and therefore each declaration of x causes it to refer to a different data object
. With in the inner block the variable x will refer to the data object declared there in.
 20

In C,the global version of a variable can't be accessed from with in the inner block.
C++ resolves this problem by introducing a new operator :: called the scope resolution operator .This can
be used to uncover a hidden variable.

Syntax: : : variable –name;

Example:
#include <iostrcam.h> int
m=10; main()
{
int m=20;
{
int k=m; int m=30;
cout<<”we are in inner block”;
cout<<"k="<<k<<endl;
cout<<"m="<<m<<endl; cout<<"::
m="<<:: m<<endl;
}
cout<<”\n we are in outer block \n”;
cout<<"m="<<m<<endl; cout<<"::
m="<<:: m<<endl;
}
 21

UNIT 4
OPERATORS IN C++ :

C++ has a rich set of operators. All C operators are valid in C++ also. In addition. C++
introduces some new operators.

<< insertion operator

>> extraction operator

:: scope resolution operator

: :* pointer to member declarator

* pointer to member operator

.* pointer to member operator

Delete memory release operator

Endl line feed operator

New memory allocation operator

Setw field width operator

C++ Type Cast Operator

C++ provides us a type-cast operator which allows us to explicit cast the value of an arithmetic expression to
get the precise result by avoiding the data loss. Before we understand what exactly a type-cast operator is
about, we need to understand some important arithmetic expressions rules in C++ language-

 The result of an arithmetic operation between two or more primitive integral(non-decimal) data-type always

results in an integral data-type value.

 The result of an arithmetic operation between two or more primitive floating data-type always results in

a floating data-type value.

 The result of an arithmetic operation between a primitive integral data-type and a floating primitive data-

type always results in a floating data-type value.

To understand the rules we have just explained, let us see an example.

#include<iostream>

using namespace std;

int main()
{
int a = 10, b =3;

//An arithmetic expression involving two int variables a and b

float result = a/b;

cout << "The result of dividing 10/3 is : " << div;

 22

Output
The value of dividing 10/3 is : 3

According to the one of the rules we have just explained- "The result of an arithmetic operation between two
or more primitive integral(non-decimal) data-type always results in integral data-type value", hence in the
program above, the result of a division operation involving two int variables a(10) and b(3) has resulted in
an int value i.e. 3, even though we were expecting the correct result to be a decimal value i.e.
a float value, 3.3333.

To avoid the data loss in such scenarios, we need to use the type-cast operator to explicit cast the value of
an expression from one data-type to another data-type.

Type Conversion in C++

A type cast is basically a conversion from one type to another. There are two types of type conversion:
1. Implicit Type Conversion Also known as ‘automatic type conversion’.
 Done by the compiler on its own, without any external trigger from the user.
 Generally takes place when in an expression more than one data type is present. In such condition type
conversion (type promotion) takes place to avoid lose of data.
 All the data types of the variables are upgraded to the data type of the variable with largest data type.
 bool -> char -> short int -> int ->
 unsigned int -> long -> unsigned ->
 long long -> float -> double -> long double
 It is possible for implicit conversions to lose information, signs can be lost (when signed is implicitly
converted to unsigned), and overflow can occur (when long long is implicitly converted to float).
Example of Type Implicit Conversion:
// An example of implicit conversion
  
#include <iostream>
using namespace std;
  
int main()
{
    int x = 10; // integer x
    char y = 'a'; // character c
  
    // y implicitly converted to int. ASCII
    // value of 'a' is 97
    x = x + y;
  
    // x is implicitly converted to float
    float z = x + 1.0;
  
    cout << "x = " << x << endl
         << "y = " << y << endl
         << "z = " << z << endl;
  
    return 0;
}

Output:
x = 107
 23

y = a
z = 108
2. Explicit Type Conversion: This process is also called type casting and it is user-defined. Here the user can
typecast the result to make it of a particular data type.
In C++, it can be done by two ways:
 Converting by assignment: This is done by explicitly defining the required type in front of the expression in
parenthesis. This can be also considered as forceful casting.
Syntax:
(type) expression
where type indicates the data type to which the final result is converted.
Example:
// C++ program to demonstrate
// explicit type casting
 #include <iostream>
using namespace std;
  
int main()
{
    double x = 1.2;
  
    // Explicit conversion from double to int
    int sum = (int)x + 1;
  
    cout << "Sum = " << sum;
  
    return 0;
}

Output:
Sum = 2
Advantages of Type Conversion:
 This is done to take advantage of certain features of type hierarchies or type representations.
 It helps to compute expressions containing variables of different data types.
Operators Precedence in C++
C++Server Side ProgrammingProgramming

Operator precedence determines the grouping of terms in an expression. The associativity of an operator is a
property that determines how operators of the same precedence are grouped in the absence of parentheses.
This affects how an expression is evaluated. Certain operators have higher precedence than others; for
example, the multiplication operator has higher precedence than the addition operator:
For example x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so
it first gets multiplied with 3*2 and then adds into 7.
Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the
bottom. Within an expression, higher precedence operators will be evaluated first.
Category                        Operator                       Associativity
     Postfix            () [] -> . ++ - -  Left to right
       Unary           + - ! ~ ++ - - (type)* & sizeof Right to left
Multiplicative   */%    Left to right  
Additive +-   Left to right
    Shift       << >> Left to right
Relational   < <= > >= Left to right
Equality       == != Left to right
Bitwise AND & Left to right
 24

Category                        Operator                       Associativity

Bitwise XOR ^ Left to right
Bitwise OR | Left to right
Logical AND && Left to right
Logical OR || Left to right
Conditional ?: Right to left
Assignment = += -= *= /= %=>>= <<= &= ^= |= Right to left
         Comma             ,  Left to right

CONTROL STRUCTURES:

Like c,c++, supports all the basic control structures and implements them various control statements.

The if statement:

The if statement is implemented in two forms:

1. simple if statement

2. if… else statement

Simple if statement:

if (condition)

Action;

If.. else statement

If

(condition)

Statment1

Else

Statement2
 25

The switch statement

This is a multiple-branching statement where, based on a condition, the control is transferred to one of the
many possible points;
 26

Switch(expr)

case 1:

action1;

break;

case 2:

action2;

break;

..

..

default:

message

The while

statement: Syn:

While(condition)

Stements

}
 27

The do-while statement:

Syn:

do

Stements

} while(condition);

The for loop:

for(expression1;expression2;expression3)

Statements;

Statements;

}
 28

FUNCTION IN C++ :
The main( ) Functon ;
ANSI does not specify any return type for the main ( ) function which is the starting point for the
execution of a program . The definition of main( ) is :-

main()
{
//main program statements
}

This is property valid because the main () in ANSI C does not return any value. In C++, the main () returns a
value of type int to the operating system. The functions that have a return value should use the return statement
for terminating. The main () function in C++ is therefore defined as follows.

int main( )
{

return(0)
}
Since the return type of functions is int by default, the key word int in the main( ) header is optional.

INLINE FUNCTION:

To eliminate the cost of calls to small functions C++ proposes a new feature called inline function.
An inline function is a function that is expanded inline when it is invoked .That is the compiler
replaces the function call with the corresponding function code.
The inline functions are defined as follows:-

inline function-header
{
function body;
}
Example: inline double cube (double a)
{
return(a*a*a);
}
The above inline function can be invoked by statements
like c=cube(3.0);
d=cube(2.5+1.5);
remember that the inline keyword merely sends a request, not a command to the compliler. The
compiler may ignore this request if the function definition is too long or too complicated and compile
the function as a normal function.
Some of the situations where inline expansion may not work are:
1. For functions returning values if a loop, a switch or a go to exists.
 29

2. for function s not returning values, if a return statement exists.

3. if functions contain static variables.
4. if inline functions are recursive,.
Example:
#include<iostream.h>
#include<stdio.h>
inline float mul(float x, float y)
{
return(x*y);
}
inline double div(double p.double q)
{
return(p/q);
}

main(
)
{ float a=12.345;
float b=9.82;
cout<<mul(a,b)<<endl;
cout<<div (a,b)<<endl;

output:-
121.227898
1.257128
DEFAULT ARGUMENT:-

C++ allows us to call a function with out specifying all its arguments.In such cases, the
function assigns a default value to the parameter which does not have a matching aguments in the
function call.Default values are specified when the function is declared .The compiler looks at the
prototype to see how many arguments a function uses and alerts the program for possible default
values.
Example: float amount (float principle, int period ,float rate=0.15);
The default value is specified in a manner syntactically similar to a variable
initialization .The above prototype declares a default value of 0.15 to the argument rate. A
subsequent function call like
value=amount(5000,7); //one argument missing
passes the value of 5000 to principle and 7 to period and then lets the function, use default value of
0.15 for rate.
The call:- value=amount(5000,5,0.12);
//no missing argument passes an explicite value of 0.12 rate.
One important point to note is that only the trailing arguments can have default values. That is, we
must add default from right to left .We cannot provide a default to a particular argument in the
middle of an argument list.
Example:- int mul(int i, int j=5,int k=10);//illegal
int mul(int i=0,int j,int k=10);//illegal
int mul(int i=5,int j);//illegal
int mul(int i=2,int j=5,int k=10);//illegal
Default arguments are useful in situation whose some arguments always have the some value.
 30

For example,bank interest may retain the same for all customers for a particular period of deposit.
 31

Example:
#include<iostream.h>
#include<stdio.h>
mainQ
{
float amount;
float value(float p,int n,float r=0.15);
void printline(char ch=’*’,int len=40);
printline( );
amount=value(5000.00,5);
cout<<”\n final
value=”<<amount<<endl; printline(‘=’);
//function definitions
float value (float p,int n, float r)
{
float si;
si=(p*n*r)/100;
return(si);
}
void printline (char ch,int len)
{
for(inti=l;i<=len;i++)
cout<<ch<<endl;
}
output:-
****************
final value=10056.71613
===============
Advantage of providing the default arguments are:
1. We can use default arguments to add new parameters to the existing functions.
2. Default argument s can be used to combine similar functions into one.

CONST ARGUMENT:-
In C++, an argument to a function can be declared as unit as const as shown
below.
int strlen(const char *p);
int length(const string
&s);
The qualifier const tells the compiler that the function should not modify the argument .the
compiler will generate an error when this condition is violated .This type of declaration is significant
only when we pass arguments by reference or pointers.
 32

FUNCTION OVERLOADING:

Overloading refers to the use of the same thing for different purposes . C++ also
permits overloading functions .This means that we can use the same function name to creates
functions that perform a variety of different tasks. This is known as function polymorphism in oops.
Using the concepts of function overloading , a family of functions with one function
name but with different argument lists in the functions call .The correct function to be invoked is
determined by checking the number and type of the arguments but not on the function type.
For example an overloaded add() function handles different types of data as shown
below.
//Declaration
int add(int a, int b); //prototype 1
int add (int a, int b, int c); //prototype 2
double add(double x, double y); //prototype 3
double add(double p , double q); //prototype
4

//function call
cout<<add(5,10); //uses prototype 1
cout<<add(15,10.0); //uses prototype 4
cout<<add(12.5,7.5); //uses prototype 3
cout<<add(5,10,15); //uses prototype 2
cout<<add(0.75,5); //uses prototype 5
A function call first matches the prototype having the same no and type of arguments and then calls
the appropriate function for execution.
The function selection invokes the following steps:-

a) The compiler first tries to find an exact match in which the types of actual
arguments are the same and use that function .
b) If an exact match is not found the compiler uses the integral promotions to the actual
arguments such as :
char to int
float to double
to find a
match
c)When either of them tails ,the compiler tries to use the built in conversions to the actual
arguments and them uses the function whose match is unique . If the conversion is possible to have
multiple matches, then the compiler will give error message.
Example:
long square (long n);
double square(double
x);
A function call such as :- square(lO)

Will cause an error because int argument can be converted to either long or
double .There by creating an ambiguous situation as to which version of square( )should be used.
 33

PROGRAM

#include<iostream.h>
int volume(double,int);
double volume( double , int );
double volume(longint ,int ,int);
main( )
{
cout<<volume(10)<<endl;
cout<<volume(10)<<endl; cout<<volume(10)<<endl;
}
int volume( ini s)
{
return (s*s*s); //cube
}
double volume( double r, int h)
{
return(3.1416*r*r*h); //cylinder
}
long volume (longint 1, int b, int h)
{
return(1*b*h); //cylinder
}

output:- 1000
157.2595
112500
 34

CLASS:-
Class is a group of objects that share common properties and relationships .In C++, a class is
a new data type that contains member variables and member functions that operates on the variables.
A class is defined with the keyword class. It allows the data to be hidden, if necessary from external
use. When we defining a class, we are creating a new abstract data type that can be treated like any
other built in data type.
Generally a class specification has two parts:-
a) Class declaration
b) Class function definition
the class declaration describes the type and scope of its members. The class function
definition describes how the class functions are implemented.

Syntax:-
class class-name
{
private:
variable declarations;
function declaration ;
public:
variable declarations;
function declaration;
};
The members that have been declared as private can be accessed only
from with in the class. On the other hand , public members can be accessed from outside the class
also. The data hiding is the key feature of oops. The use of keywords private is optional by default,
the members of a class are private.
The variables declared inside the class are known as data members and the functions
are known as members mid the functions. Only the member functions can have access to the private
data members and private functions. However, the public members can be accessed from the outside
the class. The binding of data and functions together into a single class type variable is referred to as
encapsulation.

Syntax:-
class item
{
int member;
float cost;
public:
void getldata (int a ,float b);
void putdata (void);
The class item contains two data members and two function members, the data
members are private by default while both the functions are public by declaration. The function
getdata() can be used to assign values to the member variables member and cost, and putdata() for
displaying their values . These functions provide the only access to the data members from outside
the class.
 35

CREATING OBJECTS:
Once a class has been declared we can create variables of that type
by using the class name.
Example:
item x;
creates a variables x of type item. In C++, the class variables are known as objects. Therefore
x is called an object of type item.

item x, y ,z also
possible. class item
{

}x ,y ,z;
would create the objects x ,y ,z of type item.

ACCESSING CLASS MEMBER:

The private data of a class can be accessed only through the member functions of that
class. The main() cannot contains statements that the access number and cost directly.
Syntax:
object name.function-name(actual
arguments); Example:- x. getdata(100,75.5);
It assigns value 100 to number, and 75.5 to cost of the object x by
implementing the getdata() function .
similarly the statement
x. putdata ( ); //would display the values of data members.
x. number = 100 is illegal .Although x is an object of the type item to which number belongs ,
the number can be accessed only through a member function and not by the object directly.
Example:
class xyz
{
Int x;
Int y;
public
: int z;

};

xyz p;
p. x =0; error . x is private
p, z=10; ok ,z is public
 36

DEFINING MEMBER FUNCTION:

Member can be defined in two places
• Outside the class definition
• Inside the class function

OUTSIDE THE CLASS DEFlNAT1ON;

Member function that are declared inside a class have to be defined separately
outside the class.Their definition are very much like the normal functions.

An important difference between a member function and a normal

function is that a member function incorporates a membership.Identify label in the header. The
‘label’ tells the compiler which class the function belongs to.

Syntax:

return type class-name::function-name(argument declaration )

{
function-body
}
The member ship label class-name :: tells the compiler that the function function -
name belongs to the class class-name . That is the scope of the function is restricted to the class-
name specified in the header line. The :: symbol is called scope resolution operator.

Example:
void item :: getdata (int a , float b )
{
number=a;
cost=b;
}
void item :: putdata ( void)
{
cout<<”number=:”<<number<<endl;
cout<<”cost=”<<cost<<endl;
}
The member function have some special characteristics that are often used in the program
development.
• Several different classes can use the same function name. The "membership label"
will resolve their scope, member functions can access the private data of the class
.A non member function can't do so.
• A member function can call another member function directly, without using the dot
operator.
 37

INSIDE THE CLASS DEF1NATION:

Another method of defining a member function is to replace the function declaration by the
actual function definition inside the class .
Example:
class item
{
Intnumber;
float cost;
public:
void getdata (int a ,float b);
void putdata(void)
{
cout<<number<<endl; cout<<cost<<endl;
}
};
A C++ PROGRAM WITH CLASS:
# include< iostream. h>
class item
{
int number;
float cost;
public:
void getdata ( int a , float
b); void putdala ( void)
{
cout<<“number:”<<number<<endl;
cout<<”cost :”<<cost<<endl;
}
};
void item :: getdata (int a , float b)
{
number=a;
cost=b;
}
main ( )
{
item x; cout<<”\
nobjectx”<<endl; x.
getdata( 100,299.95);
x .putdata();
item y;
cout<<”\n object y”<<endl;
y. getdata(200,175.5);
y. putdata();
}

Output: object x
number 100
 38

cost=299.950012
object -4
cost=175.5

NESTING OF MEMBER FUNCTION;

A member function can be called by using its name inside another member function of the
same class. This is known as nesting of member functions.

#include <iostream.h>
class set
{
int m,n;
public:
void input(void);
void display (void);
void largest(void);
};
int set::largest (void)
{
if(m>n)
return m;
else
return n;
}
void set::input(void)
{
cout<<”input values of m and n:”;
cin>>m>>n;
}
void set::display(void)
{
cout<<”largestvalue=”<<largest()<<”\n”;
}
void main()
{
set A;
A.input( );
A.display( );
}

output:

Input values of m and

n: 3017

largest value= 30
 39

Private member functions:

Although it is a normal practice to place all the data items in a private section and all the functions in
public, some situations may require contain functions to be hidden from the outside calls. Tasks such
as deleting an account in a customer file or providing increment to and employee are events of
serious consequences and therefore the functions handling such tasks should have restricted access.
We can place these functions in the private section.

A private member function can only be called by another function that is a member of its class. Even
an object can not invoke a private function using the dot operator.

Class sample
{
int m;
void read (void);
void write (void);
};
if si is an object of sample,
then s.read();
is illegal. How ever the function read() can be called by the function update ( ) to
update the value of m.
void sample :: update(void)
{
read( );
}
 40

#include<iostream.h>
class part
{
private:
int modelnum,partnum;
float cost;
public:
void setpart ( int mn, int pn ,float c)
{
modelmim=mn;
partnum=pn;
cost=e;
}
void showpart ( )
{
Cout<<endl<<”model:”<<modelnum<<end1;
Cout<<”num:”<< partnum <<endl
Cout<<”cost:”<<”$”<cost;
}
};
void main()
{
part pl,p2;
p1.setpart(644,73,217.55);
p2.setpart(567,89,789.55);
pl.showpart();
pl.showpart();
}

output:- model:644
num:73
cost: $217550003
model: 567
num:89
cost: $759.549988
 41

#indude<iostream.h>
class distance
{
private:
int feet;
float inches;
public:
void setdist ( int ft, float in)
{
feet=ft;
inches=in;
}
void getdist()
{
cout<<”enter feet:”;
cin>>feet;
cout<<”enter inches:”;
cin>>inches;
}
void showdist()
{
cout<< feet<<”_”inches«endl;
}
};
void main( )
{
distance dl,d2;
d1.setdist(1 1,6.25);
d2.getdata();
cout<<endl<<”dist:”<<d 1 .showdist();
cout<<”\n”<<”dist2:”;
d2.showdist();
}

output:- enter feet: 12

enter inches:
6.25
dist 1:”11’- 6.1.5”
dist 2: 12’- 6.25”
 42

UNIT 5
CONSTRUCTOR:
A constructor is a special member function whose task is to initialize the objects of its class .
It is special because its name is the same as the class name. The constructor is invoked when ever an
object of its associated class is created. It is called constructor because it construct the values of data
members of the class.

A constructor is declared and defined as follows:

//'class with a constructor
class integer
{
int m,n:
public:
integer! void);//constructor declared

};
integer :: integer(void)
{
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:-
Integer int1; //object int 1 created
This declaration not only creates the object int1 of type integer but also initializes its
data members m and n to zero.

A constructor that accept no parameter is called the default

constructor. The default constructor for class A is A :: A( ). If no such constructor is
defined, then the compiler supplies a default constructor .
Therefore a statement such as :-
A a ;//invokes the default constructor of the compiler of the
compiler to create the object "a" ;

Invokes the default constructor of the compiler to create the object

a. The constructor functions have some
characteristics:-
 They should be declared in the public section .
 They are invoked automatically when the objects are created.
 They don't have return types, not even void and therefore
they cannot return values.
 They cannot be inherited , though a derived class can call
 43

the base class constructor .

 Like other C++ function , they can have default arguments,
 Constructor can't be virtual.
 An object with a constructor can't be used as a member
of union.
Example of default constructor:

#include<iostream.h>
#include<conio.h>

class abc
{
private:
char nm[];
public:
abc (
)
{ cout<<”enter your name:”;
cin>>nm;

}
void display( )

{
cout<<nm;
}

};

int main( )
{
clrscr( );
abc d;
d.display( )
;
getch( );
return(0);
}
PARAMETERIZED CONSTRUCTOR:-
the constructors that can take arguments are called parameterized constructors.
Using parameterized constructor we can initialize the various data elements of different objects with
different values when they are created.
Example:-
class integer
{
int m,n;
public:
integer( int x, int y);
 44

};
 45

integer:: integer (int x, int

y)
{ m=x;n=y;

}
the argument can be passed to the constructor by calling the constructor
implicitly.
integer int 1 = integer(0,100); // explicit
call integer int 1(0,100); //implicite call

CLASS WITH CONSTRUCTOR:-

#include<iostream.h>
class integer
{
int m,n;
public:
integer(int,int);
void display(void)

{
cout<<”m=:”<<m ;
cout<<”n=”<<n;
}
};
integer :: integer( int x,int y) // constructor defined
{
m=x;
n=y;
}
int main( )
{
integer int 1(0, 100); // implicit
call integer int2=integer(25,75);
cout<<” \nobjectl “<<endl;
int1.display( );
cout<<” \n object2
“<<endl; int2.display( );
}
output:
object 1
m=0
n=100
object2
m=25
n=25
 46

Example:-
#include<iostream.h>
#include<conio.h>
class abc
{
private:
char nm [30];
int age;
public:
abc ( ){ }// default
abc ( char x[], int y);
void get( )
{
cout<<”enter your name:”;
cin>>nm;
cout<<” enter your age:”;
cin>>age;
}
void display( )
{
cout<<nm«endl;
cout«age;
}
};
abc : : abc(char x[], int y)
{
strcpy(nm,x);
age=y;
}
void main( )
{
abc 1;
abc m=abc("computer",20000);
l.get();
l.dispalay( );
m.display ( );
getch( );
}

OVERLOADED CONSTRUCTOR:-
#include<iostream.h>
#include<conio.h>
class sum
{
private;
int a;
int b;
int c;
float d;
double e;
public:
sum ( )
 47

{
cout<<”enter a;”;
cin>>a;
cout<<”enter b;”;
cin>>b;
cout<<”sum= “<<a+b<<endl;
}
sum(int a,int b);
sum(int a, float d,double c);
};
sum :: sum(int x,int y)
{
a=x;
b=y
;
}
sum :: sum(int p, float q ,double r)
{
a=p;
d=q
;
e=r;
}
void main( )
{
clrscr( );
sum 1;
sum m=sum(20,50);
sum n= sum(3,3.2,4.55);
getch( );
}

output:
enter a : 3
enter b : 8
sum=11
sum=70
sum=10.75

COPY CONSTRUCTOR:
A copy constructor is used to declare and initialize an object from another object.
Example:-
the statement
integer 12(11);
would define the object 12 and at the same time initialize it to the values of 11.
Another form of this statement is : integer 12=11;
The process of initialization through a copy constructor is known as copy initialization.
Example:-
#incliide<iostream.h>
class code
{
int id;
 48

public
code ( ) { } //constructor
code (int a) { id=a; } //constructor
code(code &x)
{
 49

Id=x.id;
}
void display( )
{
cout<<id;
}
};
int main( )
{
code A(100);
code B(A);
code C=A;
code D;
D=A;
cout<<” \n id of A :”; A.display( );
cout<<” \nid of B :”; B.display( );
cout<<” \n id of C:”; C.display( );
cout<<” \n id of D:”; D.display( );
}

output :-
id of
A:100 id
of B:100 id
of C:100 id
of D:100

DESTRUCTOR:-

A destructor, us the name implies is used to destroy the objects that have been created by a
constructor. Like a constructor, the destructor is a member function whose name is the same as the
class name but is preceded by a tilde.

For Example:-
~ integer( ) { }
A destructor never takes any argument nor does it return any value. It will be invoked
implicitly by the compiler upon exit from the program to clean up storage that is no longer
accessible. It is a good practice to declare destructor in a program since it releases memory space for
future use.
Delete is used to free memory which is created by new.
Example:-
matrix : : ~ matrix( )
{
for(int i=0; i<11;i++)
delete p[i];
delete p;
}

IMPLEMENTED OF DESTRUCTORS:-
#include<iostream.h>
int count=0;
class alpha
 50

{
public:
alpha( )
{
count ++;
cout<<”\n no of object created :”<<endl;
}
~alpha( )
{
cout<<”\n no of object destroyed :”
<<endl; coutnt--;
}
};

int main( )
{

cout<<” \n \n enter main \n:”;

alpha A1,A2,A3,A4;
{
cout<<” \n enter block 1 :\n”;
 51

alpha A5;
}
{
cout<<” \n \n enter block2 \n”;
alpha A6;
}
cout<<\n re-enter main \n:”;
return(0);
}

output:-
enter main
no of object created 1
no of object created 2
no of object created 3
no of object created 4
enter block 1
no of object created 5
no of object destroyed
5 enter block 2
no of object created 5
no of object destroyed
5 re-enter main
no of object destroyed
4 no of object created 3
no of object created 2
no of object created 1

Example :-
#include<iostream.h>
int x=l;
class abc
{
public:
abc( )
{
x--;
cout<<”construct the no”<<x<<endl;
}
~abc(
)
{
cout<<”destruct the no:”<<x<<endl;
x--;
}
};
int main( )
{
abc I1,I2,I3,I4;
cout«ll«12«13«l4«endl;
return(0);
}
 52

OPERATOR OVERLOADING:-
Operator overloading provides a flexible option for the creation of new definations for most
of the C++ operators. We can overload all the C++ operators except the following:
 Class members access operator (. , .*)
 Scope resolution operator (: :)
 Size operator(sizeof)
 Condition operator (? :)
Although the semantics of an operator can be extended, we can't change its syntax, the
grammatical rules that govern its use such as the no of operands precedence and associativety. For
example the multiplication operator will enjoy higher precedence than the addition operator.
When an operator is overloaded, its original meaning is not lost. For example,
the operator +, which has been overloaded to add two vectors, can still be used to add two integers.

DEFINING OPERATOR OVERLOADING:

To define an additional task to an operator, we must specify what it means in
relation to the class to which the operator is applied . This is done with the help of a special function
called operator function, which describes the task.
Syntax:-
return-type class-name :: operator op( arg-list)
{
function body
}
Where return type is the type of value returned by the specified operation and
op is the operator being overloaded. The op is preceded by the keyword operator, operator op is the
function name.
operator functions must be either member function, or friend
function. A basic defference between them is that a friend function will have only one argument for
unary operators and two for binary operators, This is because the object used to invoke the member
function is passed implicitly and therefore is available for the member functions. Arguments may be
either by value or by reference.

operator functions are declared in. the class using prototypes as follows:-
vector operator + (vector); /./ vector addition
vector operator-( ); //unary minus
friend vector operator + (vuelor, vector); // vector
add friend vector operator -(vector); // unary
minus vector operator - ( vector &a); //
substraction
int operator = =(vector); //comparision
friend int operator = =(vector ,vrctor); // comparision
vector is a data type of class and may represent both magnitude and direction or a series
of points called elements.
The process of overloading involves the following steps:-
1. Create a class that defines the data type that is used in the overloading operation.
2. Declare the operator function operator op() in the public part of the class
3. It may be either a member function or friend function.
4. Define the operator function to implement the required operations.
 53

Overloaded operator functions can be invoked by expressions such

as op x or x op;
for unary operators and
x op y
for binary opearators.
operator op(x);
for unary operator using friend
function operator op(x,y);
for binary operator usinf friend function.

Unary – operator overloading(using member function):

class abc
{
int m,n;
public:
abc()
{ m=
8;
n=9;
}
void show()
{
cout<<m<<n;
}
operator -- ()
{
--m;
--n;
}
};
void main()
{
abc x;
x.show();
--x;
 54

x.show();
}

Unary – - operator overloading(using friend function):

class abc
{
int m,n;
public:
abc()
{ m=
8;
n=9;
}
void show()
{
cout<<m<<n;
}
friend operator --(abc &p);
};
operator -- (abc &p)
{
--p.m;
--p.n;
}
};
void main()
{
abc x;
x.show();
operator--(x);
x.show();
}
 55

Unary operator+ for adding two complex numbers (using member function)
class complex
{
float real,img;
public:
complex()
{
real=0;
img=0;
}
complex(float r,float i)
{
real=r;
img=i;
}
void show()
{
cout<<real<<”+i”<<img;
}
complex operator+(complex &p)
{
complex w;
w.real=real+q.real;
w.img=img+q.img;
return w;
}
};
void main()
{
complex s(3,4);
complex t(4,5);
complex m;
m=s+t;
s.show();
t.show();
m.show();
}
Unary operator+ for adding two complex numbers (using friend function)
class complex
{
float real,img;
public:
complex()
{
real=0;
img=0;
}
complex(float r,float i)
{
real=r;
img=i;
 56

}
void show()
{
cout<<real<<”+i”<<img;
}
friend complex operator+(complex &p,complex &q);
};
complex operator+(complex &p,complex &q)
{
complex w;
w.real=p.real+q.real;
w.img=p.img+q.img;
return w;
}
};
void main()
{
complex s(3,4);complex t(4,5);
complex m;
m=operator+(s,t);
s.show();t.show();
m.show();
}

Overloading an operator does not change its basic meaning. For example assume the +
operator can be overloaded to subtract two objects. But the code becomes unreachable.
class integer
{
intx, y;
public:
int operator + ( ) ;
}
int integer: : operator + ( )
{
return (x-y) ;
}
Unary operators, overloaded by means of a member function, take no explicit argument and
return no explicit values. But, those overloaded by means of a friend function take one
reference argument (the object of the relevant class).
Binary operators overloaded through a member function take one explicit argument and those
which are overloaded through a friend function take two explicit arguments.

Table 7.2
Operator to Arguments passed to the Arguments passed to the Friend
Overload Member Function Function
Unary Operator No 1
Binary Operator 1 2
 57

Type Conversions
In a mixed expression constants and variables are of different data types. The assignment operations
causes automatic type conversion between the operand as per certain rules.

The type of data to the right of an assignment operator is automatically converted to the data type of
variable on the left.

Consider the following

example: int x;
float y = 20.123;
x=y ;

This converts float variable y to an integer before its value assigned to x. The type conversion is
automatic as far as data types involved are built in types. We can also use the assignment operator in
case of objects to copy values of all data members of right hand object to the object on left hand. The
objects in this case are of same data type. But of objects are of different data types we must apply
conversion rules for assignment.

Inheritance:

Reaccessability is yet another feature of OOP's. C++ strongly supports the concept of reusability.
The C++ classes can be used again in several ways. Once a class has been written and tested, it can
be adopted by another programmers. This is basically created by defining the new classes, reusing
the properties of existing ones. The mechanism of deriving a new class from an old one is called
'INHERTTENCE'. This is often referred to as IS-A' relationship because very object of the class
being defined "is" also an object of inherited class. The old class is called 'BASE' class and the new
one is called'DERIEVED'class.

Defining Derived Classes

A derived class is specified by defining its relationship with the base class in addition to its own
details. The general syntax of defining a derived class is as follows:

class d_classname : Access specifier baseclass name

{

// members of derived class

};
The colon indicates that the a-class name is derived from the base class name. The access specifier or
the visibility mode is optional and, if present, may be public, private or protected. By default it is
private. Visibility mode describes the status of derived features e.g.

class xyz //base class

{
members of xyz
};
class ABC : public xyz //public derivation
{
members of ABC
};
class ABC : XYZ //private derivation (by default)
{
members of ABC
 58

};
In the inheritance, some of the base class data elements and member functions are inherited into the
derived class. We can add our own data and member functions and thus extend the functionality of
the base class. Inheritance, when used to modify and extend the capabilities of the existing classes,
becomes a very powerful tool for incremental program development.

Single Inheritance
When a class inherits from a single base class, it is known as single inheritance. Following program
shows the single inheritance using public derivation.

#include<iostream.h>
#include<conio.h>
class worker
{
 59

int age;
char name [10];
public:
void get ( );
};
void worker : : get ( )
{
cout <<”yout name
please” cin >> name;
cout <<”your age please” ;
cin >> age;
}
void worker :: show ( )
{
cout <<”In My name is :”<<name<<”In My age is :”<<age;
}
class manager :: public worker //derived class (publicly)
{
int now;
public:
void get ( ) ;
void show ( ) ;
};
void manager : : get ( )
{
worker : : get ( ) ; //the calling of base class input
fn. cout << “number of workers under you”;
cin >> now;
cin>>name>>age;
} ( if they were public )
void manager :: show ( )
{
worker :: show ( ); //calling of base class o/p fn.
cout <<“in No. of workers under me are: “ << now;
}
main ( )
{
clrscr ( ) ;
worker W1;
manager M1;
M1 .get ( );
M1.show ( ) ;
}
If you input the following to this program:
Your name
please Ravinder
Your age
please 27
number of workers under you
30
 60

Then the output will be as follows:

My name is :
Ravinder My age is :
27
No. of workers under me are : 30
The following program shows the single inheritance by private derivation.
#include<iostream.h>
#include<conio.h>
class worker //Base class declaration
{
int age;
char name [10] ;
public:
void get ( ) ;
void show ( ) ;
};
void worker : : get ( )
{
cout << “your name please” ;
cin >> name;
cout << “your age
please”; cin >>age;
}
void worker : show ( )
{
cout << “in my name is: “ <<name<< “in” << “my age is : “ <<age;
}
class manager : worker //Derived class (privately by default)
{
int now;
public:
void get ( ) ;
void show ( ) ;
};
void manager : : get ( )
{
worker : : get ( ); //calling the get function of base
cout << “number of worker under you”; class which is
cin >> now;
}
void manager : : show ( )
{
worker : : show ( ) ;
cout << “in no. of worker under me are : “ <<now;
}
main ( )
{
 61

clrscr ( ) ;
worker wl ;
manager ml;
ml.get ( ) ;
ml.show ( );
}
The following program shows the single inheritance using protected derivation
#include<conio.h>
#include<iostream.h>
class worker //Base class declaration
{ protected:
int age; char name [20];
public:
void get ( );
void show ( );
};
void worker :: get ( )
{
cout >> “your name please”;
cin >> name;
cout << “your age
please”; cin >> age;
}
void worker :: show ( )
{
cout << “in my name is: “ << name << “in my age is “ <<age;
}
class manager:: protected worker // protected inheritance
{
int now;
public:
void get ( );
void show ( ) ;
};
void manager : : get ( )
{
cout << “please enter the name In”;
cin >> name;
cout<< “please enter the age In”; //Directly inputting the
data cin >> age; members of base class
cout << “ please enter the no. of workers under
you:”; cin >> now;
}
void manager : : show ( )

{
cout « "your name is : "«name«" and age is :
"«age; cout «"In no. of workers under your are :
"«now;
main ( )
{
clrscr ( ) ;
manager ml;
ml.get ( ) ;
 62

cout « "\n \n";

ml.show ( );
}

Making a Private Member Inheritable

Basically we have visibility modes to specify that in which mode you are deriving the another class
from the already existing base class. They are:

a. Private: when a base class is privately inherited by a derived class, 'public

members' of the base class become private members of the derived class and
therefore the public members of the base class can be accessed by its own
objects using the dot operator. The result is that we have no member of base
class that is accessible to the objects of the derived class.
b. Public: On the other hand, when the base class is publicly inherited, 'public
members' of the base class become 'public members' of derived class and
therefore they are accessible to the objects of the derived class.
c. Protected: C++ provides a third visibility modifier, protected, which serve a
little purpose in the inheritance. A member declared as protected is accessible
by the member functions within its class and any class immediately derived
from it. It cannot be accessed by functions outside these two classes.

The below mentioned table summarizes how the visibility of members undergo modifications when
they are inherited

Base Class Visibility Derived Class Visibility

Public Private Protected
Private X X X
Public Public Private Protected
Protected Protected Private Protected

The private and protected members of a class can be accessed by:

a. A function i.e. friend of a class.
b. A member function of a class that is the friend of the class.
c. A member function of a derived class.

Student Activity
1. Define Inheritance. What is the inheritance mechanism in C++?
2. What are the advantage of Inheritance?
3. What should be the structure of a class when it has to be a base for other
 63

Multilevel Inheritance
When the inheritance is such that, the class A serves as a base class for a derived class B which in
turn serves as a base class for the derived class C. This type of inheritance is called ‘MULTILEVEL
INHERITENCE’. The class B is known as the ‘INTERMEDIATE BASE CLASS’ since it provides a
link for the inheritance between A and C. The chain ABC is called ‘ITNHERITENCE*PATH’ for
e.g.

A Base class

Inheritance path B Intermediate base

class

C Derived class

The declaration for the same would

be: Class A
{
//body
}
Class B : public A
{
//body
}
Class C : public B
{
//body
}

This declaration will form the different levels of inheritance.

Following program exhibits the multilevel inheritance.

#include<iostream.h>
#include<conio.h>
class worker // Base class declaration
{
int age;
char name [20] ;
public;
void get( ) ;
 64

void show( ) ;
}

void worker: get ( )

{
cout << “your name please” ;
cin >> name;
cout << “your age please” ;
}
void worker : : show ( )
{
cout << “In my name is : “ <<name<< “ In my age is : “ <<age;
}
class manager : public worker //Intermediate base class derived
{ //publicly from the base
class int now;
public:
void get ( ) ;
void show( ) ;
};
void manager :: get ( )
{
worker : :get () ; //calling get ( ) fn. of base
class cout << “no. of workers under you:”;
cin >> now;
}
void manager : : show ( )
{
worker : : show ( ) ; //calling show ( ) fn. of base
class cout << “In no. of workers under me are: “<< now;
}
class ceo: public manager //declaration of derived class
{ //publicly inherited from the
int nom; //intermediate base
class public:
void get ( ) ;
void show ( ) ;
};
void ceo : : get ( )
{
manager : : get ( ) ;
cout << “no. of managers under you are:”; cin >> nom;
}
void manager : : show ( )
{
cout << “In the no. of managers under me are:
In”; cout << “nom;
}
 65

main ( )
{
clrscr ( ) ;
ceo cl ;
cl.get ( ) ; cout << “\n\n”;
cl.show ( ) ;
}
Worker

Private:
int age;
char name[20];

Protected:

Private:
int age;
char name[20];

Manager:Worker

Private:
int now;

Protected:

Public:
void get()
void show()
worker ::get()
worker ::get()

Ceo: Manager

Public:

Protected:

Public:
All the
inherited
members
 66

Multiple Inheritances
A class can inherit the attributes of two or more classes. This mechanism is known as ‘MULTIPLE
INHERITENCE’. Multiple inheritance allows us to combine the features

of several existing classes as a starring point for defining new classes. It is like the child inheriting
the physical feature of one parent and the intelligence of another. The syntax of the derived class is
as follows:

Class base1 Class base2

{ {
//body1 // body2
} }

Where the visibilityClass

refers to the: visibility
derived access specifiers i.e. public, private or protected. Following
basel, visibility
program shows the multiple
base2 inheritance.
{
#include<iostream.h> //body3
#include<conio . h>
class father //Declaration of base classl
{
int age ;
char flame [20] ;
public:
void get ( ) ;
void show ( ) ;
};
void father : : get ( )
{
cout << “your father name please”;
cin >> name;
cout << “Enter the
age”; cin >> age;
}
void father : : show ( )
{
cout<< “In my father’s name is: ‘ <<name<< “In my father’s age is:<<age;
}
class mother //Declaration of base class 2
{
char name [20] ;
int age ;
 67

public:
void get ( )
{
cout << “mother’s name please” <<
“In”; cin >> name;
cout << “mother’s age please” <<
“in”; cin >> age;
}
void show ( )
{
cout << “In my mother’s name is: “
<<name; cout << “In my mother’s age is: “
<<age;
}
class daughter : public father, public mother //derived class inheriting
{ //publicly
char name [20] ; //the features of both the base
class int std;
public:
void get ( ) ;
void show ( ) ;
};
void daughter :: get ( )
{
father :: get ( ) ;
mother :: get ( ) ;
cout << “child's name:
“; cin >> name;
cout << “child's
standard”; cin >> std;
}
void daughter :: show ( )
{
father :: show ( );
nfather :: show ( ) ;
cout << “In child’s name is : “
<<name; cout << “In child's standard: “
<< std;
}
main ( )
{
clrscr ( ) ;
daughter d1;
d1.get ( ) ;
d1.show ( ) ;
}
 68

Diagrammatic Representation of Multiple Inheritance is as

follows: Father Mother

Private: Private:
int age; int age;
char name[20]; char name[20];

Protected: Protected:

Public: Public:
void get() void get()
void show() void show()

Class daughter: public Father, public Mother

Private: char name[20]; int age;

Protected:

Public:
//self
void get(); void showQ;
//from Father
void get(); void show();
//from Mother
void get(); void show();
 69

Hierarchical Inheritance
Another interesting application of inheritance is to use is as a support to a hierarchical design of a
class program. Many programming problems can be cast into a hierarchy where certain features of
one level are shared by many others below that level for e.g.
Accounts

Saving Accounts Current Accounts

Fixed deposit

Long term
Short

In general the syntax is given as Mid term

Class A
{
// body A
}

Class B: public A
{ Class C: public A
//body B {
} //body B
}

In C++, such problems can be easily converted into hierarchies. The base class will include all the
features that are common to the subclasses. A sub-class can be constructed by inheriting the features
of base class and so on.

// Program to show the hierarchical inheritance

#include<iostream.h>
# include<conio. h>
class father //Base class declaration
{
int age;
char name [15];
public:
void get ( )
{
cout<< “father name please”; cin >> name;
 70

cout<< “father’s age please”; cin >> age;

}
void show ( )
{
cout << “In father’s name is ‘:
“<<name; cout << “In father’s age is:
“<< age;
}
};
class son : public father //derived class 1
{
char name [20] ;
int age ;
public;
void get ( ) ;
void show ( ) ;
};
void son : : get ( )

{
father :: get ( ) ;
cout << “your (son) name please” << “in”; cin
>>name; cout << “your age please” << “ln”; cin>>age;
}
void son :: show ( )
{
father : : show ( ) ;
cout << “In my name is : “
<<name; cout << “In my age is : “
<<age;
}
class daughter : public father //derived class 2.
{
char name [15] ;
int age;
public:
void get ( )
{
father : : get ( ) ;
cout << “your (daughter’s) name please In” cin>>name;
cout << “your age please In”; cin >>age;
}
void show ( )
{
father : : show ( ) ;
cout << “in my father name is: “ << name <<
“ In and his age is : “<<age;
}
};
main ( )
{
clrscr ( ) ;
 71

son S1;
daughter D1 ;
S1. get ( ) ;
D1. get ( ) ;
S1 .show( ) ;
D1. show ( ) ;
}
Hybrid Inheritance
There could be situations where we need to apply two or more types of inheritance to design a
program. Basically Hybrid Inheritance is the combination of one or more types of the inheritance.
Here is one implementation of hybrid inheritance.

//Program to show the simple hybrid

inheritance #include<i sos t ream. h>
#include<conio . h>
class student //base class declaration
{
protected:
int r_no;
public:
void get _n (int a)
{
r_no =a;
}
void put_n (void)
{
cout << “Roll No. : “<< r_no;
cout << “In”;
}
};
class test : public student
{ //Intermediate base
class protected : int parti, par 2;

public :
void get_m (int x, int y) {
parti = x; part 2 = y; }
void put_m (void) {
cout << “marks obtained: “ << “In”
<< “Part 1 = “ << part1 << “in”
<< “Part 2 = “ << part2 << “In”;
}
};
class sports // base for result
{
protected : int score;
public:
void get_s (int s) {
score = s }
void put_s (void) {
cout << “ sports wt. : “ << score << “\n\n”;
 72

}
};
class result : public test, public sports //Derived from test
& sports
{
int total;
public:
void display (void);
};

void result : : display (void)

{
total = part1 + part2 + score;
put_n ( ) ;.
put_m ( );
put_S ( );
cout << “Total score: “ <<total<< “\n”
}
main (
)
{
clrscr ( ) ;
result S1;
S1.get_n (347) ;
S1.get_m (30, 35);
S1.get_s (7) ;
S1.dciplay ( ) ;
}

Student Activity
1. What is the major use of multilevel Inheritance?
2. How are arguments sent to the base constructors in multiple inheritance?
Whose responsibility is it.
3. What is the difference between hierarchical and hybrid Inheritance.
 73

Virtual Base Classes

We have just discussed a situation which would require the use of both multiple and multi level
inheritance. Consider a situation, where all the three kinds of inheritance, namely multi-level,
multiple and hierarchical are involved.

Let us say the 'child' has two direct base classes ‘parent1’ and ‘parent2’ which themselves has a
common base class ‘grandparent’. The child inherits the traits of ‘grandparent’ via two separate
paths. It can also be inherit directly as shown by the broken line. The grandparent is sometimes
referred to as ‘INDIRECT BASE CLASS’. Now, the inheritance by the child might cause some
problems. All the public and protected members of ‘grandparent’ are inherited into ‘child’ twice, first
via ‘parent1’ and again via ‘parent2’. So, there occurs a duplicacy which should be avoided.

The duplication of the inherited members can be avoided by making common base class as the
virtual base class: for e.g.
class g_parent
{
//Body
};
class parent1: virtual public g_parent
{
// Body
};

class parent2: public virtual g_parent

{
// Body
};
class child : public parent1, public parent2
{
// body
};

When a class is virtual base class, C++ takes necessary care to see that only one copy
of that class is inherited, regardless of how many inheritance paths exists between
virtual base class and derived class. Note that keywords ‘virtual’ and ‘public’ can be
used in either order.

//Program to show the virtual base

class #include<iostream.h>
#include<conio . h>
class student // Base class declaration
{
protected:
int r_no;
public:
void get_n (int a)
{ r_no = a; }
void put_n
(void)
{ cout << “Roll No. “ << r_no<< “ln”;}
};
 74

class test : virtual public student // Virtually declared common

{ //base class 1
protected:
int part1;
int part2;
public:
void get_m (int x, int y)
{ part1= x; part2=y;}
void putm (void)
{
cout << “marks obtained: “ << “\n”;
cout << “part1 = “ << part1 << “\n”;
cout << “part2 = “<< part2 << “\n”;
}
};
class sports : public virtual student // virtually declared common
{ //base class 2
protected:
int score;
public:
void get_s (int a) {
score = a ;
}
void put_s (void)
{ cout << “sports wt.: “ <<score<< “\n”;}
};
class result: public test, public sports //derived class
{
private : int total ;
public:
void show (void) ;
};
void result : : show (void)
{ total = part1 + part2 + score ;
put_n ( );
put_m ( );
put_s ( ) ; cout << “\n total score= “ <<total<< “\n” ;
}
main ( )
{
clrscr ( ) ;
result S1 ;
S1.get_n (345)
S1.get_m (30, 35) ;
S1.get-S (7) ;
S1. show ( ) ;
}
 75

Virtual Functions
Virtual functions, one of advanced features of OOP is one that does not really exist but it« appears
real in some parts of a program. This section deals with the polymorphic features which are
incorporated using the virtual functions.

The general syntax of the virtual function declaration is:

class use_detined_name{
private:
public:
virtual return_type function_name1
(arguments); virtual return_type
function_name2(arguments); virtual return_type
function_name3( arguments);
};
To make a member function virtual, the keyword virtual is used in the methods while it is declared in
the class definition but not in the member function definition. The keyword virtual precedes the
return type of the function name. The compiler gets information from the keyword virtual that it is a
virtual function and not a conventional function declaration.

For. example, the following declararion of the virtual function is valid.

class point {
intx;
inty;
public:
virtual int length ( );
virtual void display ( );
};
Remember that the keyword virtual should not be repeated in the definition if the definition occurs
outside the class declaration. The use of a function specifier virtual in the function definition is
invalid.

For example
class point {
intx ;
inty ;
public:
virtual void display ( );
};
virtual void point: : display ( ) //error
{
Function Body
}
A virtual function cannot be a static member since a virtual member is always a member of a
particular object in a class rather than a member of the class as a whole.
class point {
int x ;
int y ;
public:
virtual static int length ( ); //error
 76

};
int point: : length ( )
{
Function body
}
A virtual function cannot have a constructor member function but it can have the destructor member
function.
class point {
int x ;
int y ;
public:
virtual point (int xx, int yy) ; // constructors,
error void display ( ) ;
int length ( ) ;
};
A destructor member function does not take any argument and no return type can be specified for it
not even void.
class point {
int x ;
int y ;
public:
virtual point (int xx, int yy) ; //invalid
void display ( ) ;
int length ( ) ;
It is an error to redefine a virtual method with a change of return data type in the derived class with
the same parameter types as those of a virtuall method in the base class.
class base {
int x,y ;
public:
virtual int sum (int xx, int yy ) ; //error
};
class derived: public base
{ intz ;
public:
virtual float sum (int xx, int yy) ;
};
The above declarations of two virtual functions are invalid. Even though these functions take
identical arguments note that the return data types are different.
virtual int sum (int xx, int IT) ; //base class
virtual float sum (int xx, int IT) ; //derived class
Both the above functions can be written with int data types in the base class as well as in the derived
class as
virtual int sum (int xx, int yy) ; //base class
virtual int sum (int xx, int yy) ; //derived class
Only a member function of a class can be declared as virtual. A non member function (nonmethod)
of a class cannot be declared virtual.
virtual void display ( ) //error, nonmember function
{
Function body
}
Exception Handling:

Exception refers to unexpected condition in a program. The unusual conditions could be faults,
causing an error which in turn causes the program to fail. The error handling mechanism of c++ is
generally referred to as exception handling.
 77

Generally , exceptions are classified into synchronous and asynchronous exceptions.. The exceptions
which occur during the program execution, due to some fault in the input data or technique that is not
suitable to handle the current class of data. with in a program is known as synchronous exception.
Example:
errors such as out of range,overflow,underflow and so on.

The exceptions caused by events or faults unrelated to the program and beyond the control of
program are asynchronous exceptions.
For example, errors such as keyboard interrupts, hardware malfunctions, disk failure and so on.

exception handling model:

When a program encounters an abnormal situation for which it in not designed, the user may transfer
control to some other part of the program that is designed to deal with the problem. This is done by
throwing an exception. The exception handling mechanism uses three blocks: try, throw and catch.
The try block must be followed immediately by a handler, which is a catch block. If an exception is
thrown in the try block the program control is transferred to the appropriate exception handler. The
program should attempt to catch any exception that is thrown by any function. The relationship of
these three exceptions handling constructs called the exception handling model is shown in figure:

try block
perform operation which may throw
or invoke external function if needed

invoke function having throw block

throw block
if (failure)
throw object

exception

catch block
catches all exceptions thrown from
within try block
 78

throw construct:

The keyword throw is used to raise an exception when an error is generated in the comutation. the
throw expression initialize a temporary object of the typeT used in thorw (T arg).
syntax:
throw T;

catch construct:

The exception handler is indicated by the catch keyword. It must be used immediately after the
statements marked by the try keyword. The catch handler can also occur immediately after another
catch Each handler will only evaluate an exception that matches.
syn:
catch(T)
{
// error meassges
}

try construct:
The try keyboard defines a boundary within which an exception can occur. A block of code in which
an exception can occur must be prefixed by the keyword try. Following the try keyword is a block of
code enclosed by braces. This indicates that the prepared to test for the existence of exceptions. If an
exception occurs, the program flow is interrupted.

try
{
…
if (failure)
throw T;
}
catch(T)
{
…
}
example:
#include<iostream.h>
void main()
{
int a,b;
cout<<”enter two numbers:”;
cin>>a>>b;
try
{
if (b= =0)
throw b;
else
cout<a/b;
}
catch(int x)
{
cout<<”2nd operand can’t be 0”;
}
}
 79

Array reference out of bound:

#define max
5 class array
{
private:
int a[max];
public:
int &operator[](int i)
{
if (i<0 || i>=max)
throw i;

else
return a[i];
}
};
void main()
{
array x;
try
{
cout<<”trying to refer a[1]…”
x[1]=3;
cout<<”trying to refer a[13]…”
x[13]=5;
}
catch(int i)
{
cout<<”out of range in array references…”;
}
}

multiple catches in a program

void test(int x)
{
try{
if (x==1)
throw x;
else if (x==-1)
throw 3.4;
else if (x==0)
throw ‘s’;
}
catch (int i)
{
cout<<”caught an integer…”;
}
catch (float s)
{
cout<<”caught a float…”;
 80

}
catch (char c)
{
cout<<”caught a character…”;
}}
void main()
{
test(1);
test(-1);
test(0);
}

catch all
void test(int x)
{
try{
if (x==1)
throw x;
else if (x==-1)
throw 3.4;
else if (x==0)
throw ‘s’;
}
catch (…)
{
cout<<”caught an error…”;
}
81