Object Oriented Programming

(For figures please refer Object Oriented Programming by

Balaguruswamy)

The major factor in the invention of object oriented approach is to remove the drawbacks
of procedural approach.

OOP treats data is critical elements in program development. It is necessary data to be

more close to functions which operate upon it. These functions protect the data from
accidental damage and modification by outside world.

OOP allows the division of problem into number of entities called objects. There can be
communication between objects through the functions of those objects.

Features of Object Oriented Programming:

1. Emphasis is on data rather than procedure

2. Programming are divided into what are known as objects
3. Functions that operate on data are tied in the form of objects
4. Data is hidden and cannot be accessed by external
5. Objects may communicate with one another through functions
 6. New data and functions can be easily added when necessary
7. Follows bottom up approach of programming
Basic Concepts of Object Oriented Programming:

1. Objects

Objects are basic run time entities in an object oriented system. The object may
represent a person, place, account or program. Object take up the space in the
memory and have associated address. Two objects can interact by sending
message to one another.

Object Student

Data
Name
Date of Birth
Marks

Functions
Total
Average
Display

2. Classes
The entire set of data and code of an object can be made as user defined data type
with the help of a class. In fact object is a real time entity created from a class.
Class is a template to create object.

Class fruit

Fruit ob;

Created object ob of type fruit.

3. Data Abstraction and Encapsulation

Wrapping up of data and function into single unit is called as class and it is a feature
of encapsulation.

Due to encapsulation data is not accessible to the outside world, and only those
functions which are wrapped in the class can access it. This feature is also classed as
data hiding or information hiding.

Abstraction refers to the act of representing essential features without including

-background explanations of implementations.

Classes use the concept of abstraction where they hide the implementation details
from the user.

4. Inheritance

Inheritance is a process by which object of one class acquire the features of another
class. The inheritance feature provides the feature of reusability. From existing class
new class is derived. Derived class is called sub class or derived class and existing
class is called base class or super class

FIGURE FROM PG9

5. Polymorphism
Poly is a ability to take more than one form. As per this concept functions can
show different behavior in different instance based on data which is passed.

A single functions name can be used to handle different number of different type
of arguments. Using a single function name to perform different types of
operation is known as function overloading

If the same operator is used to perform different work then it is called as operator
overloading.

FIGURE FROM PG10

6. Dynamic Binding
 Binding refers to the linking of procedure call to the code to be executed.
Dynamic binding means that the code associated with the given procedure call is
not known until the time of the call at run time.

In case of polymorphism and inheritance the function call depends upon the value
which are passed at run time based on that code linking will be done.

7. Message Passing
OOP objects communicate with each other. Communication involves the
following step:

1. Creating class and object out of it

2. Establishing communication among them

A message for an object is a request for execution of procedure, and therefore will
invoke a function in the receiving object which in turn generates the result.

Employee.salary(name);

Employee: Object
Salary: Function
Name: Message
Benefits of OOP

1. Through inheritance we can eliminate redundant code and use existing code again
2. Classes bring user defined data type features
3. Program can be built as working modules which communicate with one another
this leads to saving of development time and increases productivity
4. Data Hiding features helps to build secured programmes
5. Multiple object can exist together and communicate with each other
6. It is easy to partition the work into objects
7. OOP gives data centered design which is easy for implementation
8. Small system can be upgraded easily to large system
9. Message passing allows communication between objects with allows external
interfaces to talk to programme
10. Software Complexity can be easily managed.

Object Oriented Languages

1. Object – based programming languages

Object based programming languages primarily support encapsulation and object
identity.
• Data Encapsulation
• Data Hiding and access mechanisms
• Automatic initialization and clear up of objects
• Operator Overloading

They do not support inheritance and dynamic binding.

E.g. Smaltalk and Simula

# 62 , 1st Floor
10 the cross, 2nd Main
West of Cordd Road
II stage
Mahalaxmi puram
Kadamba hotel

2. Object oriented programming languages

Including all the above feature along with inheritance and dynamic binding

