C++ is a statically typed, compiled, general

purpose,
case-sensitive,
free-form
programming
language
that
supports
procedural, object-oriented, and generic
programming.
C++ is regarded as a middle-level language,
as it comprises a combination of both high-level
and low-level language features.
C++ was developed by Bjarne Stroustrup
starting in 1979 at Bell Labs in Murray Hill, New
Jersey as an enhancement to the C language
and originally named C with Classes but later it
was renamed C++ in 1983.
C++ is a superset of C, and that virtually any
legal C program is a legal C++ program.

Object-Oriented Programming
C++
fully
supports
object-oriented
programming, including the four pillars of
object-oriented development:

Encapsulation

Data hiding

Inheritance

Polymorphism

Standard Libraries
Standard C++ consists of three important parts:

The core language giving all the building blocks

including variables, data types and literals etc.
The C++ Standard Library giving a rich set of
functions manipulating files, strings etc.

Learning C++
The most important thing to do when learning
C++ is to focus on concepts and not get lost in
language technical details.
The purpose of learning a programming
language is to become a better programmer;
that is, to become more effective at designing

and implementing new

maintaining old ones.

systems

and

at

C++ supports a variety of programming styles.

You can write in the style of Fortran, C,
Smalltalk, etc., in any language. Each style can
achieve its aims effectively while maintaining
runtime and space efficiency.
When we consider a C++ program it can be
defined as a collection of objects that
communicate via invoking each others
methods. Let us now briefly look into what do
class, object, methods and instant variables
mean.

Object - Objects have states and behaviors.

Example: A dog has states-color, name, breed
as well as behaviors -wagging, barking, eating.
An object is an instance of a class.
Class - A class can be defined as a template/
blue print that describe the behaviors/states
that object of its type support.
Methods - A method is basically a behavior. A
class can contain many methods. It is in
methods where the logics are written, data is
manipulated and all the actions are executed.

Instant Variables - Each object has its unique

set of instant variables. An object's state is
created by the values assigned to these instant
variables.

C++ Program Structure:

Let us look at a simple code that would print the
words Hello World.
#include <iostream>
using namespace std;
// main() is where program
execution begins.
int main()
{
cout << "Hello World"; // prints
Hello World
return 0;
}
Let us look various parts of the above program:

The C++ language defines several headers,

which contain information that is either

necessary or useful to your program. For this

program, the header <iostream> is needed.
The line using namespace std; tells the
compiler to use the std namespace.
Namespaces are a relatively recent addition to
C++.
The next line // main() is where program
execution begins. is a single-line comment
available in C++. Single-line comments begin
with // and stop at the end of the line.
The line int main() is the main function where
program execution begins.
The next line cout << "This is my first C++
program."; causes the message "This is my
first C++ program" to be displayed on the
screen.
The next line return 0; terminates main(
)function and causes it to return the value 0 to
the calling process.

Compile & Execute C++

Program:
Lets look at how to save the file, compile and
run the program. Please follow the steps given
below:

Open a text editor and add the code as above.

Save the file as : hello.cpp

Open a command prompt and go to the

directory where you saved the file.
Type 'g++ hello.cpp ' and press enter to compile
your code. If there are no errors in your code
the command prompt will take you to the next
line and would generate a.out executable file.
Now type ' a.out' to run your program.
You will be able to see ' Hello World ' printed on
the window.

Semicolons & Blocks in C++:

In C++, the semicolon is a statement
terminator. That is, each individual statement
must be ended with a semicolon. It indicates
the end of one logical entity.
For example, following are three different
statements:
x = y;
y = y+1;
add(x, y);
A block is a set of logically connected
statements that are surrounded by opening and
closing braces. For example:
{

cout << "Hello World"; // prints

Hello World
return 0;
}
C++ does not recognize the end of the line as a
terminator. For this reason, it does not matter

where on a line you put a statement. For

example:
x = y;
y = y+1;
add(x, y);
is the same as
x = y; y = y+1; add(x, y);

C++ Identifiers:
A C++ identifier is a name used to identify a
variable, function, class, module, or any other
user-defined item. An identifier starts with a
letter A to Z or a to z or an underscore (_)
followed by zero or more letters, underscores,
and digits (0 to 9).
C++ does not allow punctuation characters
such as @, $, and % within identifiers. C++ is a
case
sensitive
programming
language.
Thus Manpower and manpower are
two
different identifiers in C++.

Here are
identifiers:
mohd
a_123
myname50
retVal

some

examples

of

acceptable

zara

abc

move_name

_temp

a23b9

C++ Keywords:
The following list shows the reserved words in
C++. These reserved words may not be used
as constant or variable or any other identifier
names.
asm

else

new

this

auto

enum

operator

throw

bool

explicit

private

true

break

export

protected

try

case

extern

public

typedef

catch

false

register

typeid

char

float

reinterpret_ca typenam

st

class

for

return

union

const

friend

short

unsigne
d

const_cast

goto

signed

using

continue

if

sizeof

virtual

default

inline

static

void

delete

int

static_cast

volatile

do

long

struct

wchar_t

double

mutable

switch

while

dynamic_ca namespac
template
st
e

Whitespace in C++:
A line containing only whitespace, possibly with
a comment, is known as a blank line, and C++
compiler totally ignores it.

Whitespace is the term used in C++ to describe

blanks,
tabs,
newline
characters
and
comments. Whitespace separates one part of a
statement from another and enables the
compiler to identify where one element in a
statement, such as int, ends and the next
element begins. Therefore, in the statement,
int age;
There must be at least one whitespace
character (usually a space) between int and
age for the compiler to be able to distinguish
them. On the other hand, in the statement
fruit = apples + oranges;
the total fruit

// Get

No whitespace characters are necessary

between fruit and =, or between = and apples,
although you are free to include some if you
wish for readability purpose.
Program comments are explanatory statements
that you can include in the C++ code that you
write and helps anyone reading it's source

code. All programming languages allow for

some form of comments.
C++ supports single line and multi-line
comments. All characters available inside any
comment are ignored by C++ compiler.
C++ comments start with /* and end with */. For
example:
/* This is a comment */
/* C++ comments can also
* span multiple lines
*/
A comment can also start with //, extending to
the end of the line. For example:
#include <iostream>
using namespace std;
main()
{
cout << "Hello World"; // prints
Hello World

return 0;
}
When the above code is compiled, it will
ignore // prints Hello World and final
executable will produce following result:
Hello World
Within a /* and */ comment, // characters have
no special meaning. Within a // comment, /* and
*/ have no special meaning. Thus, you can
"nest" one kind of comment within the other
kind. For example:
/* Comment out printing of Hello
World:
cout << "Hello World"; // prints
Hello World
*/
While doing programming in any programming
language, you need to use various variables to
store various information. Variables are nothing

but reserved memory locations to store values.

This means that when you create a variable you
reserve some space in memory.
You may like to store information of various
data type like character, wide character,
integer, floating point, double floating point,
boolean etc. Based on the data type of a
variable, the operating system allocates
memory and decides what can be stored in the
reserved memory.

Primitive Built-in Types:

C++ offer the programmer a rich assortment of
built-in as well as user defined data types.
Following table list down seven basic C++ data
types:
Type

Keyword

Boolean

bool

Character

char

Integer

int

Floating point

float

Double floating point double

Valueless

void

Wide character

wchar_t

Several of the basic types can be modified

using one or more of these type modifiers:

signed

unsigned

short

long
The following table shows the variable type,
how much memory it takes to store the value
memory, and what is maximum and minimum
vaue which can be stored in such type of
variables.
Type

Typical
Typical Range
Bit Width

char

1byte

-127 to 127 or 0 to
255

unsigned

1byte

0 to 255

char
signed
char

1byte

-127 to 127

int

4bytes

-2147483648 to
2147483647

unsigned
int

4bytes

0 to 4294967295

signed int

4bytes

-2147483648 to
2147483647

short int

2bytes

-32768 to 32767

unsigned
short int

Range

0 to 65,535

signed
short int

Range

-32768 to 32767

long int

4bytes

-2,147,483,647 to
2,147,483,647

signed
long int

4bytes

same as long int

unsigned
long int

4bytes

0 to 4,294,967,295

float

4bytes

+/- 3.4e +/- 38 (~7

digits)
double

8bytes

+/- 1.7e +/- 308

(~15 digits)

long
double

8bytes

+/- 1.7e +/- 308

(~15 digits)

wchar_t

2 or 4
bytes

1 wide character

The sizes of variables might be different from

those shown in the above table, depending on
the compiler and the computer you are using.
Following is the example which will produce
correct size of various data type on your
cmputer.
#include <iostream>
using namespace std;
int main()
{
cout << "Size of char : " <<
sizeof(char) << endl;
cout << "Size of int : " <<
sizeof(int) << endl;

cout << "Size of short int : "

<< sizeof(short int) << endl;
cout << "Size of long int : " <<
sizeof(long int) << endl;
cout << "Size of float : " <<
sizeof(float) << endl;
cout << "Size of double : " <<
sizeof(double) << endl;
cout << "Size of wchar_t : " <<
sizeof(wchar_t) << endl;
return 0;
}
This example uses endl which inserts a newline character after every line and << operator is
being used to pass multiple values out to the
screen. We are also using sizeof() function to
get size of various data types.
When the above code is compiled and
executed, it produces following result which can
vary from machine to machine:
Size
Size
Size
Size

of
of
of
of

char : 1
int : 4
short int : 2
long int : 4

Size of float : 4
Size of double : 8
Size of wchar_t : 4

Typedef Declarations:
You can create a new name for an existing type
using typedef. Following is the simple syntax to
define a new type using typedef:
typedef type newname;
For example, the following tells the compiler
that feet is another name for int:
typedef int feet;
Now, the following declaration is perfectly legal
and creates an integer variable called distance:
feet distance;

#include <iostream>

#include <string>
using namespace std;

typedef short SmallNumber;

typedef unsigned int Positive;
typedef double* PDouble;
typedef string FiveStrings[5];

int main()
{
SmallNumber temperature = 248;

Positive height = 1048;

PDouble distance = new
double(390.82);
FiveStrings countries = {
"Ghana", "Angola", "Togo",
"Tunisia", "Cote d'Ivoire" };

cout << "Temperature: " <<

temperature << endl;
cout << "Height:
height << endl;

" <<

cout << "Distance:

*distance << endl;

" <<

cout << "Countries:\n";

for(int i = 0; i <
sizeof(countries) /
sizeof(string); i++)
cout << '\t' <<
countries[i] << endl;

cout << endl;

return 0;
}
This would produce:
Temperature: -248
Height:

1048

Distance:

390.82

Countries:

Ghana
Angola
Togo
Tunisia
Cote d'Ivoire

Enumerated Types:
An enumerated type declares an optional type
name and a set of zero or more identifiers that
can be used as values of the type. Each
enumerator is a constant whose type is the
enumeration.
To create an enumeration requires the use of
the keyword enum. The general form of an
enumeration type is:

enum enum-name { list of names }

var-list;
Here, The enum-name is the enumeration's
type name. The list of names is comma
separated.
For example, the following code defines an
enumeration of colors called colors and the
variable c of type color. Finally, c is assigned
the value "blue".
enum color { red, green, blue } c;
c = blue;
By default, the value of the first name is 0, the
second name has the value 1, the third has the
value 2, and so on. But you can give a name a
specific value by adding an initializer. For
example,
in
the
following
enumeration, green will have the value 5.
enum color { red, green=5, blue };
Here blue will have a value of 6 because each
name will be one greater than the one that
precedes it.

Enum example
#include <iostream.h>
int main()
{
enum
Days{Sunday,Monday,Tuesday,Wednesday,
Thursday,Friday,Saturday};
Days TheDay;
int j;
cout<<"Please enter the day of the week (0
to 6)";
cin>>j;
TheDay = Days(j);
if(TheDay == Sunday || TheDay ==
Saturday)

cout<<"Hurray it is the weekend"<<endl;

else
cout<<"Curses still at work"<<endl;
return 0;
}

Variable Declaration in C++:

All variables must be declared before use,
although certain declarations can be made
implicitly by content. A declaration specifies a
type, and contains a list of one or more
variables of that type as follows:
type variable_list;
Here, type must be a valid C++ data type
including char, w_char, int, float, double, bool or
any
user
defined
object
etc.,
and variable_list may consist of one or more

identifier names separated by commas. Some

valid declarations are shown here:
int
i, j, k;
char
c, ch;
float f, salary;
double d;
A variable declaration with an initializer is
always a definition. This means that storage is
allocated for the variable and could be declared
as follows:
int
i = 100;
An extern declaration is not a definition and
does not allocate storage. In effect, it claims
that a definition of the variable exists elsewhere
in the program. A variable can be declared
multiple times in a program, but it must be
defined only once. Following is the declaration
of a variable with extern keyword:
extern int
i;
Though you can declare a variable multiple
times in your C++ program but it can be
decalred only once in a file, a function or a
block of code.

Variable Initialization in C++:

Variables are initialized (assigned an value)
with an equal sign followed by a constant
expression. The general form of initialization is:
variable_name = value;
Variables can be initialized (assigned an initial
value) in their declaration. The initializer
consists of an equal sign followed by a constant
expression as follows:
type variable_name = value;
Some examples are:
int d = 3, f = 5;
//
initializing d and f.
byte z = 22;
// initializes
z.
double pi = 3.14159; // declares an
approximation of pi.
char x = 'x';
// the
variable x has the value 'x'.

For declarations without an initializer: variables