For e.g C++, Java etc.

A Simple C++ Programme:

# include<iostream>

int main()
{

Cout << “ Welcome to C++”;

Return 0;
}

Comments :

A Single line comments

// This is one line comment

Multiline Comments

/* */

/* This is
Multiline comment */

Input and Output Statements:

The declaration of cout and cin is there in the head file iostream which is
needed to be included before we use this in programme.

# include<iostream>

# include is a preprocessor directive to include a header file.

Cout

Figure from pg 20

Cout << “ What ever is to be printed here”;

<< operator is called as insertion or put to operator. This operator can be also
used for bit wise left shift operator.

Cin

Cin >> variable name;

Cin is the functions used to take input from the user from standard keyboard
into variables.

Before the variable are used for inputting it is suppose to be declared.

Figure from pg 24

Example programme showing input and output in C++

#include<iostream>

int main()
{
int a,b,c;

cout<< “enter two numbers”;

cin>>a;
cin>>b;
c=a+b;
cout<<”Answer is”<<c;
return 0;
}

Structure of C++ Programme

Include Files
Class Declaration
Member functions definitions
Main Function programme
Class declaration and header file definition are placed into one file , function definitions
are placed in separate files and then the main function where objects of classes are used.
So entire programme structure of C++ is divided into 3 parts. As described above

Figure from pg 27

Tokens , Expressions and Control Structures

Tokens are individual unit of programmes. C++ tokens are of following types:

1. Keywords
2. Identifiers
3. Constants
4. Strings
5. Operators

Keywords:

Keywords are explicitly reserved identifiers that can not be used as names of programme
variables, or user defined programmes.

and double not_eq throw

and_eq dynamic_castoperator true
asm else or try
auto enum or_eq typedef
bitand explicit private typeid
bitor extern protected typename
bool false public union
break float register unsigned
case fro reinterpret-castusing
catch friend return virtual
char goto short void
class if signed volatile
compl inline sizeof wchar_t
const int static while
const-castlong static_cast xor
continue mutable struct xor_eq
default namespace switch
delete new template
do not this
Identifiers and Constants:

Identifiers are name given to variables, functions, arrays and classes. There are certain
fundamental rules regarding naming of identifiers.

1. Only alphabetic characters, digits, and underscore are permitted

2. The name cannot start with digit
3. Upper case and lowercase letters are distinct
4. A declared keywords cannot be used as variable name.

Constants are those identifiers for which the value cannot be changed through the
execution of the programme.

Const datatype <name of constant> = value ;

const int a = 10;

Value of a cannot be changed at all in the execution of a programme.

Basic Data types in C++

Figure from pg 35

Table from pg 36

Declaration of variables
In order to use a variable in C++, we must first declare it specifying which data type we want
it to be. The syntax to declare a new variable is to write the specifier of the desired data type
(like int, bool, float...) followed by a valid variable identifier. For example:

1 int a;
2 float mynumber;

These are two valid declarations of variables. The first one declares a variable of type int with
the identifier a. The second one declares a variable of type float with the identifier mynumber.
Once declared, the variables a and mynumber can be used within the rest of their scope in the
program.

If you are going to declare more than one variable of the same type, you can declare all of
them in a single statement by separating their identifiers with commas. For example:

int a, b, c;
This declares three variables (a, b and c), all of them of type int, and has exactly the same
meaning as:

1 int a;
2 int b;
3 int c;

The integer data types char, short, long and int can be either signed or unsigned depending on
the range of numbers needed to be represented. Signed types can represent both positive and
negative values, whereas unsigned types can only represent positive values (and zero). This
can be specified by using either the specifier signed or the specifier unsigned before the type
name. For example:

1 unsigned short int NumberOfSisters;

2 signed int MyAccountBalance;

By default, if we do not specify either signed or unsigned most compiler settings will assume
the type to be signed, therefore instead of the second declaration above we could have
written:

int MyAccountBalance;
Operators
Once we know of the existence of variables and constants, we can begin to operate with them.
For that purpose, C++ integrates operators. Unlike other languages whose operators are
mainly keywords, operators in C++ are mostly made of signs that are not part of the alphabet
but are available in all keyboards. This makes C++ code shorter and more international, since
it relies less on English words, but requires a little of learning effort in the beginning.

You do not have to memorize all the content of this page. Most details are only provided to
serve as a later reference in case you need it.

Assignment (=)
The assignment operator assigns a value to a variable.

a = 5;

This statement assigns the integer value 5 to the variable a. The part at the left of the
assignment operator (=) is known as the lvalue (left value) and the right one as the rvalue
(right value). The lvalue has to be a variable whereas the rvalue can be either a constant, a
variable, the result of an operation or any combination of these.
The most important rule when assigning is the right-to-left rule: The assignment operation
always takes place from right to left, and never the other way:

a = b;

This statement assigns to variable a (the lvalue) the value contained in variable b (the
rvalue). The value that was stored until this moment in a is not considered at all in this
operation, and in fact that value is lost.

Consider also that we are only assigning the value of b to a at the moment of the assignment
operation. Therefore a later change of b will not affect the new value of a.

For example, let us have a look at the following code - I have included the evolution of the
content stored in the variables as comments:

1 // assignment operator a:4 b:7

2
3 #include <iostream>
4 using namespace std;
5
6 int main ()
7{
8 int a, b; // a:?, b:?
9 a = 10; // a:10, b:?
10 b = 4; // a:10, b:4
11 a = b; // a:4, b:4
12 b = 7; // a:4, b:7
13
14 cout << "a:";
15 cout << a;
16 cout << " b:";
17 cout << b;
18
19 return 0;
20 }

This code will give us as result that the value contained in a is 4 and the one contained in b is
7. Notice how a was not affected by the final modification of b, even though we declared a =
b earlier (that is because of the right-to-left rule).

A property that C++ has over other programming languages is that the assignment operation
can be used as the rvalue (or part of an rvalue) for another assignment operation. For
example:

a = 2 + (b = 5);

is equivalent to:

1 b = 5;
2 a = 2 + b;

that means: first assign 5 to variable b and then assign to a the value 2 plus the result of the
previous assignment of b (i.e. 5), leaving a with a final value of 7.

The following expression is also valid in C++:

a = b = c = 5;

It assigns 5 to the all three variables: a, b and c.

Arithmetic operators ( +, -, *, /, % )
The five arithmetical operations supported by the C++ language are:

+ addition
- subtraction
* multiplication
/ division
% modulo

Operations of addition, subtraction, multiplication and division literally correspond with their
respective mathematical operators. The only one that you might not be so used to see is
modulo; whose operator is the percentage sign (%). Modulo is the operation that gives the
remainder of a division of two values. For example, if we write:

a = 11 % 3;
the variable a will contain the value 2, since 2 is the remainder from dividing 11 between 3.

Compound assignment (+=, -=, *=, /=, %=, >>=, <<=,

&=, ^=, |=)

When we want to modify the value of a variable by performing an operation on the value
currently stored in that variable we can use compound assignment operators:

expression is equivalent to
value += increase; value = value + increase;
a -= 5; a = a - 5;
a /= b; a = a / b;
price *= units + 1; price = price * (units + 1);

and the same for all other operators. For example:

1 // compound assignment operators 5

2
3 #include <iostream>
4 using namespace std;
5
6 int main ()
7{
8 int a, b=3;
9 a = b;
10 a+=2; // equivalent
11 to a=a+2
12 cout << a;
13 return 0;
}

Increase and decrease (++, --)

Shortening even more some expressions, the increase operator (++) and the decrease
operator (--) increase or reduce by one the value stored in a variable. They are equivalent to
+=1 and to -=1, respectively. Thus:

1 c++;
2 c+=1;
3 c=c+1;

are all equivalent in its functionality: the three of them increase by one the value of c.