with static storage duration are implicitly
initialized with NULL (all bytes have the value
0); the initial value of all other variables is
undefined.
It is a good programming practice to initialize
variables
properly
otherwise,
sometime
program would produce unexpected result. Try
following example which makes use of various
types of variables:
#include <iostream>
using namespace std;
int main ()
{
// Variable declaration:
int a, b;
int c;
float f;
// actual initialization
a = 10;
b = 20;
c = a + b;

cout << c << endl ;

f = 70.0/3.0;
cout << f << endl ;
return 0;
}
When the above code is compiled and
executed, it produces following result:
30
23.3333

Lvalues and Rvalues:

There are two kinds of expressions in C++:

lvalue : An expression that is an lvalue may

appear as either the left-hand or right-hand side
of an assignment.

rvalue : An expression that is an rvalue may

appear on the right- but not left-hand side of an
assignment.
Variables are lvalues and so may appear on the
left-hand side of an assignment. Numeric
literals are rvalues and so may not be assigned
and can not appear on the left-hand side.
Following is a valid statement:
int g = 20;
But following is not a valid statement and would
generate compile-time error:
10 = 20;
scope is a region of the program and broadly
speaking there are three places where
variables can be declared:

Inside a function or a block which is called local

variables,
In the definition of function parameters which is
called formal parameters.

Outside of all functions which is called global

variables.
We will learn what is a function and it's
parameter in subsequent chapters. Here let us
explain what are local and global variables.

Local Variables:
Variables that are declared inside a function or
block are local variables. They can be used
only by statements that are inside that function
or block of code. Local variables are not known
to functions outside their own. Following is the
example using local variables:
#include <iostream>
using namespace std;
int main ()
{
// Local variable declaration:
int a, b;
int c;

// actual initialization
a = 10;
b = 20;
c = a + b;
cout << c;
return 0;
}

Global Variables:
Global variables are defined outside of all the
functions, usually on top of the program. The
global variables will hold their value throughout
the lifetime of your program.
A global variable can be accessed by any
function. That is, a global variable is available

for use throughout your entire program after its

declaration. Following is the example using
global and local variables:
#include <iostream>
using namespace std;
// Global variable declaration:
int g;
int main ()
{
// Local variable declaration:
int a, b;
// actual initialization
a = 10;
b = 20;
g = a + b;
cout << g;
return 0;
}

A program can have same name for local and

global variables but value of local variable
inside a function will take preference. For
example:
#include <iostream>
using namespace std;
// Global variable declaration:
int g = 20;
int main ()
{
// Local variable declaration:
int g = 10;
cout << g;
return 0;
}
When the above code is compiled and
executed, it produces following result:
10

Initializing Local and Global

Variables:
When a local variable is defined, it is not
initalised by the system, you must initalise it
yourself. Global variables are initalised
automatically by the system when you define
them as follows:
Data Type Initialser
int

char

'\0'

float

double

pointer

NULL

It is a good programming practice to initialize

variables
properly
otherwise,
sometime
program would produce unexpected result.
Constants refer to fixed values that the program
may not alter and they are called literals.

Constants can be of any of the basic data types

and can be divided in Integer Numerals,
Floating-Point Numerals, Characters, Strings
and Boolean Values.
Again, constants are treated just like regular
variables except that their values cannot be
modified after their definition.

Character literals:
Character literals are enclosed in single quotes.
If the literal begins with L (uppercase only), it is
a wide character literal (e.g., L'x') and should be
stored in wchar_t type of variable . Otherwise,
it is a narrow character literal (e.g., 'x') and can
be stored in a simple variable of char type.
A character literal can be a plain character
(e.g., 'x'), an escape sequence (e.g., '\t'), or a
universal character (e.g., '\u02C0').
There are certain characters in C++ when they
are proceeded by a back slash they will have
special meaning and they are used to represent

like newline (\n) or tab (\t). Here you have a list

of some of such escape sequence codes:
Escape sequence

Meaning

\\

\ character

\'

' character

\"

" character

\?

? character

\a

Alert or bell

\b

Backspace

\f

Form feed

\n

Newline

\r

Carriage return

\t

Horizontal tab

\v

Vertical tab

Following is the example to show few escape

sequence characters:
#include <iostream>
using namespace std;

int main()
{
cout << "Hello\tWorld\n\n";
return 0;
}
When the above code is compiled and
executed, it produces following result:
Hello

World

String literals:
String literals are enclosed in double quotes. A
string contains characters that are similar to
character literals: plain characters, escape
sequences, and universal characters.
You can break a long lines into multiple lines
using string literals and separating them using
whitespaces.

Here are some examples of string literals. All

the three forms are identical strings.
"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"

Defining Constants:
There are two simple ways in C++ to define
constants:

Using #define preprocessor.

Using const keyword.

The #define Preprocessor:

Following is the form to use
preprocessor to define a constant:
#define identifier value
Following example explains it in detail:
#include <iostream>
using namespace std;
#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'
int main()
{
int area;

area = LENGTH * WIDTH;

cout << area;
cout << NEWLINE;
return 0;

#define

When the above code is compiled and

executed, it produces following result:
50

The const Keyword:

You can use const prefix to declare constants
with a specific type as follows:
const type variable = value;
Following example explains it in detail:
#include <iostream>
using namespace std;
int main()
{
const int LENGTH = 10;
const int WIDTH = 5;
const char NEWLINE = '\n';
int area;
area = LENGTH * WIDTH;

cout << area;

cout << NEWLINE;
return 0;
}
When the above code is compiled and
executed, it produces following result:
50
Note that it is a good programming practice to
define constants in CAPITALS.

Storage Classes:
A storage class defines the scope (visibility)
and life time of variables and/or functions within
a C++ Program. These specifiers precede the
type that they modify. There are following
storage classes which can be used in a C++
Program

auto

register

static

extern

mutable

The auto Storage Class:

The auto storage class is the default storage
class for all local variables.
{
int mount;
auto int month;
}
The example above defines two variables with
the same storage class, auto can only be used
within functions, i.e. local variables.

The register Storage Class:

The register storage class is used to define
local variables that should be stored in a
register instead of RAM. This means that the

variable has a maximum size equal to the

register size (usually one word) and can't have
the unary '&' operator applied to it (as it does
not have a memory location).
{
register int miles;
}
The register should only be used for variables
that require quick access such as counters. It
should also be noted that defining 'register'
goes not mean that the variable will be stored in
a register. It means that it MIGHT be stored in a
register
depending
on
hardware
and
implementation restrictions.

The static Storage Class:

The static storage class instructs the compiler
to keep a local variable in existence during the
lifetime of the program instead of creating and
destroying it each time it comes into and goes
out of scope. Therefore, making local variables

static allows them to maintain their values

between function calls.
The static modifier may also be applied to
global variables. When this is done, it causes
that variable's scope to be restricted to the file
in which it is declared.
In C++, when static is used on a class data
member, it causes only one copy of that
member to be shared by all objects of its class.
#include <iostream>
// Function declaration
void func(void);
static int count = 10; /* Global
variable */
main()
{
while(count--)
{
func();
}
return 0;

}
// Function definition
void func( void )
{
static int i = 5; // local
static variable
i++;
std::cout << "i is " << i ;
std::cout << " and count is "
<< count << std::endl;
}
When the above code is compiled and
executed, it produces following result:
i
i
i
i
i
i
i
i
i
i

is
is
is
is
is
is
is
is
is
is

6 and count is 9
7 and count is 8
8 and count is 7
9 and count is 6
10 and count is 5
11 and count is 4
12 and count is 3
13 and count is 2
14 and count is 1
15 and count is 0

The extern Storage Class:

The extern storage class is used to give a
reference of a global variable that is visible to
ALL the program files. When you use 'extern'
the variable cannot be initialized as all it does is
point the variable name at a storage location
that has been previously defined.
When you have multiple files and you define a
global variable or function which will be used in
other files also, then extern will be used in
another file to give reference of defined variable
or function. Just for understanding extern is
used to declare a global variable or function in
another files.
The extern modifier is most commonly used
when there are two or more files sharing the
same global variables or functions as explained
below.
First File: main.cpp
#include <iostream>

int count ;
extern void write_extern();
main()
{
count = 5;
write_extern();
}
Second File: write.cpp
#include <iostream>
extern int count;
void write_extern(void)
{
std::cout << "Count is " <<
count << std::endl;
}
Here extern keyword is being used to declare
count in another file. Now compile these two
files as follows:
$g++ main.cpp write.cpp -o write

This will produce write executable program, try

to execute write and check the result as
follows:
$./write
5

The mutable Storage Class:

The mutable specifier applies only to class
objects, which are discussed later in this
tutorial. It allows a member of an object to
override constness. That is, a mutable member
can be modified by a const member function.
An operator is a symbol that tells the compiler
to perform specific mathematical or logical
manipulations. C++ is rich in built-in operators
and provides following type of operators:

Arithmetic Operators

Relational Operators

Logical Operators

Bitwise Operators

Assignment Operators

Misc Operators
This chapter will examine the arithmetic,
relational, and logical, bitwise, assignment and
other operators one by one.

Arithmetic Operators:
There are following arithmetic
supported by C++ language:

operators

Assume variable A holds 10 and variable B

holds 20 then:
Show Examples
Operator Description

Example

Adds two
operands

A + B will give
30

Subtracts
second
operand from
the first

A - B will give 10

Multiply both
operands

A * B will give
200

Divide
numerator by
de-numerator

B / A will give 2

Modulus
Operator and
B % A will give
remainder of
0
after an integer
division

++

Increment
operator,
increases
integer value
by one

A++ will give

11

--

Decrement
operator,
decreases
integer value
by one

A-- will give 9

Relational Operators:
There are following relational
supported by C++ language

operators

Assume variable A holds 10 and variable B

holds 20 then:
Show Examples
Operator Description

Example

==

Checks if the
value of two
operands is
(A == B) is not
equal or not, if
true.
yes then
condition
becomes true.

!=

Checks if the
value of two
operands is
equal or not, if
(A != B) is true.
values are not
equal then
condition
becomes true.

>

Checks if the
value of left
operand is
greater than
(A > B) is not
the value of
true.
right operand,
if yes then
condition
becomes true.

<

Checks if the
value of left
operand is less
than the value
(A < B) is true.
of right
operand, if yes
then condition
becomes true.

>=

Checks if the
value of left
operand is
(A >= B) is not
greater than or
true.
equal to the
value of right
operand, if yes

then condition
becomes true.

<=

Checks if the
value of left
operand is less
than or equal
(A <= B) is
to the value of
true.
right operand,
if yes then
condition
becomes true.

Logical Operators:
There are following logical operators supported
by C++ language
Assume variable A holds 1 and variable B holds
0 then:
Show Examples
Operator Description
&&

Example

Called Logical (A && B) is

AND operator. false.

If both the
operands are
non zero then
condition
becomes true.

||

Called Logical
OR Operator. If
any of the two
operands is
(A || B) is true.
non zero then
condition
becomes true.

Called Logical
NOT Operator.
Use to
reverses the
logical state of
!(A && B) is
its operand. If a
true.
condition is
true then
Logical NOT
operator will
make false.

Bitwise Operators:
Bitwise operator works on bits and perform bit
by bit operation. The truth tables for &, |, and ^
are as follows:
p

p&q

p|q

p^q

Assume if A = 60; and B = 13; Now in binary

format they will be as follows:

A = 0011 1100
B = 0000 1101
----------------A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
The Bitwise operators supported by C++
language are listed in the following table.
Assume variable A holds 60 and variable B
holds 13 then:
Show Examples
Operator Description

Example

&

Binary AND
Operator
copies a bit to
the result if it
exists in both
operands.

(A & B) will
give 12 which
is 0000 1100

Binary OR

(A | B) will give

Operator
61 which is
copies a bit if it 0011 1101
exists in either
operand.

Binary XOR
Operator
(A ^ B) will give
copies the bit if
49 which is
it is set in one
0011 0001
operand but
not both.

Binary Ones
Complement
(~A ) will give Operator is
60 which is
unary and has
1100 0011
the effect of
'flipping' bits.

<<

Binary Left
Shift Operator.
The left
A << 2 will give
operands value
240 which is
is moved left by
1111 0000
the number of
bits specified
by the right

operand.

>>

Binary Right
Shift Operator.
The left
operands value A >> 2 will give
is moved right 15 which is
by the number 0000 1111
of bits specified
by the right
operand.

Assignment Operators:
There are following assignment operators
supported by C++ language:
Show Examples
Operator Description

Example

Simple
assignment
operator,
C = A + B will
Assigns values assign value of
from right side A + B into C
operands to left
side operand

+=

Add AND
assignment
operator, It
adds right
C += A is
operand to the equivalent to C
left operand
=C+A
and assign the
result to left
operand

-=

Subtract AND
assignment
operator, It
subtracts right
C -= A is
operand from
equivalent to C
the left
=C-A
operand and
assign the
result to left
operand

*=

Multiply AND
assignment
C *= A is
operator, It
equivalent to C
multiplies right = C * A
operand with

the left
operand and
assign the
result to left
operand

/=

Divide AND
assignment
operator, It
divides left
operand with
the right
operand and
assign the
result to left
operand

%=

Modulus AND
assignment
operator, It
takes modulus C %= A is
using two
equivalent to C
operands and = C % A
assign the
result to left
operand

C /= A is
equivalent to C
=C/A

<<=

Left shift AND

assignment
operator

C <<= 2 is
same as C = C
<< 2

>>=

Right shift AND C >>= 2 is

assignment
same as C = C
operator
>> 2

&=

Bitwise AND
assignment
operator

C &= 2 is same
as C = C & 2

^=

bitwise
exclusive OR
and
assignment
operator

C ^= 2 is same
as C = C ^ 2

|=

bitwise
inclusive OR
and
assignment
operator

C |= 2 is same
as C = C | 2

Misc Operators:

There are few other operators supported by

C++ Language.
Operator

Description

sizeof

sizeof operator returns the

size of a variable. For
example sizeof(a), where a is
integer, will return 4.

Conditional operator. If
Condition ? Condition is true ? then it
X:Y
returns value X : otherwise
value Y

Comma operator causes a

sequence of operations to be
performed. The value of the
entire comma expression is
the value of the last
expression of the commaseparated list.

Member operators are used

. (dot) and - to reference individual
> (arrow)
members of classes,
structures, and unions.
Cast

Casting operators convert

one data type to another. For

example, int(2.2000) would
return 2.

&

Pointer operator & returns

the address of an variable.
For example &a; will give
actual address of the
variable.

Pointer operator * is pointer

to a variable. For example
*var; will pointer to a variable
var.

Operators
Precedence in
C++:
Operator precedence determines the grouping
of terms in an expression. 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 get 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.
Show Examples
Category
Operator

Associativity

Postfix

() [] -> . ++ Left to right

-

Unary

+ - ! ~ ++ - (type)* &
Right to left
sizeof

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

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

There may be a situation when you need to

execute a block of code several number of
times. In general statements are executed
sequentially: The first statement in a function is
executed first, followed by the second, and so
on.

Programming languages provide various control

structures that allow for more complicated
execution paths.
A loop statement allows us to execute a
statement or group of statements multiple times
and following is the general from of a loop
statement in most of the programming
languages:

C++ programming language provides following

types of loop to handle looping requirements.
Click the following links to check their detail.
Loop Type Description

while loop

Repeats a statement or
group of statements while a
given condition is true. It
tests the condition before
executing the loop body.

for loop

Execute a sequence of
statements multiple times
and abbreviates the code
that manages the loop
variable.

do...while
loop

Like a while statement,

except that it tests the
condition at the end of the
loop body

nested
loops

You can use one or more

loop inside any another
while, for or do..while loop.

Loop Control
Statements:

Loop control statements change execution from

its normal sequence. When execution leaves a
scope, all automatic objects that were created
in that scope are destroyed.
C++ supports the following control statements.
Click the following links to check their detail.
Control
Description
Statement
break
statement

Terminates
the loop or switch statement
and transfers execution to
the statement immediately
following the loop or switch.

continue
statement

Causes the loop to skip the

remainder of its body and
immediately retest its
condition prior to reiterating.

goto
statement

Transfers control to the

labeled statement. Though it
is not advised to use goto
statement in your program.

The Infinite
Loop:
A loop becomes infinite loop if a condition never
becomes false. The for loop is traditionally
used for this purpose. Since none of the three
expressions that form the for loop are required,
you can make an endless loop by leaving the
conditional expression empty.
#include <iostream>
using namespace std;
int main ()
{
for( ; ; )
{
printf("This loop will run
forever.\n");
}

return 0;
}
When the conditional expression is absent, it is
assumed to be true. You may have an
initialization and increment expression, but C++
programmers more commonly use the for(;;)
construct to signify an infinite loop.
NOTE: You can terminate an infinite loop by
pressing Ctrl + C keys.
Decision making structures require that the
programmer specify one or more conditions to
be evaluated or tested by the program, along
with a statement or statements to be executed if
the condition is determined to be true, and
optionally, other statements to be executed if
the condition is determined to be false.
Following is the general from of a typical
decision making structure found in most of the
programming languages:

C++ programming language provides following

types of decision making statements. Click the
following links to check their detail.
Statement

Description

if statement

An if statement consists of
a boolean expression
followed by one or more
statements.

if...else
statement

An if statement can be
followed by an optional
else statement, which
executes when the
boolean expression is

false.
switch
statement

A switch statement allows

a variable to be tested for
equality against a list of
values.

nested if
statements

You can use one if or else

if statement inside another
if or else if statement(s).

You can use one swicth

nested switch
statement inside another
statements
switch statement(s).

The ? :
Operator:
We have covered conditional operator ? : in
previous chapter which can be used to
replace if...elsestatements. It has the following
general form:
Exp1 ? Exp2 : Exp3;

Where Exp1, Exp2, and Exp3 are expressions.

Notice the use and placement of the colon.
The value of a ? expression is determined like
this: Exp1 is evaluated. If it is true, then Exp2 is
evaluated and becomes the value of the entire
? expression. If Exp1 is false, then Exp3 is
evaluated and its value becomes the value of
the expression.
A function is a group of statements that
together perform a task. Every C++ program
has at least one function which is main(), and
all the most trivial programs can define
additional functions.
You can divide up your code into separate
functions. How you divide up your code among
different functions is up to you, but logically the
division usually is so each function performs a
specific task.
A function declaration tells the compiler about
a function's name, return type, and parameters.
A function definition provides the actual body
of the function.

The C++ standard library provides numerous

built-in functions that your program can call. For
example, function strcat() to concatenate two
strings,
function memcpy() to
copy
one
memory location to another location and many
more functions.
A function is knows as with various names like
a method or a sub-routine or a procedure etc.

Defining a
Function:
The general form of a C++ function definition is
as follows:
return_type function_name(
parameter list )
{
body of the function
}

A C++ function definition consists of a function

header and a function body. Here are all the
parts of a function:

Return Type: A function may return a value.

The return_type is the data type of the value
the function returns. Some functions perform
the desired operations without returning a
value. In this case, the return_type is the
keyword void.
Function Name: This is the actual name of the
function. The function name and the parameter
list together constitute the function signature.
Parameters: A parameter is like a placeholder.
When a function is invoked, you pass a value to
the parameter. This value is referred to as
actual parameter or argument. The parameter
list refers to the type, order, and number of the
parameters of a function. Parameters are
optional; that is, a function may contain no
parameters.
Function Body: The function body contains a
collection of statements that define what the
function does.

Example:
Following is the source code for a function
called max().
This
function
takes
two
parameters num1 and num2 and returns the
maximum between the two:
// function returning the max
between two numbers
int max(int num1, int num2)
{
// local variable declaration
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}

Function
Declarations:
A function declaration tells the compiler about
a function name and how to call the function.
The actual body of the function can be defined
separately.
A function declaration has the following parts:
return_type function_name(
parameter list );
For the above defined function max(), following
is the function declaration:
int max(int num1, int num2);
Parameter names are not importan in function
declaration only their type is required, so
following is also valid declaration:
int max(int, int);

Function declaration is required when you

define a function in one source file and you call
that function in another file. In such case you
should declare the function at the top of the file
calling the function.

Calling a
Function:
While creating a C++ function, you give a
definition of what the function has to do. To use
a function, you will have to call or invoke that
function.
When a program calls a function, program
control is transferred to the called function. A
called function performs defined task and when
its return statement is executed or when its
function-ending closing brace is reached, it
returns program control back to the main
program.

To call a function you simply need to pass the

required parameters along with function name
and if function returns a value then you can
store returned value. For example:
#include <iostream>
using namespace std;
// function declaration
int max(int num1, int num2);
int main ()
{
// local variable declaration:
int a = 100;
int b = 200;
int ret;
// calling a function to get max
value.
ret = max(a, b);
cout << "Max value is : " << ret
<< endl;
return 0;

}
// function returning the max
between two numbers
int max(int num1, int num2)
{
// local variable declaration
int result;
if (num1 > num2)
result = num1;
else
result = num2;
}

return result;

I kept max() function along with main() function

and complied the source code. While running
final executable, it would produce following
result:
Max value is : 200

Function
Arguments:
If a function is to use arguments, it must declare
variables that accept the values of the
arguments. These variables are called
the formal parameters of the function.
The formal parameters behave like other local
variables inside the function and are created
upon entry into the function and destroyed upon
exit.
While calling a function, there are two ways that
arguments can be passed to a function:
Call Type

Description

Call by
value

This method copies the

actual value of an argument
into the formal parameter of
the function. In this case,
changes made to the

parameter inside the function

have no effect on the
argument.

Call by
pointer

This method copies the

address of an argument into
the formal parameter. Inside
the function, the address is
used to access the actual
argument used in the call.
This means that changes
made to the parameter affect
the argument.

This method copies the

reference of an argument
into the formal parameter.
Inside the function, the
Call by
reference is used to access
reference the actual argument used in
the call. This means that
changes made to the
parameter affect the
argument.
By default, C++ uses call by value to pass
arguments. In general, this means that code

within a function cannot alter the arguments

used to call the function and above mentioned
example while calling max() function used the
same method.

Default
Values for
Parameters:
When you define a function you can specify a
default value for for each of the last parameters.
This value will be used if the corresponding
argument is left blank when calling to the
function.
This is done by using the assignment operator
and assigning values for the arguments in the
function definition. If a value for that parameter
is not passed when the function is called, the
default given value is used, but if a value is

specified this default value is ignored and the

passed value is used instead. Consider the
following example:
#include <iostream>
using namespace std;
int sum(int a, int b=20)
{
int result;
result = a + b;
}

return (result);

int main ()
{
// local variable declaration:
int a = 100;
int b = 200;
int result;
// calling a function to add the
values.
result = sum(a, b);

cout << "Total value is :" <<

result << endl;
// calling a function again as
follows.
result = sum(a);
cout << "Total value is :" <<
result << endl;
return 0;
}
When the above code is compiled and
executed, it produces following result:
Total value is :300
Total value is :120

ormally, when we work with Numbers, we use

primitive data types such as int, short, long,
float and double etc. The number data types,
their possible values and number ranges have

been explained while discussing C++ Data

Types.

Defining
Numbers in
C++:
You have already defined numbers in various
examples given in previous chapters. Here is
another consolidated example to define various
types of numbers in C++:
#include <iostream>
using namespace std;
int main ()
{
// number definition:
short s;
int
i;

long
l;
float f;
double d;
// number assignments;
s = 10;
i = 1000;
l = 1000000;
f = 230.47;
d = 30949.374;
// number printing;
cout << "short s :"
endl;
cout << "int
i :"
endl;
cout << "long
l :"
endl;
cout << "float f :"
endl;
cout << "double d :"
endl;
return 0;
}

<< s <<
<< i <<
<< l <<
<< f <<
<< d <<

When the above code is compiled and

executed, it produces following result:
short
int
long
float
double

s
i
l
f
d

:10
:1000
:1000000
:230.47
:30949.4

Math
Operations in
C++:
In addition to the various functions you can
create, C++ also includes some useful functions
you can use. These functions are available in
standard C and C++ libraries and called builtin functions. These are functions that can be
included in your program and then use.

C++ has a rich set of mathematical operations

which can be performed on various numbers.
Following table list down some useful built-in
mathematical functions available in C++.
To utilize these functions you need to include
the math header file <cmath>.
S.N. Function & Purpose
1

double cos(double);
This function takes an angle (as a
double) and returns the cosine.

double sin(double);
This function takes an angle (as a
double) and returns the sine.

double tan(double);
This function takes an angle (as a
double) and returns the tangent.

double log(double);
This function takes a number and
returns the natural log of that
number.

double pow(double, double);

The first is a number you wish to
raise and the second is the power

you wish to raise it to.

double hypot(double, double);

If you pass this function the length of
two sides of a right triangle, it will
return you the length of the
hypotenuse.

double sqrt(double);
You pass this function a number and
it gives you this square root.

int abs(int);
This function returns the absolute
value of an integer that is passed to
it.

double fabs(double);
This function returns the absolute
value of any decimal number passed
to it.

10

double floor(double);
Finds the integer which is less than
or equal to the argument passed to
it.

Following a simple example to show few of the

mathematical operations:

#include <iostream>
#include <cmath>
using namespace std;
int main ()
{
// number definition:
short s = 10;
int
i = -1000;
long
l = 100000;
float f = 230.47;
double d = 200.374;
// mathematical operations;
cout << "sin(d) :" << sin(d) <<
endl;
cout << "abs(i) :" << abs(i) <<
endl;
cout << "floor(d) :" << floor(d)
<< endl;
cout << "sqrt(f) :" << sqrt(f)
<< endl;
cout << "pow( d, 2) :" << pow(d,
2) << endl;

return 0;
}
When the above code is compiled and
executed, it produces following result:
sign(d) :-0.634939
abs(i) :1000
floor(d) :200
sqrt(f) :15.1812
pow( d, 2 ) :40149.7

Random
Numbers in
C++:
There are many cases where you will wish to
generate a random number. There are actually
two functions you will need to know about
random number generation. The first is rand(),
this function will only return a pseudo random

number. The way to fix this is to first call

the srand() function.
Following a simple example to generate few
random numbers. This example makes use
of time()function to get the number of seconds
on your system time, to randomly seed the
rand() function:
#include <iostream>
#include <ctime>
using namespace std;
int main ()
{
int i,j;
// set the seed
srand( (unsigned)time( NULL ) );
*/

/* generate 10

random numbers.

for( i = 0; i < 10; i++ )

{
// generate actual random
number

j= rand();
cout <<" Random Number : " <<
j << endl;
}
return 0;
}
When the above code is compiled and
executed, it produces following result:
Random
Random
Random
Random
Random
Random
Random
Random
Random
Random

Number
Number
Number
Number
Number
Number
Number
Number
Number
Number

:
:
:
:
:
:
:
:
:
:

1748144778
630873888
2134540646
219404170
902129458
920445370
1319072661
257938873
1256201101
580322989

C++ provides a data structure, the array, which

stores a fixed-size sequential collection of
elements of the same type. An array is used to
store a collection of data, but it is often more
useful to think of an array as a collection of
variables of the same type.
Instead of declaring individual variables, such
as number0, number1, ..., and number99, you
declare one array variable such as numbers
and use numbers[0], numbers[1], and ...,
numbers[99] to represent individual variables. A
specific element in an array is accessed by an
index.
All arrays consist of contiguous memory
locations. The lowest address corresponds to
the first element and the highest address to the
last element.

Declaring
Arrays:

To declare an array in C++, the programmer

specifies the type of the elements and the
number of elements required by an array as
follows:
type arrayName [ arraySize ];
This is called a single-dimension array.
The arraySize must be an integer constant
greater than zero and type can be any valid
C++ data type. For example, to declare a 10element array called balance of type double,
use this statement:
double balance[10];

Initializing
Arrays:
You can initialize C++ array elements either
one by one or using a single statement as
follows:

double balance[5] = {1000.0, 2.0,

3.4, 17.0, 50.0};
The number of values between braces { } can
not be larger than the number of elements that
we declare for the array between square
brackets [ ]. Following is an example to assign a
single element of the array:
If you omit the size of the array, an array just
big enough to hold the initialization is created.
Therefore, if you write:
double balance[] = {1000.0, 2.0,
3.4, 17.0, 50.0};
You will create exactly the same array as you
did in the previous example.
balance[4] = 50.0;
The above statement assigns element number
5th in the array a value of 50.0. Array with 4th
index will be 5th ie. last element because all
arrays have 0 as the index of their first element
which is also called base index. Following is the
pictorial representaion of the same array we
discussed above:

Accessing
Array
Elements:
An element is accessed by indexing the array
name. This is done by placing the index of the
element within square brackets after the name
of the array. For example:
double salary = balance[9];
The above statement will take 10th element
from the array and assign the value to salary
variable. Following is an example which will use
all the above mentioned three concepts viz.
declaration, assignment and accessing arrays:
#include <iostream>

using namespace std;

#include <iomanip>
using std::setw;
int main ()
{
int n[ 10 ]; // n is an array of
10 integers
// initialize elements of array
n to 0
for ( int i = 0; i < 10; i++ )
{
n[ i ] = i + 100; // set
element at location i to i + 100
}
cout << "Element" << setw( 13 )
<< "Value" << endl;
// output each array element's
value
for ( int j = 0; j < 10; j++ )
{

cout << setw( 7 )<< j <<

setw( 13 ) << n[ j ] << endl;
}
return 0;
}
This program makes use setw() function to
format the output. When the above code is
compiled and executed, it produces following
result:
Element
Value
0
100
1
101
2
102
3
103
4
104
5
105
6
106
7
107
8
108
9
109

C++ Arrays in
Detail:
Arrays are important to C++ and should need
lots of more detail. There are following few
important concepts which should be clear to a
C++ programmer:
Concept

Description

Multidimensional
arrays

C++ supports
multidimensional arrays.
The simplest form of the
multidimensional array is
the two-dimensional
array.

Pointer to an
array

You can generate a

pointer to the first
element of an array by

simply specifying the

array name, without any
index.

Passing arrays
to functions

You can pass to the

function a pointer to an
array by specifying the
array's name without an
index.

Return array
from functions

C++ allows a function to

return an array.

C++ allows multidimensional arrays. Here is the

general form of a multidimensional array
declaration:
type name[size1][size2]...[sizeN];
For example, the following declaration creates a
three dimensional 5 . 10 . 4 integer array:
int threedim[5][10][4];

TwoDimensional
Arrays:
The simplest form of the multidimensional array
is the two-dimensional array. A two-dimensional
array is, in essence, a list of one-dimensional
arrays. To declare a two-dimensional integer
array of size x,y you would write something as
follows:
type arrayName [ x ][ y ];
Where type can be any valid C++ data type
and arrayName will be a valid C++ identifier.
A two dimensional array can be think as a table
which will have x number of rows and y number
of columns. A 2-dimentional array a which
contains three rows and four columns can be
shown as below:

Thus, every element in array a is identified by

an element name of the form a[ i ][ j ], where a
is the name of the array, and i and j are the
subscripts that uniquely identify each element in
a.

Initializing
TwoDimensional
Arrays:
Multidimensioned arrays may be initialized by
specifying bracketed values for each row.

Following is an array with 3 rows and each row

have 4 columns.
int a[3][4] = {
{0, 1, 2, 3} ,
/* initializers
for row indexed by 0 */
{4, 5, 6, 7} ,
/* initializers
for row indexed by 1 */
{8, 9, 10, 11}
/* initializers
for row indexed by 2 */
};
The nested braces, which indicate the intended
row, are optional. The following initialization is
equivalent to previous example:
int a[3][4] =
{0,1,2,3,4,5,6,7,8,9,10,11};

Accessing
Two-

Dimensional
Array
Elements:
An element in 2-dimensional array is accessed
by using the subscripts ie. row index and
column index of the array. For example:
int val = a[2][3];
The above statement will take 4th element from
the 3rd row of the array. You can verify it in the
above digram.
#include <iostream>
using namespace std;
int main ()
{

// an array with 5 rows and 2

columns.
int a[5][2] = { {0,0}, {1,2},
{2,4}, {3,6},{4,8}};
// output each array element's
value
for ( int i = 0; i < 5; i++ )
for ( int j = 0; j < 2; j++ )
{
cout << "a[" << i << "]["
<< j << "]: ";
cout << a[i][j]<< endl;
}
return 0;
}
When the above code is compiled and
executed, it produces following result:
a[0][0]:
a[0][1]:
a[1][0]:
a[1][1]:
a[2][0]:

0
0
1
2
2

a[2][1]:
a[3][0]:
a[3][1]:
a[4][0]:
a[4][1]:

4
3
6
4
8

As explained above, you can have arrays with

any number of dimensions, although it is likely
that most of the arrays you create will be of one
or two dimensions.

The main purpose of C++ programming is to

add object orientation to the C programming
language and classes are the central feature of
C++ that supports object-oriented programming
and are often called user-defined types.
A class is used to specify the form of an object
and it combines data representation and
methods for manipulating that data into one
neat package. The data and functions within a
class are called members of the class.

C++ Class
Definitions:
When you define a class, you define a blueprint
for a data type. This doesn't actually define any
data, but it does define what the class name
means, that is, what an object of the class will
consist of and what operations can be
performed on such an object.
A
class
definition
starts
with
the
keyword class followed by the class name; and
the class body, enclosed by a pair of curly
braces. A class definition must be followed
either by a semicolon or a list of declarations.
For example we defined the Box data type
using the keyword class as follows:
class Box
{
public:
double length;
// Length of
a box

double breadth; // Breadth

of a box
double height;
// Height of
a box
};
The keyword public determines the access
attributes of the members of the class that
follow it. A public member can be accessed
from outside the class anywhere within the
scope of the class object. You can also specify
the
members
of
a
class
as private or protected which we will discuss
in a sub-section.

Define C++
Objects:
A class provides the blueprints for objects, so
basically an object is created from a class. We
declare objects of a class with exactly the same
sort of declaration that we declare variables of

basic types. Following statements declare two

objects of class Box:
Box Box1;
of type Box
Box Box2;
of type Box

// Declare Box1
// Declare Box2

Both of the objects Box1 and Box2 will have

their own copy of data members.

Accessing the
Data
Members:
The public data members of objects of a class
can be accessed using the direct member
access operator (.). Let us try following example
to make the things clear:
#include <iostream>

using namespace std;

class Box
{
public:
double length;
a box
double breadth;
of a box
double height;
a box
};

// Length of
// Breadth
// Height of

int main( )
{
Box Box1;
// Declare Box1
of type Box
Box Box2;
// Declare Box2
of type Box
double volume = 0.0;
//
Store the volume of a box here
// box 1 specification
Box1.height = 5.0;

Box1.length = 6.0;
Box1.breadth = 7.0;
// box 2 specification
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
// volume of box 1
volume = Box1.height *
Box1.length * Box1.breadth;
cout << "Volume of Box1 : " <<
volume <<endl;
// volume of box 2
volume = Box2.height *
Box2.length * Box2.breadth;
cout << "Volume of Box2 : " <<
volume <<endl;
return 0;
}
When the above code is compiled and
executed, it produces following result:
Volume of Box1 : 210
Volume of Box2 : 1560

It is important to note that private and protected

members can not be accessed directly using
direct member access operator (.). We will learn
how private and protected members can be
accessed.

Classes & Objects in Detail:

So far you have got very basic idea about C++
Classes and Objects. There are further
interesting concepts related to C++ Classes
and Objects which we will discuss in various
sub-sections listed below:
Concept

Description

Class member
functions

A member function of a
class is a function that
has its definition or its
prototype within the
class definition like any
other variable.

Class access

A class member can be

defined as public, private

modifiers

or protected. By default
members would be
assumed as private.

Constructor &
destructor

A class constructor is a
special function in a
class that is called when
a new object of the class
is created. A destructor
is also a special function
which is called when
created object is
deleted.

C++ copy
constructor

The copy constructor is

a constructor which
creates an object by
initializing it with an
object of the same class,
which has been created
previously.

C++ friend

A friend function is

functions

C++ inline
functions

permitted full access to

private and protected
members of a class.
With an inline function,
the compiler tries to
expand the code in the
body of the function in
place of a call to the
function.

Every object has a

The this pointer special
in C++
pointer this which points
to the object itself.

Pointer to C++
classes

A pointer to a class is
done exactly the same
way a pointer to a
structure is. In fact a
class is really just a
structure with functions

in it.
Both data members and
Static members function members of a
of a class
class can be declared as
static.

C++ Class Definitions:

C++ Class
A class is the collection of related data and function under
a single name. A C++ program can have any number of
classes. When related data and functions are kept under a
class, it helps to visualize the complex problem efficiently
and effectively.

A Class is a blueprint for objects

1

When a class is defined, no memory is allocated. You can

imagine like a datatype.
int var;
The above code specifies var is a variable of type integer;
int is used for specifying variable var is of integer type.
Similarly, class are also just the specification for objects
and object bears the property of that class.
Defining the Class in C++
Class is defined in C++ programming using keyword class
followed by identifier(name of class). Body of class is
defined inside curly brackets an terminated by semicolon
at the end in similar way as structure.
class class_name
{
// some data
// some functions
};
When you define a class, you define a blueprint for a data
type. This doesn't actually define any data, but it does
define what the class name means, that is, what an object
of the class will consist of and what operations can be
performed on such an object.
A class definition starts with the keyword class followed
by the class name; and the class body, enclosed by a pair
of curly braces. A class definition must be followed either
by a semicolon or a list of declarations. For example we
2

defined the Box data type using the keyword class as

follows:
class Box
{
public:
double length;
// Length of a box
double breadth; // Breadth of a box
double height;
// Height of a box
};
The keyword public determines the access attributes of
the members of the class that follow it. A public member
can be accessed from outside the class anywhere within
the scope of the class object. You can also specify the
members of a class as private or protected which we will
discuss in a sub-section.
Define C++ Objects:
C++ Objects
When class is defined, only specification for the object is
defined. Object has same relationship to class as variable
has with the data type. Objects can be defined in similary
way as structure is defined.
Syntax to Define Object in C++
class_name variable name;
For the above defined class temp, objects for that class
can be defined as:
temp obj1,obj2;
3

Here, two objects(obj1 and obj2) of temp class are

defined.
Data member and Member functions
The data within the class is known as data member. The
function defined within the class is known as member
function. These two technical terms are frequently used in
explaining OOP. In the above
class temp, data1 and data2are data members
and func1() and func2() are member functions.
Accessing Data Members and Member functions
Data members and member functions can be accessed in
similar way the member of structure is accessed using
member operator(.). For the class and object defined
above, func1() for object obj2 can be called using code:
obj2.func1();
Similary, the data member can be accessed as:
object_name.data_memeber;
Example to Explain Working of Object and Class in C++
Programming
/* Program to illustrate working of Objects
and Class in C++ Programming */
#include <iostream>
using namespace std;
class temp
{
4

int data1;
float data2;
void int_data(int d){
data1=d;
cout<<"Number: "<<data1;
}
float float_data(){
cout<<"\nEnter data: ";
cin>>data2;
return data2;
}
};
int main(){
temp obj1, obj2;
obj1.int_data(12);
cout<<"You entered
"<<obj2.float_data();
return 0;
}
Output:
Number: 12
Enter data: 12.43
You entered: 12.43
Explanation of Program
In this program, two data members data1 and data2 and
two member function int_data() and float_data() are
defined under temp class. Two objects obj1 and obj2 of
that class are declared. Function int_data() for the obj1 is
5

executed using code obj1.int_data(12);, which sets 12 to

the data1 of object obj1. Then, function float_data() for
the objectobj2 is executed which takes data from user;
stores it in data2 of obj2 and returns it to the calling
function.
Note: In this program, data2 for
object obj1 and data1 for object obj2 is not used and
contains garbage value.

Defining Member Function Outside the Class

A large program may contain many member functions. For
the clarity of the code, member functions can be defined
outside the class. To do so, member function should be
declared inside the class(function prototype should be
inside the class). Then, the function definition can be
defined using scope resolution operator ::. Learn more
about defining member function outside the class.
A class provides the blueprints for objects, so basically an
object is created from a class. We declare objects of a
class with exactly the same sort of declaration that we
declare variables of basic types. Following statements
declare two objects of class Box:
6

Box Box1;
Box
Box Box2;
Box

// Declare Box1 of type

// Declare Box2 of type

Both of the objects Box1 and Box2 will have their own
copy of data members.
Accessing the Data Members:
The public data members of objects of a class can be
accessed using the direct member access operator (.). Let
us try following example to make the things clear:
#include <iostream>
using namespace std;
class Box
{
public:
double length;
double breadth;
double height;
};
int main( )
{
Box Box1;
//Box
Box Box2;
//Box

// Length of a box
// Breadth of a box
// Height of a box

// Declare Box1 of type

// Declare Box2 of type

double volume = 0.0;

volume of a box here

// Store the

// box 1 specification
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
// box 2 specification
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
// volume of box 1
volume = Box1.height * Box1.length *
Box1.breadth;
cout << "Volume of Box1 : " << volume
<<endl;
// volume of box 2
volume = Box2.height * Box2.length *
Box2.breadth;
cout << "Volume of Box2 : " << volume
<<endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Volume of Box1 : 210
Volume of Box2 : 1560
8

It is important to note that private and protected members

can not be accessed directly using direct member access
operator (.). We will learn how private and protected
members can be accessed.
Classes & Objects in Detail:
So far you have got very basic idea about C++ Classes
and Objects. There are further interesting concepts related
to C++ Classes and Objects which we will discuss in
various sub-sections listed below:
Concept

Description

Class member
functions

A member function of a class

is a function that has its
definition or its prototype
within the class definition like
any other variable.

Class access
modifiers

A class member can be

defined as public, private or
protected. By default
members would be assumed
as private.

Constructor &
destructor

A class constructor is a
special function in a class that
is called when a new object of
the class is created. A
9

destructor is also a special

function which is called when
created object is deleted.

C++ copy
constructor

The copy constructor is a

constructor which creates an
object by initializing it with an
object of the same class,
which has been created
previously.

C++ friend
functions

A friend function is permitted

full access to private and
protected members of a class.

With an inline function, the

compiler tries to expand the
C++ inline functions code in the body of the
function in place of a call to
the function.
The this pointer in
C++

Every object has a special

pointer this which points to
the object itself.

Pointer to C++
classes

A pointer to a class is done

exactly the same way a
pointer to a structure is. In fact
10

a class is really just a

structure with functions in it.
Both data members and
Static members of a
function members of a class
class
can be declared as static.

Data hiding is one of the important features of Object

Oriented Programming which allows preventing the
functions of a program to access directly the internal
representation of a class type. The access restriction to
the class members is specified by the labeled public,
private, and protected sections within the class body.
The keywords public, private, and protected are called
access specifiers.
A class can have multiple public, protected, or private
labeled sections. Each section remains in effect until either
another section label or the closing right brace of the class
body is seen. The default access for members and
classes is private.
class Base {
public:
// public members go here
protected:
11

// protected members go here

private:
// private members go here
};
The public members:
A public member is accessible from anywhere outside the
class but within a program. You can set and get the value
of public variables without any member function as shown
in the following example:
#include <iostream>
using namespace std;
class Line
{
public:
double length;
void setLength( double len );
double getLength( void );
};
// Member functions definitions
double Line::getLength(void)
{
return length ;
}
12

void Line::setLength( double len )

{
length = len;
}
// Main function for the program
int main( )
{
Line line;
// set line length
line.setLength(6.0);
cout << "Length of line : " <<
line.getLength() <<endl;
// set line length without member
function
line.length = 10.0; // OK: because
length is public
cout << "Length of line : " <<
line.length <<endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Length of line : 6
Length of line : 10
The private members:
13

A private member variable or function cannot be

accessed, or even viewed from outside the class. Only the
class and friend functions can access private members.
By default all the members of a class would be private, for
example in the following class width is a private member,
which means until you label a member, it will be assumed
a private member:
class Box
{
double width;
public:
double length;
void setWidth( double wid );
double getWidth( void );
};
Practically, we define data in private section and related
functions in public section so that they can be called from
outside of the class as shown in the following program.
#include <iostream>
using namespace std;
class Box
{
public:
double length;
void setWidth( double wid );
double getWidth( void );
14

private:
double width;
};
// Member functions definitions
double Box::getWidth(void)
{
return width ;
}
void Box::setWidth( double wid )
{
width = wid;
}
// Main function for the program
int main( )
{
Box box;
// set box length without member
function
box.length = 10.0; // OK: because length
is public
cout << "Length of box : " << box.length
<<endl;
// set box width without member function
// box.width = 10.0; // Error: because
width is private
15

box.setWidth(10.0); // Use member

function to set it.
cout << "Width of box : " <<
box.getWidth() <<endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Length of box : 10
Width of box : 10
The protected members:
A protected member variable or function is very similar to
a private member but it provided one additional benefit
that they can be accessed in child classes which are
called derived classes.
You will learn derived classes and inheritance in next
chapter. For now you can check following example where I
have derived one child class SmallBox from a parent
class Box.
Following example is similar to above example and
here width member will be accessible by any member
function of it's derived class SmallBox.
using namespace std;
class Box
{
protected:
double width;
16

};
class SmallBox:Box // SmallBox is the
derived class.
{
public:
void setSmallWidth( double wid );
double getSmallWidth( void );
};
// Member functions of child class
double SmallBox::getSmallWidth(void)
{
return width ;
}
void SmallBox::setSmallWidth( double wid )
{
width = wid;
}
// Main function for the program
int main( )
{
SmallBox box;
// set box width using member function
box.setSmallWidth(5.0);
cout << "Width of box : "<<
box.getSmallWidth() << endl;
17

return 0;
}
When the above code is compiled and executed, it
produces following result:
Width of box : 5
A member function of a class is a function that has its
definition or its prototype within the class definition like any
other variable. It operates on any object of the class of
which it is a member, and has access to all the members
of a class for that object.
Let us take previously defined class to access the
members of the class using a member function instead of
directly accessing them:
class Box
{
public:
double
box
double
a box
double
box
double
volume
};

length;

// Length of a

breadth;

// Breadth of

height;

// Height of a

getVolume(void);// Returns box

18

Member functions can be defined within the class

definition or separately using scope resolution operator,
::. Defining a member function within the class definition
declares the function inline, even if you do not use the
inline
specifier.
So
either
you
can
define Volume() function as below:
class Box
{
public:
double length;
// Length of a
box
double breadth;
// Breadth of a
box
double height;
// Height of a
box
double getVolume(void)
{
return length * breadth * height;
}
};
If you like you can define same function outside the class
using scope resolution operator, :: as follows:
double Box::getVolume(void)
{
return length * breadth * height;
}
Here only important point is that you would have to use
class name just before :: operator. A member function will

19

be called using an dot operator (.) on a object where it will

manipulate data related to that object only as follows:
Box myBox;
// Create an object
myBox.getVolume();
for the object

// Call member function

Let us put above concepts to set and get the value of

different class members in a class:
#include <iostream>
using namespace std;
class Box
{
public:
double length;
box
double breadth;
a box
double height;
box

// Length of a
// Breadth of
// Height of a

// Member functions declaration

double getVolume(void);
void setLength( double len );
void setBreadth( double bre );
void setHeight( double hei );
};

20

// Member functions definitions

double Box::getVolume(void)
{
return length * breadth * height;
}
void Box::setLength( double len )
{
length = len;
}
void Box::setBreadth( double bre )
{
breadth = bre;
}
void Box::setHeight( double hei )
{
height = hei;
}
// Main function for the program
int main( )
{
Box Box1;
// Declare Box1
of type Box
Box Box2;
// Declare Box2
of type Box
double volume = 0.0;
// Store the
volume of a box here
21

// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// volume of box 1
volume = Box1.getVolume();
cout << "Volume of Box1 : " << volume
<<endl;
// volume of box 2
volume = Box2.getVolume();
cout << "Volume of Box2 : " << volume
<<endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Volume of Box1 : 210
Volume of Box2 : 1560
The Class Constructor:

22

A class constructor is a special member function of a

class that is executed whenever we create new objects of
that class.
A constructor will have exact same name as the class and
it does not have any return type at all, not even void.
Constructors can be very useful for setting initial values for
certain member variables.
..... ... .....
class temporary
{
private:
int x;
float y;
public:
temporary(): x(5), y(5.5)
/* Constructor */
{
/* Body of constructor
*/
}
.... ... ....
}
int main()
{
Temporary t1;
.... ... ....
}
Following example explain the concept of constructor:
23

Constructor Example
/*Source Code to demonstrate the working of
constructor in C++ Programming */
/* This program calculates the area of a
rectangle and displays it. */
#include <iostream>
using namespace std;
class Area
{
private:
int length;
int breadth;
public:
Area(): length(5), breadth(2){ }
/* Constructor */
void GetLength()
{
cout<<"Enter length and breadth
respectively: ";
cin>>length>>breadth;
}
int AreaCalculation() { return
(length*breadth); }
void DisplayArea(int temp)
{
cout<<"Area: "<<temp;
}
};
int main()
{
24

Area A1,A2;
int temp;
A1.GetLength();
temp=A1.AreaCalculation();
A1.DisplayArea(temp);
cout<<endl<<"Default Area when value is
not taken from user"<<endl;
temp=A2.AreaCalculation();
A2.DisplayArea(temp);
return 0;
}
Explanation
In this program, a class of name Area is created to
calculate the area of a rectangle. There are two data
memberslength and breadth. A constructor is defined
which initializes length to 5 and breadth to 2. And, we
have three additional member functions GetLength(),
AreaCalculation() and DisplayArea() to get length from
user, calculate the area and display the area respectively.
When, objects A1 and A2 are created then, the length and
breadth of both objects are initialized to 5 and 2
respectively because of the constructor. Then the member
function GetLength() is invoked which takes the value
oflength and breadth from user for object A1. Then, the
area for the object A1 is calculated and stored in
variable tempby calling AreaCalculation() function. And
finally, the area of object A1 is displayed. For object A2,
25

no data is asked from the user. So, the value of length will
be 5 and breadth will be 2. Then, the area for A2 is
calculated and displayed which is 10.

#include <iostream>
using namespace std;
class Line
{
public:
void setLength( double len );
double getLength( void );
Line(); // This is the constructor

};

private:
double length;

// Member functions definitions including

constructor
Line::Line(void)
{
cout << "Object is being created" <<
endl;
}
void Line::setLength( double len )
{
length = len;
26

}
double Line::getLength( void )
{
return length;
}
// Main function for the program
int main( )
{
Line line;
// set line length
line.setLength(6.0);
cout << "Length of line : " <<
line.getLength() <<endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Object is being created
Length of line : 6
Parameterized Constructor:
A default constructor does not have any paramter but if
you need a constructor can have parameters. This helps
you to assign initial value to an object at the time of its
creation as shown in the following example:

27

/* Source Code to demonstrate the working

of overloaded constructors */
#include <iostream>
using namespace std;
class Area
{
private:
int length;
int breadth;
public:
Area(): length(5), breadth(2){ }
// Constructor without no argument
Area(int l, int b): length(l),
breadth(b){ } // Constructor with two
argument
void GetLength()
{
cout<<"Enter length and breadth
respectively: ";
cin>>length>>breadth;
}
int AreaCalculation() { return
(length*breadth); }
void DisplayArea(int temp)
{
cout<<"Area: "<<temp<<endl;
}
};
int main()
{
28

Area A1,A2(2,1);
int temp;
cout<<"Default Area when no argument is
passed."<<endl;
temp=A1.AreaCalculation();
A1.DisplayArea(temp);
cout<<"Area when (2,1) is passed as
arguement."<<endl;
temp=A2.AreaCalculation();
A2.DisplayArea(temp);
return 0;
}
For object A1, no argument is passed. Thus, the
constructor with no argument is invoked which
initializes length to 5 and breadth to 2. Hence, the area of
object A1 will be 10. For object A2, 2 and 1 is passed as
argument. Thus, the constructor with two argument is
called which initializes length to l(2 in this case)
and breadth to b(1 in this case.). Hence the area of
object A2 will be 2.
#include <iostream>
using namespace std;
class Line
{
public:
void setLength( double len );
double getLength( void );
29

Line(double len);
constructor

};

// This is the

private:
double length;

// Member functions definitions including

constructor
Line::Line( double len)
{
cout << "Object is being created,
length = " << len << endl;
length = len;
}
void Line::setLength( double len )
{
length = len;
}
double Line::getLength( void )
{
return length;
}
// Main function for the program
int main( )
{
Line line(10.0);
// get initially set length.
30

cout << "Length of line : " <<

line.getLength() <<endl;
// set line length again
line.setLength(6.0);
cout << "Length of line : " <<
line.getLength() <<endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Object is being created, length = 10
Length of line : 10
Length of line : 6
The Class Destructor:
A destructor is a special member function of a class that
is executed whenever an object of it's class goes out of
scope or whenever the delete expression is applied to a
pointer to the object of that class.
A destructor will have exact same name as the class
prefixed with a tilde (~) and it can neither return a value
nor can it take any parameters. Destructor can be very
useful for releasing resources before coming out of the
program like closing files, releasing memories etc.
Following example explain the concept of destructor:
#include <iostream>
31

using namespace std;

class Line
{
public:
void setLength( double len );
double getLength( void );
Line();
// This is the constructor
declaration
~Line(); // This is the destructor:
declaration
private:
double length;
};
// Member functions definitions including
constructor
Line::Line(void)
{
cout << "Object is being created" <<
endl;
}
Line::~Line(void)
{
cout << "Object is being deleted" <<
endl;
}
void Line::setLength( double len )
{
32

length = len;
}
double Line::getLength( void )
{
return length;
}
// Main function for the program
int main( )
{
Line line;
// set line length
line.setLength(6.0);
cout << "Length of line : " <<
line.getLength() <<endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Object is being created
Length of line : 6
Object is being deleted

33

The copy constructor is a constructor which creates an

object by initializing it with an object of the same class,
which has been created previously. The copy constructor
is used to:

Initialize one object from another of the same type.

Copy an object to pass it as an argument to a function.

Copy an object to return it from a function.

If a copy constructor is not defined in a class, the compiler
itself defines one.If the class has pointer variables and has
some dynamic memory allocations, then it is a must to
have a copy constructor. The most common form of copy
constructor is shown here:
classname (const classname &obj) {
// body of constructor
}
Here, obj is a reference to an object that is being used to
initialize another object.

34

#include <iostream>
using namespace std;
class Line
{
public:
int getLength( void );
Line( int len );
simple constructor
Line( const Line &obj);
constructor
~Line();
destructor

};

//
// copy
//

private:
int *ptr;

// Member functions definitions including

constructor
Line::Line(int len)
{
cout << "Normal constructor allocating
ptr" << endl;
// allocate memory for the pointer;
ptr = new int;
*ptr = len;
}
Line::Line(const Line &obj)
35

{
cout << "Copy constructor allocating
ptr." << endl;
ptr = new int;
*ptr = *obj.ptr; // copy the value
}
Line::~Line(void)
{
cout << "Freeing memory!" << endl;
delete ptr;
}
int Line::getLength( void )
{
return *ptr;
}
void display(Line obj)
{
cout << "Length of line : " <<
obj.getLength() <<endl;
}
// Main function for the program
int main( )
{
Line line(10);
display(line);
return 0;
36

}
When the above code is compiled and executed, it
produces following result:
Normal constructor allocating ptr
Copy constructor allocating ptr.
Length of line: 10
Freeing memory!
Freeing memory!
Let us see the same example but with a small change to
create another object using existing object of the same
type:
#include <iostream>
using namespace std;
class Line
{
public:
int getLength( void );
Line( int len );
simple constructor
Line( const Line &obj);
constructor
~Line();
destructor
private:
int *ptr;
37

//
// copy
//

};
// Member functions definitions including
constructor
Line::Line(int len)
{
cout << "Normal constructor allocating
ptr" << endl;
// allocate memory for the pointer;
ptr = new int;
*ptr = len;
}
Line::Line(const Line &obj)
{
cout << "Copy constructor allocating
ptr." << endl;
ptr = new int;
*ptr = *obj.ptr; // copy the value
}
Line::~Line(void)
{
cout << "Freeing memory!" << endl;
delete ptr;
}
int Line::getLength( void )
{
return *ptr;
}
38

void display(Line obj)

{
cout << "Length of line : " <<
obj.getLength() <<endl;
}
// Main function for the program
int main( )
{
Line line1(10);
Line line2 = line1; // This also calls
copy constructor
display(line1);
display(line2);
return 0;
}
When the above code is compiled and executed, it
produces following result:
Normal constructor allocating ptr
Copy constructor allocating ptr.
Copy constructor allocating ptr.
Length of line : 10
Freeing memory!
Copy constructor allocating ptr.
Length of line : 10
Freeing memory!
39

Freeing memory!
Freeing memory!
One of the important concept of OOP is data hiding, i.e., a
nonmember function cannot access an object's private or
protected data. But, sometimes this restriction may force
programmer to write long and complex codes. So, there is
mechanism built in C++ programming to access private or
protected data from non-member function which is friend
function and friend class.
friend Function in C++
If a function is defined as a friend function then, the
private and protected data of class can be accessed from
that function. The complier knows a given function is a
friend function by its keyword friend. The declaration of
friend function should be made inside the body of class
(can be anywhere inside class either in private or public
section) starting with keyword friend.
class class_name
{
...... ....
........
friend return_type function_name(argument/s);

......

....

........

}
A friend function of a class is defined outside that class's
scope but it has the right to access all private and
40

protected members of the class. Even though the

prototypes for friend functions appear in the class
definition, friends are not member functions.
A friend can be a function, function template, or member
function, or a class or class template, in which case the
entire class and all of its members are friends.
Now, you can define friend function of that name and that
function can access the private and protected data of that
function. No keywords in used in function definition of
friend function.

Example to Demonstrate working of friend Function

/* C++ program to demonstrate the working
of friend function.*/
#include <iostream>
using namespace std;
class Distance
{
private:
int meter;
41

public:
Distance(): meter(0){ }
friend int func(Distance);
//friend function
};
int func(Distance d)
//function
definition
{
d.meter=5;
//accessing private
data from non-member function
return d.meter;
}
int main()
{
Distance D;
cout<<"Distace: "<<func(D);
return 0;
}
Output
Distance: 5
Here, friend function func() is declared inside Distance
class. So, the private data can be accessed from this
function.
Though this example gives you what idea about the
concept of friend function, this program doesn't give you
idea about when friend function is helpful.

42

Suppose, you need to operate on objects of two different

class then,friend function can be very helpful. You can
operate on two objects of different class without using
friend function but, you program will be long, complex and
hard to understand.
To declare a function as a friend of a class, precede the
function prototype in the class definition with
keyword friend as follows:
class Box
{
double width;
public:
double length;
friend void printWidth( Box box );
void setWidth( double wid );
};
To declare all member functions of class ClassTwo as
friends of class ClassOne, place a following declarationin
the definition of class ClassOne:

43

friend class ClassTwo;

Consider the following program:
#include <iostream>
using namespace std;
class Box
{
double width;
public:
friend void printWidth( Box box );
void setWidth( double wid );
};
// Member function definition
void Box::setWidth( double wid )
{
width = wid;
}
// Note: printWidth() is not a member
function of any class.
void printWidth( Box box )
{
/* Because setWidth() is a friend of
Box, it can
directly access any member of this
class */
cout << "Width of box : " << box.width
<<endl;
44

}
// Main function for the program
int main( )
{
Box box;
// set box width without member function
box.setWidth(10.0);
// Use friend function to print the
wdith.
printWidth( box );
return 0;
}
When the above code is compiled and executed, it
produces following result:
Width of box : 10
Example to operate on Objects of two Different class using
friend Function

#include <iostream>
using namespace std;
45

class B;
// forward declaration
class A {
private:
int data;
public:
A(): data(12){ }
friend int func(A , B);
//friend
function Declaration
};
class B {
private:
int data;
public:
B(): data(1){ }
friend int func(A , B); //friend
function Declaration
};
int func(A d1,B d2)
/*Function func() is the friend function of
both classes A and B. So, the private data
of both class can be accessed from this
function.*/
{
return (d1.data+d2.data);
}
int main()
{
A a;
B b;
cout<<"Data: "<<func(a,b);
return 0;
46

}
In this program, classes A and B has declared func() as a
friend function. Thus, this function can access private data
of both class. In this program, two objects of two different
class A and B are passed as an argument to friend
function. Thus, this function can access private and
protected data of both class. Here, func() function adds
private data of two objects and returns it to main function.
To work this program properly, a forward declaration of a
class should be made as in above example(forward
declaration of class B is made). It is because class B is
referenced from class A using code: friend int func(A , B);.
So, class A should be declared before class B to work
properly.
friend Class in C++ Programming
Similarly like, friend function. A class can be made a friend
of another class using keyword friend. For example:
........ ..... ........
class A{
friend class B;
// class B is a
friend class
..... ..... .....
}
class B{
..... ..... .....
}
47

When a class is made a friend class, all the member

functions of that class becomes friend function. In this
program, all member functions of class B will be friend
function of class A. Thus, any member function of class B
can access the private and protected data of class A.
If B is declared friend class of A then, all member
functions of class B can access private data and protected
data of class A but, member functions of class A cannot
private and protected data of class B. Remember,
friendship relation in C++ is granted not taken.
C++ Inline functions
C++ inline function is powerful concept that is commonly
used with classes. If a function is inline, the compiler
places a copy of the code of that function at each point
where the function is called at compile time.
Any change to an inline function could require all clients of
the function to be recompiled because compiler would
need to replace all the code once again otherwise it will
continue with old functionality.
To inline a function, place the keyword inline before the
function name and define the function before any calls are
made to the function. The compiler can ignore the inline
qualifier in case defined function is more than a line.
A function definition in a class definition is an inline
function
definition,
even
without
the
use
of
the inlinespecifier.
48

Following is an example which makes use of inline

function to returns max of two numbers:
#include <iostream>
using namespace std;
inline int Max(int x, int y)
{
return (x > y)? x : y;
}
// Main function for the program
int main( )
{
cout << "Max (20,10): " << Max(20,10) <<
endl;
cout << "Max (0,200): " << Max(0,200) <<
endl;
cout << "Max (100,1010): " <<
Max(100,1010) << endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Max (20,10): 20
Max (0,200): 200
Max (100,1010): 1010
49

This pointer in C
Every object in C++ has access to its own address
through an important pointer called this pointer.
Thethis pointer is an implicit parameter to all member
functions. Therefore, inside a member function, this may
be used to refer to the invoking object.
Friend functions do not have a this pointer, because
friends are not members of a class. Only member
functions have a this pointer.
Let us try the following example to understand the concept
of this pointer:

#include <iostream>
using namespace std;
class Box
{
public:
// Constructor definition
50

Box(double l=2.0, double b=2.0,

double h=2.0)
{
cout <<"Constructor called." <<
endl;
length = l;
breadth = b;
height = h;
}
double Volume()
{
return length * breadth * height;
}
int compare(Box box)
{
return this->Volume() >
box.Volume();
}
private:
double length;
// Length of a box
double breadth;
// Breadth of a
box
double height;
// Height of a box
};
int main(void)
{
Box Box1(3.3, 1.2, 1.5);
box1
Box Box2(8.5, 6.0, 2.0);
box2
51

// Declare
// Declare

if(Box1.compare(Box2))
{
cout << "Box2 is smaller than Box1"
<<endl;
}
else
{
cout << "Box2 is equal to or larger
than Box1" <<endl;
}
return 0;
}
When the above code is compiled and executed, it
produces following result:
Constructor called.
Constructor called.
Box2 is equal to or larger than Box1

Pointer in C++
A pointer to a C++ class is done exactly the same way as
a pointer to a structure and to access members of a
pointer to a class you use the member access operator > operator, just as you do with pointers to structures. Also
as with all pointers, you must initialize the pointer before
using it.
52

Let us try the following example to understand the concept

of pointer to a class:
#include <iostream>
using namespace std;
class Box
{
public:
// Constructor definition
Box(double l=2.0, double b=2.0,
double h=2.0)
{
cout <<"Constructor called." <<
endl;
length = l;
breadth = b;
height = h;
}
double Volume()
{
return length * breadth * height;
}
private:
double length;
// Length of a box
double breadth;
// Breadth of a
box
double height;
// Height of a box
};

53

int main(void)
{
Box Box1(3.3, 1.2, 1.5);
box1
Box Box2(8.5, 6.0, 2.0);
box2
Box *ptrBox;
pointer to a class.

// Declare
// Declare
// Declare

// Save the address of first object

ptrBox = &Box1;
// Now try to access a member using
member access operator
cout << "Volume of Box1: " << ptrBox>Volume() << endl;
// Save the address of first object
ptrBox = &Box2;
// Now try to access a member using
member access operator
cout << "Volume of Box2: " << ptrBox>Volume() << endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:

54

Constructor called.
Constructor called.
Volume of Box1: 5.94
Volume of Box2: 102
Static Member
We can define class members static using static keyword.
When we declare a member of a class as static it means
no matter how many objects of the class are created,
there is only one copy of the static member.
A static member is shared by all objects of the class. All
static data is initialized to zero when the first object is
created, if no other initialization is present. We can't put it
in the class definition but it can be initialized outside the
class as done in the following example by redeclaring the
static variable, using the scope resolution operator :: to
identify which class it belongs to.
Let us try the following example to understand the concept
of static data members:
#include <iostream>
using namespace std;
class Box
{
public:
static int objectCount;
// Constructor definition
55

Box(double l=2.0, double b=2.0,

double h=2.0)
{
cout <<"Constructor called." <<
endl;
length = l;
breadth = b;
height = h;
// Increase every time object is
created
objectCount++;
}
double Volume()
{
return length * breadth * height;
}
private:
double length;
// Length of a box
double breadth;
// Breadth of a
box
double height;
// Height of a box
};
// Initialize static member of class Box
int Box::objectCount = 0;
int main(void)
{
Box Box1(3.3, 1.2, 1.5);
box1
56

// Declare

Box Box2(8.5, 6.0, 2.0);

box2

// Declare

// Print total number of objects.

cout << "Total objects: " <<
Box::objectCount << endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Constructor called.
Constructor called.
Total objects: 2

Static Function Members:

By declaring a function member as static, you make it
independent of any particular object of the class. A static
member function can be called even if no objects of the
class exist and the static functions are accessed using
only the class name and the scope resolution operator ::.

57

A static member function can only access static data

member, other static member functions and any other
functions from outside the class.
Static member functions have a class scope and they do
not have access to the this pointer of the class. You could
use a static member function to determine whether some
objects of the class have been created or not.
Let us try the following example to understand the concept
of static function members:
#include <iostream>
using namespace std;
class Box
{
public:
static int objectCount;
// Constructor definition
Box(double l=2.0, double b=2.0,
double h=2.0)
{
cout <<"Constructor called." <<
endl;
length = l;
breadth = b;
height = h;
// Increase every time object is
created
objectCount++;
58

}
double Volume()
{
return length * breadth * height;
}
static int getCount()
{
return objectCount;
}
private:
double length;
// Length of a box
double breadth;
// Breadth of a
box
double height;
// Height of a box
};
// Initialize static member of class Box
int Box::objectCount = 0;
int main(void)
{
// Print total number of objects before
creating object.
cout << "Inital Stage Count: " <<
Box::getCount() << endl;
Box Box1(3.3, 1.2, 1.5);
box1
Box Box2(8.5, 6.0, 2.0);
box2
59

// Declare
// Declare

// Print total number of objects after

creating object.
cout << "Final Stage Count: " <<
Box::getCount() << endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Inital Stage Count: 0
Constructor called.
Constructor called.
Final Stage Count: 2
C++ Inheritance
One of the most important concepts in object-oriented
programming is that of inheritance. Inheritance allows us
to define a class in terms of another class, which makes it
easier to create and maintain an application. This also
provides an opportunity to reuse the code functionality and
fast implementation time.
When creating a class, instead of writing completely new
data members and member functions, the programmer
can designate that the new class should inherit the
members of an existing class. This existing class is called
60

the base class, and the new class is referred to as

the derived class.
The idea of inheritance implements the is a relationship.
For example, mammal IS-A animal, dog IS-A mammal
hence dog IS-A animal as well and so on.
Inheritance in C++ Programming
Inheritance is one of the key feature of object-oriented
programming including C++ which allows user to create a
new class(derived class) from a existing class(base class).
The derived class inherits all feature from a base class
and it can have additional features of its own.

Concept of Inheritance in OOP

Suppose, you want to calculate either area, perimeter or
diagonal length of a rectangle by taking data(length and
breadth) from user. You can create three different
objects( Area, Perimeter and Diagonal) and asks user to
enter length and breadth in each object and calculate
61

corresponding data. But, the better approach would be to

create a additional object Rectangle to store value of
length and breadth from user and derive
objects Area, Perimeter andDiagonal from Rectangle base
class. It is because, all three
objects Area, Perimeter and diagonal are related to
objectRectangle and you don't need to ask user the input
data from these three derived objects as this feature is
included in base class.

Implementation of Inheritance in C++ Programming

class Rectangle
{
... .. ...
};
class Area : public Rectangle
{
... .. ...
};
62

class Perimeter : public Rectangle

{
.... .. ...
};
In the above example, class Rectangle is a base class and
classes Area and Perimeter are the derived
from Rectangle. The derived class appears with the
declaration of class followed by a colon, the
keyword public and the name of base class from which it
is derived.
Since, Area and Perimeter are derived from Rectangle, all
data member and member function of base
class Rectangle can be accessible from derived class.
Note: Keywords private and protected can be used in
place of public while defining derived class(will be
discussed later).
Source Code to Implement Inheritance in C++
Programming
This example calculates the area and perimeter a
rectangle using the concept of inheritance.
/* C++ Program to calculate the area and
perimeter of rectangles using concept of
inheritance. */

63

#include <iostream>
using namespace std;
class Rectangle
{
protected:
float length, breadth;
public:
Rectangle(): length(0.0),
breadth(0.0)
{
cout<<"Enter length: ";
cin>>length;
cout<<"Enter breadth: ";
cin>>breadth;
}
};
/* Area class is derived from base class
Rectangle. */
class Area : public Rectangle
{
public:
float calc()
{
return length*breadth;
}
};

64

/* Perimeter class is derived from base

class Rectangle. */
class Perimeter : public Rectangle
{
public:
float calc()
{
return 2*(length+breadth);
}
};
int main()
{
cout<<"Enter data for first rectangle
to find area.\n";
Area a;
cout<<"Area = "<<a.calc()<<" square
meter\n\n";
cout<<"Enter data for second rectangle
to find perimeter.\n";
Perimeter p;
cout<<"\nPerimeter = "<<p.calc()<<"
meter";
return 0;
}
Output
Enter data for first rectangle to find area.
Enter length: 5
Enter breadth: 4
65

Area = 20 square meter

Enter data for second rectangle to find
perimeter.
Enter length: 3
Enter breadth: 2
Area = 10 meter
Explanation of Program
In this program, classes Area and Perimeter are derived
from class Rectangle. Thus, the object of derived class can
access the public members of Rectangle. In this program,
when objects of class Area and Perimeter are created,
constructor in base class is automatically called. If there
was public member function in base class then, those
functions also would have been accessible for
objects a and p.
Keyword protected
In this program, length and breadth in the base class are
protected data members. These data members are
accessible from the derived class but, not accessible from
outside it. This maintains the feature of data hiding in
C++ programming. If you defined length and breadth as
private members then, those two data are not accessible
to derived class and if defined as public members, it can
be accessible from both derived class and from main(
)function.
66

Accessbility

Private Protected Public

Accessible from
own class ?

yes

yes

yes

Accessible from
dervied class ?

no

yes

yes

Accessible
outside dervied
class ?

no

no

yes

Type of Inheritance:
When deriving a class from a base class, the base class
may
be
inherited
through public,
protected or
private inheritance. The type of inheritance is specified by
the access-specifier as explained above.
We
hardly
use protected or private inheritance
but public inheritance is commonly used. While using
different type of inheritance, following rules are applied:
Public Inheritance: When deriving a class from
a public base class, public members of the base class
become public members
of
the
derived
class
and protected members
of
the
base
class
become protected members of the derived class. A base
class's private members are never accessible directly
from a derived class, but can be accessed through calls to
the publicand protected members of the base class.
67

Protected
Inheritance: When
deriving
from
a protected base class, public and protectedmembers of
the base class become protected members of the derived
class.
Private Inheritance: When deriving from a private base
class, public and protected members of the base class
become private members of the derived class.
Things to remember while Using Public, Protected and
Private Inheritance
1. Protected and public members(data and function) of a
base class are accessible from a derived class(for all
three: public, protected and private inheritance).
2. Objects of derived class with private and protected
inheritance cannot access any data member of a base
class.
3. Objects of derived class with public inheritance can
access only public member of a base class.

68

Summary of Public, Protected and Private Inheritance

Accessibility in Public Inheritance

69

Accessibility

Private Protected Public

Accessible from
own class?

yes

yes

yes

Accessible from
dervied class?

no

yes

yes

Accessible
outside dervied
class?

no

no

yes

Accessibility in Protected Inheritance

Accessibility

Private Protected Public

Accessible from
own class?

yes

yes

yes

Accessible from
dervied class?

no

yes

yes

Accessible
outside dervied
class?

no

no

no

70

Accessibility in Private Inheritance

Accessibility

Private Protected Public

Accessible from
own class?

yes

yes

yes

Accessible from
dervied class?

no

yes

yes

Accessible
outside dervied
class?

no

no

no

Base & Derived Classes:

A class can be derived from more than one classes, which
means it can inherit data and functions from multiple base
classes. To define a derived class, we use a class
derivation list to specify the base class(es). A class
derivation list names one or more base classes and has
the form:
class derived-class: access-specifier baseclass
Where
access-specifier
is
one
of public,
protected, or private, and base-class is the name of a
71

previously defined class. If the access-specifier is not

used, then it is private by default.
Consider a base class Shape and its
derived
class Rectangle as follows:
#include <iostream>
using namespace std;
// Base class
class Shape
{
public:
void setWidth(int w)
{
width = w;
}
void setHeight(int h)
{
height = h;
}
protected:
int width;
int height;
};
// Derived class
class Rectangle: public Shape
{
public:
int getArea()
{
72

return (width * height);

};

int main(void)
{
Rectangle Rect;
Rect.setWidth(5);
Rect.setHeight(7);
// Print the area of the object.
cout << "Total area: " << Rect.getArea()
<< endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Total area: 35
Multilevel Inheritance and Multiple Inheritance in C++
Programming
Levels of Inheritance
In C++ programming, a class be can derived from a
derived class which is known as multilevel inhertiance. For
example:
class A
73

{ .... ... .... };

class B : public A
{ .... ... .... };
class C : public B
{ .... ... .... };
In this example, class B is derived from class A and
class C is derived from derived class B.
Example to Demonstrate the Multilevel Inheritance
#include <iostream>
using namespace std;
class A
{
public:
void display()
{
cout<<"Base class content.";
}
};
class B : public A
{
};
class C : public B
{
};
74

int main()
{
C c;
c.display();
return 0;
}
Output
Base class content.
Explanation of Program
In this program, class B is derived from A and C is derived
from B. An object of class C is defined in main( )function.
When the display( ) function is called, display( ) in
class A is executed because there is no display( ) function
in C and B. The program first looks for display( ) in class C
first but, can't find it. Then, looks in B because C is
derived from B. Again it can't find it. And finally looks it
in A and executes the codes inside that function.
If there was display( ) function in C too, then it would
have override display( ) in A because of member function
overriding.
Multiple Inheritance in C++
In C++ programming, a class can be derived from more
than one parents. For example: A class Rectangle is
derived from base classes Area and Circle.
75

Source Code to Implement Multiple Inheritance in C++

Programming
This program calculates the area and perimeter of an
rectangle but, to perform this program, multiple
inheritance is used.
#include <iostream>
using namespace std;
class Area
{
public:
float area_calc(float l,float b)
{
return l*b;
}
};
class Perimeter
{
public:
float peri_calc(float l,float b)
76

return 2*(l+b);

}
};
/* Rectangle class is derived from classes
Area and Perimeter. */
class Rectangle : private Area, private
Perimeter
{
private:
float length, breadth;
public:
Rectangle() : length(0.0),
breadth(0.0) { }
void get_data( )
{
cout<<"Enter length: ";
cin>>length;
cout<<"Enter breadth: ";
cin>>breadth;
}
float area_calc()
{
/* Calls area_calc() of class Area
and returns it. */
return
Area::area_calc(length,breadth);
}
77

float peri_calc()
{
/* Calls peri_calc() function of
class Perimeter and returns it. */
return
Perimeter::peri_calc(length,breadth);
}
};
int main()
{
Rectangle r;
r.get_data();
cout<<"Area = "<<r.area_calc();
cout<<"\nPerimeter = "<<r.peri_calc();
return 0;
}
Output
Enter length: 5.1
Enter breadth: 2.3
Area = 11.73
Perimeter = 14.8
Note: This program is intended to give you idea on how
multiple inheritance works rather than the condition in
which multiple inheritance is used.

78

Ambiguity in Multiple Inheritance

Multiple inheritance may be helpful in certain cases but,
sometimes odd sort of problem encounters while using
multiple inheritance. For example: Two base classes have
functions with same name which is not overridden in
derived class and if you write code to access that function
using object of derived class, compiler shows error
because, it cannot determine which function to call. Here
is a code for this type of ambiguity in multiple inheritance
class base1
{
public:
void some_function( )
{ .... ... .... }
};
class base2
{
void some_function( )
{ .... ... .... }
};
class derived : public base1, public base2
{
};
int main()
{
derived obj;
79

/* Error because compiler can't figure out

which function to call either
same_function( ) of base1 or base2 .*/
obj.same_function( )
}
But, this problem can be solved easily using scope
resolution function to specify which function to class
either base1or base2
int main()
{
obj.base1::same_function( ); /*
Function of class base1 is called. */
obj.base2::same_function( ); /*
Function of class base2 is called. */
}
A C++ class can inherit members from more than one
class and here is the extended syntax:
class derived-class: access baseA, access
baseB....
Where access is one of public, protected, or private and
would be given for every base class and they will be
separated by comma as shown above. Let us try the
following example:
#include <iostream>
using namespace std;
80

// Base class Shape

class Shape
{
public:
void setWidth(int w)
{
width = w;
}
void setHeight(int h)
{
height = h;
}
protected:
int width;
int height;
};
// Base class PaintCost
class PaintCost
{
public:
int getCost(int area)
{
return area * 70;
}
};
// Derived class
class Rectangle: public Shape, public
PaintCost
{
81

};

public:
int getArea()
{
return (width * height);
}

int main(void)
{
Rectangle Rect;
int area;
Rect.setWidth(5);
Rect.setHeight(7);
area = Rect.getArea();
// Print the area of the object.
cout << "Total area: " << Rect.getArea()
<< endl;
// Print the total cost of painting
cout << "Total paint cost: $" <<
Rect.getCost(area) << endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:

82

Total area: 35
Total paint cost: $2450
C++ Overloading (Operator and Function)
C++ allows you to specify more than one definition for
a function name or an operator in the same scope, which
is
called function
overloading and operator
overloading respectively.
An overloaded declaration is a declaration that had been
declared with the same name as a previously declared
declaration in the same scope, except that both
declarations have different arguments and obviously
different definition (implementation).
When you call an overloaded function or operator, the
compiler determines the most appropriate definition to use
by comparing the argument types you used to call the
function or operator with the parameter types specified in
the definitions. The process of selecting the most
appropriate overloaded function or operator is
called overload resolution.
Function overloading in C++:
You can have multiple definitions for the same function
name in the same scope. The definition of the function
must differ from each other by the types and/or the
number of arguments in the argument list. You can not
overload function declarations that differ only by return
type.
83

Following is the example where same function print() is

being used to print different data types:
#include <iostream>
using namespace std;
class printData
{
public:
void print(int i) {
cout << "Printing int: " << i <<
endl;
}
void print(double f) {
cout << "Printing float: " << f <<
endl;

void print(char* c) {
cout << "Printing character: " << c
<< endl;
}
};
int main(void)
{
printData pd;
// Call print to print integer
pd.print(5);
// Call print to print float
84

pd.print(500.263);
// Call print to print character
pd.print("Hello C++");
return 0;
}
When the above code is compiled and executed, it
produces following result:
Printing int: 5
Printing float: 500.263
Printing character: Hello C++
Operators overloading in C++:
C++ Programming Operator Overloading
The meaning of operators are already defined and fixed
for basic types like: int, float, double etc in C++ language.
For example: If you want to add two integers then, +
operator is used. But, for user-defined types(like: objects),
you can define the meaning of operator, i.e, you can
redefine the way that operator works. For example: If
there are two objects of a class that contain string as its
data member, you can use + operator to concatenate two
strings. Suppose, instead of strings if that class contains
integer data member, then you can use + operator to add
integers. This feature in C++ programming that allows
programmer to redefine the meaning of operator when
they operate on class objects is known as operator
overloading.
85

Why Operator overloading is used in C++ programming?

You can write any C++ program without the knowledge of
operator overloading. But, operator operating are
profoundly used by programmer to make a program
clearer. For example: you can replace the code
like: calculation =
add(mult(a,b),div(a,b)); with calculation =
a*b+a/b; which is more readable and easy to
understand.
How to overload operators in C++ programming?
To overload a operator, a operator function is defined
inside a class as:

The return type comes first which is followed by

keyword operator, followed by operator sign,i.e., the
operator you want to overload like: +, <, ++ etc. and
finally the arguments is passed. Then, inside the body of
you want perform the task you want when this operator
function is called.

86

This operator function is called when, the operator(sign)

operates on the object of that class class_name.
Example of operator overloading in C++ Programming
/* Simple example to demonstrate the
working of operator overloading*/
#include <iostream>
using namespace std;
class temp
{
private:
int count;
public:
temp():count(5){ }
void operator ++() {
count=count+1;
}
void Display() { cout<<"Count:
"<<count; }
};
int main()
{
temp t;
++t;
/* operator function void
operator ++() is called */
t.Display();
return 0;
}
Output
87

Count: 6
Explanation
In this program, a operator function void operator ++
() is defined(inside class temp), which is invoked when ++
operator operates on the object of type temp. This
function will increase the value of count by 1.
Things to remember while using Operator overloading in
C++ language
1. Operator overloading cannot be used to change the
way operator works on built-in types. Operator
overloading only allows to redefine the meaning of
operator for user-defined types.
2. There are two operators assignment operator(=) and
address operator(&) which does not need to be
overloaded. Because these two operators are already
overloaded in C++ library. For example:
If obj1 and obj2are two objects of same class then,
you can use code obj1=obj2; without overloading =
operator. This code will copy the contents object
of obj2 to obj1. Similarly, you can use address
operator directly without overloading which will return
the address of object in memory.
3. Operator overloading cannot change the precedence
of operators and associativity of operators. But, if you

88

want to change the order of evaluation, parenthesis

should be used.
4. Not all operators in C++ language can be overloaded.
The operators that cannot be overloaded in C++ are
::(scope resolution), .(member selection), .*(member
selection through pointer to function) and ?:(ternary
operator).
Following best practice while using operator overloading
Operator overloading allows programmer to define
operator the way they want but, there is a pitfall if
operator overloading is not used properly. In above
example, you have seen ++ operator operates on object
to increase the value of count by 1. But, the value is
increased by 1 because, we have used the code:
void operator ++() {
count=count+1;
}
If the code below was used instead, then the value of
count will be decreased by 100 if ++ operates on object.
void operator ++() {
count=count-100;
}
But, it does not make any sense to decrease count by 100
when ++ operator is used. Instead of making code
readable this makes code obscure and confusing. And, it is
the job of the programmer to use operator overloading
properly and in consistent manner.
89

Again, the above example is increase count by 1 is not

complete. This program is incomplete in sense that, you
cannot use code like:
t1=++t
It is because the return type of operator function is void.
It is generally better to make operator work in similar way
it works with basic types if possible.
Here, are the examples of operator overloading on
different types of operators in C++ language in best
possible ways:
Box operator+(const Box&);
declares the addition operator that can be used to add two
Box objects and returns final Box object. Most overloaded
operators may be defined as ordinary non-member
functions or as class member functions. In case we define
above function as non-member function of a class then we
would have to pass two arguments for each operand as
follows:
Box operator+(const Box&, const Box&);
Following is the example to show the concept of operator
over loading using a member function. Here an object is
passed as an argument whose properties will be accessed
using this object, the object which will call this operator
can be accessed using this operator as explained below:
#include <iostream>
using namespace std;
class Box
90

{
public:
double getVolume(void)
{
return length * breadth * height;
}
void setLength( double len )
{
length = len;
}
void setBreadth( double bre )
{
breadth = bre;
}
void setHeight( double hei )
{
height = hei;
}
// Overload + operator to add two Box
objects.
Box operator+(const Box& b)
{
Box box;
box.length = this->length +
b.length;
box.breadth = this->breadth +
b.breadth;
91

box.height = this->height +
b.height;

return box;

}
private:
double length;
// Length of a
box
double breadth;
// Breadth of a
box
double height;
// Height of a
box
};
// Main function for the program
int main( )
{
Box Box1;
// Declare Box1
of type Box
Box Box2;
// Declare Box2
of type Box
Box Box3;
// Declare Box3
of type Box
double volume = 0.0;
// Store the
volume of a box here
// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
Box2.setLength(12.0);
92

Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// volume of box 1
volume = Box1.getVolume();
cout << "Volume of Box1 : " << volume
<<endl;
// volume of box 2
volume = Box2.getVolume();
cout << "Volume of Box2 : " << volume
<<endl;
// Add two object as follows:
Box3 = Box1 + Box2;
// volume of box 3
volume = Box3.getVolume();
cout << "Volume of Box3 : " << volume
<<endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400
Overloadable/Non-overloadableOperators:
93

Following is the list of operators which can be overloaded:

+

&

<

>

<=

>=

++

--

<<

>>

==

!=

&&

||

+=

-=

/=

%=

^=

&=

|=

*=

<<=

>>=

[]

()

->

->*

new

new []

delete

delete
[]

Following is the list of operators which can not be

overloaded:
::

.*

?:

Operator Overloading Examples:

Here are various operator overloading examples to help
you in understanding the concept.
S.N. Operators and Example
1

Unary operators overloading

94

Binary operators overloading

Relational operators overloading

Input/Output operators overloading

++ and -- operators overloading

Assignment operators overloading

Function call () operator overloading

Subscripting [] operator overloading

Class member access operator -> overloading

The unary operators operate on a single operand and

following are the examples of Uninary operators:

The increment (++) and decrement (--) operators.

The unary minus (-) operator.

The logical not (!) operator.

The unary operators operate on the object for which they
were called and normally, this operator appears on the left
side of the object, as in !obj, -obj, and ++obj but sometime
they can be used as postfix as well like obj++ or obj--.

95

Following example explain how minus (-) operator can be

overloaded for prefix as well as postfix usage.
#include <iostream>
using namespace std;
class Distance
{
private:
int feet;
// 0 to
infinite
int inches;
// 0 to 12
public:
// required constructors
Distance(){
feet = 0;
inches = 0;
}
Distance(int f, int i){
feet = f;
inches = i;
}
// method to display distance
void displayDistance()
{
cout << "F: " << feet << " I:" <<
inches <<endl;
}
// overloaded minus (-) operator
Distance operator- ()
{
96

feet = -feet;
inches = -inches;
return Distance(feet, inches);
}
};
int main()
{
Distance D1(11, 10), D2(-5, 11);
-D1;
negation
D1.displayDistance();
-D2;
negation
D2.displayDistance();

// apply
// display D1
// apply
// display D2

return 0;
}
When the above code is compiled and executed, it
produces following result:
F: -11 I:-10
F: 5 I:-11
The unary operators take two arguments and following are
the examples of Binary operators. You use binary
operators very frequently like addition (+) operator,
subtraction (-) operator and division (/) operator.

97

Following example explain how addition (+) operator can

be overloaded. Similar way you can overload subtraction
(-) and division (/) operators.
#include <iostream>
using namespace std;
class Box
{
double length;
double breadth;
double height;
public:

// Length of a box
// Breadth of a box
// Height of a box

double getVolume(void)
{
return length * breadth * height;
}
void setLength( double len )
{
length = len;
}
void setBreadth( double bre )
{
breadth = bre;
}
void setHeight( double hei )
{
height = hei;
98

}
// Overload + operator to add two Box
objects.
Box operator+(const Box& b)
{
Box box;
box.length = this->length + b.length;
box.breadth = this->breadth +
b.breadth;
box.height = this->height + b.height;
return box;
}
};
// Main function for the program
int main( )
{
Box Box1;
// Declare Box1
of type Box
Box Box2;
// Declare Box2
of type Box
Box Box3;
// Declare Box3
of type Box
double volume = 0.0;
// Store the
volume of a box here
// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
99

Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// volume of box 1
volume = Box1.getVolume();
cout << "Volume of Box1 : " << volume
<<endl;
// volume of box 2
volume = Box2.getVolume();
cout << "Volume of Box2 : " << volume
<<endl;
// Add two object as follows:
Box3 = Box1 + Box2;
// volume of box 3
volume = Box3.getVolume();
cout << "Volume of Box3 : " << volume
<<endl;
return 0;
}
When the above code is compiled and executed, it
produces following result:
Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400
100

There are various relational operators supported by C++

language like (<, >, <=, >=, ==, etc.) which can be used to
compare C++ built-in data types.
You can overload any of these operators, which can be
used to compare the objects of a class.
Following example explain how a < operator can be
overloaded and similar way you can overload other
relational operators.
#include <iostream>
using namespace std;
class Distance
{
private:
int feet;
// 0 to
infinite
int inches;
// 0 to 12
public:
// required constructors
Distance(){
feet = 0;
inches = 0;
}
Distance(int f, int i){
feet = f;
inches = i;
}
101

// method to display distance

void displayDistance()
{
cout << "F: " << feet << " I:" <<
inches <<endl;
}
// overloaded minus (-) operator
Distance operator- ()
{
feet = -feet;
inches = -inches;
return Distance(feet, inches);
}
// overloaded < operator
bool operator <(const Distance& d)
{
if(feet < d.feet)
{
return true;
}
if(feet == d.feet && inches <
d.inches)
{
return true;
}
return false;
}
};
int main()
{
Distance D1(11, 10), D2(5, 11);
102

if( D1 < D2 )
{
cout << "D1 is less than D2 " <<
endl;
}
else
{
cout << "D2 is less than D1 " <<
endl;
}
return 0;
}
When the above code is compiled and executed, it
produces following result:
D2 is less than D1
The word polymorphism means having many forms.
Typically, polymorphism occurs when there is a hierarchy
of classes and they are related by inheritance.
C++ polymorphism means that a call to a member function
will cause a different function to be executed depending
on the type of object that invokes the function.
Consider the following example where a base class has
been derived by other two classes:
#include <iostream>
using namespace std;
103

class Shape {
protected:
int width, height;
public:
Shape( int a=0, int b=0)
{
width = a;
height = b;
}
int area()
{
cout << "Parent class area :"
<<endl;
return 0;
}
};
class Rectangle: public Shape{
public:
Rectangle( int a=0, int b=0)
{
Shape(a, b);
}
int area ()
{
cout << "Rectangle class area :"
<<endl;
return (width * height);
}
};
class Triangle: public Shape{
104

public:
Triangle( int a=0, int b=0)
{
Shape(a, b);
}
int area ()
{
cout << "Rectangle class area :"
<<endl;
return (width * height / 2);
}
};
// Main function for the program
int main( )
{
Shape *shape;
Rectangle rec(10,7);
Triangle tri(10,5);
// store the address of Rectangle
shape = &rec;
// call rectangle area.
shape->area();
// store the address of Triangle
shape = &tri;
// call triangle area.
shape->area();
return 0;
}
105

When the above code is compiled and executed, it

produces following result:
Parent class area
Parent class area
The reason for the incorrect output is that the call of the
function area() is being set once by the compiler as the
version defined in the base class. This is called static
resolution of the function call, orstatic linkage - the
function call is fixed before the program is executed. This
is also sometimes calledearly binding because the area()
function is set during the compilation of the program.
But now, let's make a slight modification in our program
and precede the declaration of area() in the Shape class
with the keyword virtual so that it looks like this:
class Shape {
protected:
int width, height;
public:
Shape( int a=0, int b=0)
{
width = a;
height = b;
}
virtual int area()
{
cout << "Parent class area :"
<<endl;
return 0;
}
};
106

After this slight modification, when the previous example

code is compiled and executed, it produces following
result:
Rectangle class area
Triangle class area
This time the compiler looks at the contents of the pointer
instead of it's type. Hence since addresses of objects of tri
and rec classes are stored in *shape the respective area()
function is called.
As you can see, each of the child classes has a separate
implementation for the function area(). This is
how polymorphism is generally used. You have different
classes with a function of the same name, and even the
same parameters, but with different implementations.

Virtual Function in C++ Programming

If there are member function with same name in derived
classes, virtual functions gives programmer capability to
call member function of different class by a same function
call depending upon different context. This feature in C++
107

programming is known as polymorphism which is one of

the important feature of OOP.
If a base class and derived class has same function and if
you write code to access that function using pointer of
base class then, the function in the base class is executed
even if, the object of derived class is referenced with that
pointer variable. This can be demonstrated by an
example.

#include <iostream>
using namespace std;
class B
{
public:
void display()
108

{ cout<<"Content of base
class.\n"; }
};
class D : public B
{
public:
void display()
{ cout<<"Content of derived
class.\n"; }
};
int main()
{
B *b;
D d;
b->display();
d = &b;
/* Address of object d in
pointer variable */
d->display();
return 0;
}
Note: An object(either normal or pointer) of derived class
is type compatible with pointer to base class. So, b =
&d; is allowed in above program.
Output
Content of base class.
Content of base class.
109

In above program, even if the object of derived class d is

put in pointer to base class, display( ) of the base class is
executed( member function of the class that matches the
type of pointer ).
Virtual Functions
If you want to execute the member function of derived
class then, you can declare display( ) in the base class
virtual which makes that function existing in appearance
only but, you can't call that function. In order to make a
function virtual, you have to add keyword virtual in front
of a function.
/* Example to demonstrate the working of
virtual function in C++ programming. */
#include <iostream>
using namespace std;
class B
{
public:
virtual void display()
/* Virtual
function */
{ cout<<"Content of base
class.\n"; }
};
class D1 : public B
{
public:
110

void display()
{ cout<<"Content of first derived
class.\n"; }
};
class D2 : public B
{
public:
void display()
{ cout<<"Content of second derived
class.\n"; }
};
int main()
{
B *b;
D1 d1;
D2 d2;
/* b->display(); // You cannot use this
code here because the function of base
class is virtual. */
b = &d1;
b->display();
/* calls display() of
class derived D1 */
b = &d2;
b->display();
/* calls display() of
class derived D2 */
return 0;
}
111

Output
Content of first derived class.
Content of second derived class.
After the function of base class is made virtual, code b>display( ) will call the display( ) of the derived class
depending upon the content of pointer.
In this program, display( ) function of two different classes
are called with same code which is one of the example of
polymorphism in C++ programming using virtual
functions.

112