In the early C compilers, the three previous expressions probably produced different
executable code depending on which one was used. Nowadays, this type of code optimization
is generally done automatically by the compiler, thus the three expressions should produce
exactly the same executable code.
A characteristic of this operator is that it can be used both as a prefix and as a suffix. That
means that it can be written either before the variable identifier (++a) or after it (a++).
Although in simple expressions like a++ or ++a both have exactly the same meaning, in other
expressions in which the result of the increase or decrease operation is evaluated as a value in
an outer expression they may have an important difference in their meaning: In the case that
the increase operator is used as a prefix (++a) the value is increased before the result of the
expression is evaluated and therefore the increased value is considered in the outer
expression; in case that it is used as a suffix (a++) the value stored in a is increased after
being evaluated and therefore the value stored before the increase operation is evaluated in
the outer expression. Notice the difference:

Example 1 Example 2
B=3; B=3;
A=++B; A=B++;
// A contains 4, B contains 4 // A contains 3, B contains 4

In Example 1, B is increased before its value is copied to A. While in Example 2, the value of B
is copied to A and then B is increased.

Relational and equality operators ( ==, !=, >, <, >=, <=
)

In order to evaluate a comparison between two expressions we can use the relational and
equality operators. The result of a relational operation is a Boolean value that can only be true
or false, according to its Boolean result.

We may want to compare two expressions, for example, to know if they are equal or if one is
greater than the other is. Here is a list of the relational and equality operators that can be
used in C++:

== Equal to
!= Not equal to
> Greater than
< Less than
>= Greater than or equal to
<= Less than or equal to

Here there are some examples:

1 (7 == 5) // evaluates to false.
2 (5 > 4) // evaluates to true.
3 (3 != 2) // evaluates to true.
4 (6 >= 6) // evaluates to true.
5 (5 < 5) // evaluates to false.

Of course, instead of using only numeric constants, we can use any valid expression, including
variables. Suppose that a=2, b=3 and c=6,

1 (a == 5) // evaluates to false since a is not equal to 5.

2 (a*b >= c) // evaluates to true since (2*3 >= 6) is true.
3 (b+4 > a*c) // evaluates to false since (3+4 > 2*6) is false.
4 ((b=2) == a) // evaluates to true.

Be careful! The operator = (one equal sign) is not the same as the operator == (two equal
signs), the first one is an assignment operator (assigns the value at its right to the variable at
its left) and the other one (==) is the equality operator that compares whether both
expressions in the two sides of it are equal to each other. Thus, in the last expression ((b=2)
== a), we first assigned the value 2 to b and then we compared it to a, that also stores the
value 2, so the result of the operation is true.

Logical operators ( !, &&, || )

The Operator ! is the C++ operator to perform the Boolean operation NOT, it has only one
operand, located at its right, and the only thing that it does is to inverse the value of it,
producing false if its operand is true and true if its operand is false. Basically, it returns the
opposite Boolean value of evaluating its operand. For example:

1 !(5 == 5) // evaluates to false because the expression at its right

2 (5 == 5) is true.
3 !(6 <= 4) // evaluates to true because (6 <= 4) would be false.
4 !true // evaluates to false
!false // evaluates to true.

The logical operators && and || are used when evaluating two expressions to obtain a single
relational result. The operator && corresponds with Boolean logical operation AND. This
operation results true if both its two operands are true, and false otherwise. The following
panel shows the result of operator && evaluating the expression a && b:

&& OPERATOR
a b a && b
true true true
true false false
false true false
false false false

The operator || corresponds with Boolean logical operation OR. This operation results true if
either one of its two operands is true, thus being false only when both operands are false
themselves. Here are the possible results of a || b:

|| OPERATOR
a b a || b
true true true
true false true
false true true
false false false

For example:
1 ( (5 == 5) && (3 > 6) ) // evaluates to false ( true && false ).
2 ( (5 == 5) || (3 > 6) ) // evaluates to true ( true || false ).

Conditional operator ( ? )

The conditional operator evaluates an expression returning a value if that expression is true
and a different one if the expression is evaluated as false. Its format is:

condition ? result1 : result2

If condition is true the expression will return result1, if it is not it will return result2.

1 7==5 ? 4 : 3 // returns 3, since 7 is not equal to 5.

2 7==5+2 ? 4 : 3 // returns 4, since 7 is equal to 5+2.
3 5>3 ? a : b // returns the value of a, since 5 is greater than 3.
4 a>b ? a : b // returns whichever is greater, a or b.

1 // conditional operator 7
2
3 #include <iostream>
4 using namespace std;
5
6 int main ()
7{
8 int a,b,c;
9
10 a=2;
11 b=7;
12 c = (a>b) ? a : b;
13
14 cout << c;
15
16 return 0;
17 }

In this example a was 2 and b was 7, so the expression being evaluated (a>b) was not true,
thus the first value specified after the question mark was discarded in favor of the second
value (the one after the colon) which was b, with a value of 7.

Comma operator ( , )
The comma operator (,) is used to separate two or more expressions that are included where
only one expression is expected. When the set of expressions has to be evaluated for a value,
only the rightmost expression is considered.

For example, the following code:

a = (b=3, b+2);
Would first assign the value 3 to b, and then assign b+2 to variable a. So, at the end, variable
a would contain the value 5 while variable b would contain value 3.

Bitwise Operators ( &, |, ^, ~, <<, >> )

Bitwise operators modify variables considering the bit patterns that represent the values they
store.

operator asm equivalent description

& AND Bitwise AND
| OR Bitwise Inclusive OR
^ XOR Bitwise Exclusive OR
~ NOT Unary complement (bit inversion)
<< SHL Shift Left
>> SHR Shift Right

Explicit type casting operator

Type casting operators allow you to convert a datum of a given type to another. There are
several ways to do this in C++. The simplest one, which has been inherited from the C
language, is to precede the expression to be converted by the new type enclosed between
parentheses (()):

1 int i;
2 float f = 3.14;
3 i = (int) f;

The previous code converts the float number 3.14 to an integer value (3), the remainder is
lost. Here, the typecasting operator was (int). Another way to do the same thing in C++ is
using the functional notation: preceding the expression to be converted by the type and
enclosing the expression between parentheses:

i = int ( f );

Both ways of type casting are valid in C++.

sizeof()
This operator accepts one parameter, which can be either a type or a variable itself and
returns the size in bytes of that type or object:

a = sizeof (char);

This will assign the value 1 to a because char is a one-byte long type.
The value returned by sizeof is a constant, so it is always determined before program
execution.

Other operators
Later in these tutorials, we will see a few more operators, like the ones referring to pointers or
the specifics for object-oriented programming. Each one is treated in its respective section.

Precedence of operators
When writing complex expressions with several operands, we may have some doubts about
which operand is evaluated first and which later. For example, in this expression:

a = 5 + 7 % 2

we may doubt if it really means:

1 a = 5 + (7 % 2) // with a result of 6, or
2 a = (5 + 7) % 2 // with a result of 0

The correct answer is the first of the two expressions, with a result of 6. There is an
established order with the priority of each operator, and not only the arithmetic ones (those
whose preference come from mathematics) but for all the operators which can appear in C++.
From greatest to lowest priority, the priority order is as follows:

Level Operator Description Grouping

Left-to-
1 :: scope
right
() [] . -> ++ -- dynamic_cast static_cast Left-to-
2 postfix
reinterpret_cast const_cast typeid right
++ -- ~ ! sizeof new delete unary (prefix)
indirection and Right-to-
3 * &
reference (pointers) left
+ - unary sign operator
Right-to-
4 (type) type casting
left
Left-to-
5 .* ->* pointer-to-member
right
Left-to-
6 * / % multiplicative
right
Left-to-
7 + - additive
right
Left-to-
8 << >> shift
right
Left-to-
9 < > <= >= relational
right
Left-to-
10 == != equality
right
Left-to-
11 & bitwise AND
right
12 ^ bitwise XOR Left-to-
 right
Left-to-
13 | bitwise OR
right
Left-to-
14 && logical AND
right
Left-to-
15 || logical OR
right
Right-to-
16 ?: conditional
left
Right-to-
17 = *= /= %= += -= >>= <<= &= ^= |= assignment
left
Left-to-
18 , comma
right

Grouping defines the precedence order in which operators are evaluated in the case that there
are several operators of the same level in an expression.

All these precedence levels for operators can be manipulated or become more legible by
removing possible ambiguities using parentheses signs ( and ), as in this example:

a = 5 + 7 % 2;

might be written either as:

a = 5 + (7 % 2);

or
a = (5 + 7) % 2;

depending on the operation that we want to perform.

Manipulators

What is a Manipulator?
Manipulators are operators used in C++ for formatting output. The data is
manipulated by the programmer’s choice of display.

There are numerous manipulators available in C++. Some of the more commonly
used manipulators are provided here below:

endl Manipulator:
This manipulator has the same functionality as the ‘\n’ newline character.

For example:

cout << "Exforsys" << endl;

cout << "Training";

produces the output:

Exforsys
Training

Setw Manipulator:

This manipulator sets the minimum field width on output. The syntax is:

setw(x)

Here setw causes the number or string that follows it to be printed within a field of x
characters wide and x is the argument set in setw manipulator. The header file that
must be included while using setw manipulator is <iomanip.h>

Sum=345

Cout << setw(5) << sum << endl;

3 4 5
Memory Management Operators

What are memory management operators?

There are two types of memory management operators in C++:

• new
• delete

These two memory management operators are used for allocating and freeing
memory blocks in efficient and convenient ways.

New operator:
The new operator in C++ is used for dynamic storage allocation. This operator can
be used to create object of any type.

General syntax of new operator in C++:

The general syntax of new operator in C++ is as follows:

pointer variable = new datatype;

In the above statement, new is a keyword and the pointer variable is a variable of
type datatype.

For example:

int *a=new int;

In the above example, the new operator allocates sufficient memory to hold the
object of datatype int and returns a pointer to its starting point. The pointer variable
a holds the address of memory space allocated.

Dynamic variables are never initialized by the compiler. Therefore, the programmer
should make it a practice to first assign them a value.

The assignment can be made in either of the two ways:

int *a = new int;

*a = 20;

or

int *a = new int(20);

delete operator:
The delete operator in C++ is used for releasing memory space when the object is
no longer needed. Once a new operator is used, it is efficient to use the
corresponding delete operator for release of memory.

General syntax of delete operator in C++:

The general syntax of delete operator in C++ is as follows:

delete pointer variable;

In the above example, delete is a keyword and the pointer variable is the pointer
that points to the objects already created in the new operator

The new operator offers following advantages over the function malloc()
1. It automatically computes the size of data object. We need not use the
operator size of
2. It automatically returns the correct pointer type, so that there is not need to
use a type cast
3. It is possible to initialize the object while creating the memory space
4. Like any other operator new and delete can be overloaded.
Control Structures:

Control structures are divided into three categories:

1. Sequence Structures
2. Selection Structures
3. Loop Structures

Figure from pg 61

Selection Structures:
If
1. if
2. if with else
3. Nested if
4. Else if Ladder

Switch

Simple if:

If (condition)
{
Statements

If with else

If (condition)
{

}
Else
{

Nested if
If (condition)
{
If (condition)
{

}
Else
{

else

Else if Ladder:

If (condition)
{

}
Else if ( condition )
{

}
Else
{

}
Switch Case

Switch(expression)
{
Case1:
{
Action1;
}
Case2:
{

}
Default:
{

}
}

Looping Statements:

1. do … while
2. While condition
3. for

do
{
Action1;
} while (condition )

This loop will run minimum one time.

While condition :

While (condition)
{
Action1;
}

For loop statements:

For ( initial value; test condition;increment)
{

Action1