Object Oriented Programming

Programmer thinks about and defines the

attributes and behavior of objects.
Often the objects are modeled after realworld entities.
Very different approach than function-based
programming (like C).

Object Oriented Programming

Object-oriented programming (OOP)
Encapsulates data (attributes) and functions
(behavior) into packages called classes.

So, Classes are user-defined (programmerdefined) types.

Data (data members)
Functions (member functions or methods)

In other words, they are structures +

functions

Classes in C++
Member access specifiers
public:

can be accessed outside the class directly.

The public stuff is the interface.

private:

Accessible only to member functions of class

Private members and methods are for internal use
only.

class Circle
{
private:
double radius;
public:
Circle() { radius = 0.0;}
Circle(int r);
void setRadius(double r){radius = r;}
double getDiameter(){ return radius *2;}
double getArea();
double getCircumference();
};
void main()
Circle::Circle(int r)
{
{
Circle c(7);
radius = r;
Circle *cp1 = &c;
}
Circle *cp2 = new Circle(7);
double Circle::getArea()
cout<<The are of cp2:
{
<<cp2->getArea();
return radius * radius * (22.0/7);
}
double Circle:: getCircumference() }
{
return 2 * radius * (22.0/7);
}

Another class Example

This class shows how to handle time parts.

Destructor

class Time
{
private:
int *hour,*minute,*second;
public:
Time();
Time(int h,int m,int s);
void printTime();
void setTime(int h,int m,int s);
int getHour(){return *hour;}
int getMinute(){return *minute;}
int getSecond(){return *second;}
void setHour(int h){*hour = h;}
void setMinute(int m){*minute = m;}
void setSecond(int s){*second = s;}
~Time();
};

Time::Time()
{
hour = new int;
minute = new int;
second = new int;
*hour = *minute = *second = 0;
}
Dynamic locations
should be allocated
to pointers first

Time::Time(int h,int m,int s)

{
hour = new int;
minute = new int;
second = new int;
*hour = h;
*minute = m;
*second = s;
}
void Time::setTime(int h,int m,int s)
{
*hour = h;
*minute = m;
*second = s;
}

void Time::printTime()
{
cout<<"The time is : ("<<*hour<<":"<<*minute<<":"<<*second<<")"
<<endl;
}

Destructor: used here to deallocate memory locations

Time::~Time()
{
delete hour; delete minute;delete second;
}
void main()
{
Time *t;
t= new Time(3,55,54);
t->printTime();

Output:
The time is : (3:55:54)
The time is : (7:17:43)
Press any key to continue

t->setHour(7);
t->setMinute(17);
t->setSecond(43);
t->printTime();
delete t;
}

When executed, the

destructor is called

Reasons for OOP

1. Simplify programming
2. Interfaces
Information hiding:
Implementation details hidden within classes themselves

3. Software reuse

Class objects included as members of other

classes

Modules

.First introduced scope rules for data hiding

Public part consists of variables and
functions that are visible outside of the
.module
Private part consists of variables and
.functions visible only within the module
Modules may span multiple compilation
.units (files)
Modules generally lack any inheritance
.mechanism

?Why OO-Programming

Reduces conceptual load by reducing

amount of detail
Provides fault containment
Cant use components (e.g., a class) in
inappropriate ways

Provides independence between

components
Design/development can be done by more than
one person

The Evolution of OOPS

Global Variables -lifetime spans program

.execution
Local Variables - lifetime limited to execution
.of a single routine
.Nested Scopes - allow functions to be local
.Static Variables - visible in single scope
Modules - allow several subroutines to share
.a set of static variables
Module Types - multiple instances of an
.abstraction
.Classes - families of related abstractions

Keys to OO Programming

An instance of a class is know as an

.Object
Languages that are based on classes are
.know as Object-Oriented
Eiffel
++C
Modula-3
Ada 95
Java

Keys to OO Programming

Encapsulation (data hiding)

Enable programmer to group data & subroutines
(methods) together, hiding irrelevant details from users

Inheritance
Enable a new abstraction (i.e., derived class) to be
defined as an extension of an existing abstraction,
retaining key characteristics

Dynamic method binding

Enable use of new abstraction (i.e., derived class) to
exhibit new behavior in context of old abstraction

Classes in C++
A class definition begins with the keyword
class.
The body of the class is contained within a
set of braces, { } ; (notice the semi-colon).
class class_name
}
.
.
.
;{

Any valid
identifier
Class body (data member
+ methods)
methods

++Classes in C
Within the body, the keywords private: and
public: specify the access level of the
members of the class.
the default is private.

Usually, the data members of a class are

declared in the private: section of the class
and the member functions are in public:
section.

Classes in C++
class class_name
}
:private

public:

;{

private members or
methods

Public members or methods

Class Example
This class example shows how we can
encapsulate (gather) a circle information
into one package (unit or class)
No need for others classes to
class Circle
{
private:
double radius;
public:
void setRadius(double r);
double getDiameter();
double getArea();
double getCircumference();
};

access and retrieve its value

directly. The
class methods are responsible for
that only.

They are accessible from outside

the class, and they can access the
member (radius)

Creating an object of a Class

Declaring a variable of a class type creates an
object. You can have many variables of the same
type (class).
Instantiation

Once an object of a certain class is instantiated, a

new memory location is created for it to store its
data members and code
You can instantiate many objects from a class
type.
Ex) Circle c; Circle *c;

Special Member Functions

Constructor:
Public function member
called when a new object is created
(instantiated).
Initialize data members.
Same name as class
No return type
Several constructors
Function overloading

Special Member Functions

class Circle
{
private:
double radius;
public:
Circle();
Circle(int r);
void setRadius(double r);
double getDiameter();
double getArea();
double getCircumference();
};

Constructor with no
argument
Constructor with one
argument

Implementing class methods

Class implementation: writing the code of class

methods.
There are two ways:
1. Member functions defined outside class

Using Binary scope resolution operator (::)

Ties member name to class name
Uniquely identify functions of particular class
Different classes can have member functions with same name

Format for defining member functions

ReturnType ClassName::MemberFunctionName( ){

Implementing class methods

2. Member functions defined inside class
Do not need scope resolution operator, class
name;
class Circle
{
private:
double radius;
public:
Circle() { radius = 0.0;}
Circle(int r);
void setRadius(double r){radius = r;}
double getDiameter(){ return radius *2;}
double getArea();
double getCircumference();
};

Defined
inside
class

class Circle
{
private:
double radius;
public:
Circle() { radius = 0.0;}
Circle(int r);
void setRadius(double r){radius = r;}
double getDiameter(){ return radius *2;}
double getArea();
double getCircumference();
};
Circle::Circle(int r)
{
radius = r;
}
double Circle::getArea()
{
return radius * radius * (22.0/7);
}
double Circle:: getCircumference()
{
return 2 * radius * (22.0/7);
}

Defined outside class

Accessing Class Members

Operators to access class members
Identical to those for structs
Dot member selection operator (.)
Object
Reference to object

Arrow member selection operator (->)

Pointers

class Circle
{
private:
double radius;
public:
The first
The second
Circle() { radius = 0.0;}
constructor is
constructor is
Circle(int r);
called
called
void setRadius(double r){radius = r;}
double getDiameter(){ return radius *2;}
double getArea();
Since radius is a
void main()
double getCircumference();
private class data
{
};
Circle c1,c2(7);
member
Circle::Circle(int r)
{
cout<<The area of c1:
<<c1.getArea()<<\n;
radius = r;
}
//c1.raduis = 5;//syntax error
double Circle::getArea()
c1.setRadius(5);
{
return radius * radius * (22.0/7);
cout<<The circumference of c1:
}
<< c1.getCircumference()<<\n;
double Circle:: getCircumference()
{
cout<<The Diameter of c2:
<<c2.getDiameter()<<\n;
return 2 * radius * (22.0/7);
}
}

Classes
Extends the scope rules of modules to
.include inheritance
Should private members of a base class be
?visible in derived classes
Should public members of a base class
always be public members of a derived
.class
How much control should a base class
?have over its members in derived classes

C++ Classes
Any class can limit the visibility of its
:members
Public members are visible anywhere the class
.is in scope
Private members are visible only within the
.classs methods
Protected members are visible inside members
.of the class and derived classes
Friend classes are granted exceptions to
.(some) of the rules

C++ Classes
Derived classes can further restrict visibility of
:base class members, but not increase it
Private members of a base class are never visible in a
.derived class
Protected and public members of a public base class
.are protected or public, respectively, in a derived class
Protected and public members of a protected base
.class are protected members of a derived class
Protected and public members of a private base class
.are private members of a derived class

C++ Classes
Derived classes that limit visibility of base class
members can restore visibility by inserting a
using declaration in its protected or public
.sections
Rules in other languages can be significantly
.different

Dynamic Method Binding

Member Lookup

Inheritance

Encapsulation
:Encapsulation Requires that functions, modules and classes
Have clearly defined external interfaces
Hide implementation details

public functions

private
functions

private data

Encapsulation is all about coupling coupling happens through

.interfaces
?Exactly what is an interface

Abstract Data Types

Modularity
Keeps the complexity of a large program
manageable by systematically controlling
the interaction of its components
Isolates errors

Abstract Data Types

Modularity (Continued)
Eliminates redundancies
A modular program is
Easier to write
Easier to read
Easier to modify

Abstract Data Types

Procedural abstraction
Separates the purpose and use of a module
from its implementation
A modules specifications should
Detail how the module behaves
Identify details that can be hidden within the module

Abstract Data Types

Information hiding
Hides certain implementation details within a
module
Makes these details inaccessible from outside
the module

Abstract Data Types

Figure 3.1
Isolated tasks: the implementation of task T does not affect task Q

Abstract Data Types

The isolation of modules is not total
Functions specifications, or contracts, govern how they interact with
each other

Figure 3.2 A slit in the wall

Abstract Data Types

Typical operations on data
Add data to a data collection
Remove data from a data collection
Ask questions about the data in a data
collection

Abstract Data Types

Data abstraction
Asks you to think what you can do to a
collection of data independently of how you do it
Allows you to develop each data structure in
relative isolation from the rest of the solution
A natural extension of procedural abstraction

Abstract Data Types

Abstract data type (ADT)
An ADT is composed of
A collection of data
A set of operations on that data

Specifications of an ADT indicate

What the ADT operations do, not how to implement
them

Implementation of an ADT
Includes choosing a particular data structure

Abstract Data Types

Figure 3.4
A wall of ADT operations isolates a data structure from the program that uses it

The ADT List

Except for the first and last items, each item
has a unique predecessor and a unique
successor
Head or front do not have a predecessor
Tail or end do not have a successor

The ADT List

Items are referenced by their position within
the list
Specifications of the ADT operations
Define the contract for the ADT list
Do not specify how to store the list or how to
perform the operations

ADT operations can be used in an

application without the knowledge of how
the operations will be implemented

The ADT List

ADT List operations
Create an empty list
Determine whether a list is empty
Determine the number of items in a list
Add an item at a given position in the list
Remove the item at a given position in the list
Remove all the items from the list
Retrieve (get) item at a given position in the list

The ADT List

The ADT sorted list
Maintains items in sorted order
Inserts and deletes items by their values, not
their positions

The ADT List

Figure 3.7
The wall between displayList and the implementation of the ADT list

Designing an ADT
The design of an ADT should evolve
naturally during the problem-solving process
Questions to ask when designing an ADT
?What data does a problem require
?What operations does a problem require

Designing an ADT
For complex abstract data types, the
behavior of the operations must be specified
using axioms
Axiom: A mathematical rule
Ex. : (aList.createList()).size() = 0

Implementing ADTs
Choosing the data structure to represent the
ADTs data is a part of implementation
Choice of a data structure depends on
Details of the ADTs operations
Context in which the operations will be used

Implementing ADTs
Implementation details should be hidden
behind a wall of ADT operations
A program would only be able to access the
data structure using the ADT operations

Implementing ADTs

Figure 3.8
ADT operations provide access to a data structure

Implementing ADTs

Figure 3.9 Violating the wall of ADT operations

C++ Classes
Encapsulation combines an ADTs data with
its operations to form an object
An object is an instance of a class
A class contains data members and member
functions

By default, all members in a class are

private

Inheritance Concept
{class Rectangle

Polygon
Rectangle

Triangle

:private
;int numVertices
;float *xCoord, *yCoord
:public
;void set(float *x, float *y, int nV)
();float area
;{

{class Polygon
:private
;int numVertices
;float *xCoord, *yCoord
:public
;void set(float *x, float *y, int nV)
;{

{class Triangle
:private
;int numVertices
;float *xCoord, *yCoord
:public
;void set(float *x, float *y, int nV)
();float area
;{

Inheritance Concept
Polygon

Rectangle

Triangle

{class Rectangle : public Polygon

:public
();float area
;{

{class Polygon
:protected
;int numVertices
;float *xCoord, float *yCoord
:public
;void set(float *x, float *y, int nV)
;{
{class Rectangle
:protected
;int numVertices
;float *xCoord, float *yCoord
:public
;void set(float *x, float *y, int nV)
();float area
;{

Inheritance Concept
Polygon

Rectangle

Triangle

{class Triangle : public Polygon

:public
();float area
;{

{class Polygon
:protected
;int numVertices
;float *xCoord, float *yCoord
:public
;void set(float *x, float *y, int nV)
;{
{class Triangle
:protected
;int numVertices
;float *xCoord, float *yCoord
:public
;void set(float *x, float *y, int nV)
();float area
;{

Inheritance Concept
x
y

Point
Circle

3D-Point

x
y
r

x
y
z

{class Circle : public Point

: private
;double r
;{

{class Point
:protected
;int x, y
:public
;void set (int a, int b)
;{

class 3D-Point: public

{Point
: private
;int z
;{

Inheritance Concept
Augmenting the original class
Polygon

Rectangle

Point

Circle

Triangle

3D-Point

Specializing the original class

ComplexNumber

real

RealNumber

real
imag

ImaginaryNumber

imag

?Why Inheritance
Inheritance is a mechanism for
building class types from existing class types
defining new class types to be a
specialization
augmentation
of existing types

Define a Class Hierarchy

:Syntax
class DerivedClassName : access-level BaseClassName
where
access-level specifies the type of derivation
private by default, or
public

Any class can serve as a base class

Thus a derived class can also be a base class

Class Derivation
Point
3D-Point
Sphere
{class 3D-Point : public Point
: private
;double z

;{

{class Point
:protected
;int x, y
:public
;void set (int a, int b)
;{
{class Sphere : public 3D-Point
: private
;double r

;{

Point is the base class of 3D-Point, while 3D-Point is the base class of Sphere

?What to inherit
In principle, every member of a base class
is inherited by a derived class
just with different access permission

Access Control Over the Members

members goes to

derive from

b a s e c la s s / s u p e r c la s s /
p a r e n t c la s s

d e r iv e d c la s s / s u b c la s s /
c h ild c la s s

Two levels of access control

over class members
class definition
inheritance type
{class Point
;protected: int x, y
;public: void set(int a, int b)
;{
{class Circle : public Point

;{

Access Rights or access

specifiers of Derived Classes
Type of Inheritance

Access Control
for Members

private
protecte
d

private
-

protected
-

public
-

private

protected protected

public
private
protected
public
The type of inheritance defines the access level for the
members of derived class that are inherited from the
base class

Public Inheritance
class A : public B
Class A now inherits the members of Class // {
B
with no change in the access specifier for //
the inherited members// }

public base class (B)

public members
protected members
private members

derived class (A)

public
protected
inherited but not
accessible

Protected Inheritance

class A : protected B
Class A now inherits the members of Class B// {
with public members promoted to protected//
but no other changes to the inherited // }
members

protected base class

(B)
public members
protected members
private members

derived class (A)

protected
protected
inherited but not
accessible

Private Inheritance

class A : private B
Class A now inherits the members of Class B // {
with public and protected members//
promoted to private// }
private base class (B)
public members
protected members
private members

derived class (A)

private
private
inherited but not
accessible

Class Derivation
{class mother
;protected: int mProc
;public: int mPubl
;private: int mPriv
;{
private/protected/public
{class daughter : --------- mother
;private: double dPriv
((););public:
public:void
voidmFoo
dFoo
;{

( ){void daughter :: dFoo

mPriv = 10; //error
;mProc = 20
;{

{class grandDaughter : public daughter

;private: double gPriv
( );public: void gFoo
;{

() {int main
/*.*/
{

?What to inherit
In principle, every member of a base
class is inherited by a derived class
just with different access permission

However, there are exceptions for

constructor and destructor
operator=() member
friends

Since all these functions are class-specific

Inheritance (continued)
class Shape
}
:public
( ) ; int GetColor
so derived classes can access it//
:protected
;int color
;{
class Two_D : public Shape
}
put members specific to 2D shapes here//
;{
class Three_D : public Shape
}
put members specific to 3D shapes here//
;{

Inheritance (continued)
class Square : public Two_D
}
:public
( ) ; float getArea
:protected
;float edge_length
;{
class Cube : public Three_D
}
:public
( ) ; float getVolume
:protected
;float edge_length
;{

Inheritance (continued)
( ) int main
}
;Square mySquare
;Cube myCube
Square inherits //
( ); mySquare.getColor
( ); mySquare.getArea
)(Cube inherits getColor //
( ); myCube.getColor
( ); myCube.getVolume
{

Define its Own Members

The derived class can also define
its own members, in addition to
the members inherited from the
base class

Point
x
y
r

x
y

Circle
{class Circle : public Point
: private
;double r
:public
;void set_r(double c)
;{

{class Point
:protected
;int x, y
:public
;void set(int a, int b)
;{
{class Circle
:protected
;int x, y
:private
;double r
:public
;void set(int a, int b)
;void set_r(double c)
;{

Even more
A derived class can override methods defined in its
,parent class. With overriding
the method in the subclass has the identical signature to the
. method in the base class
. a subclass implements its own version of a base class method

{class A
:protected
;int x, y
:public
()void print
;}cout<<From A<<endl{
;{

{class B : public A
: public
()void print
;}cout<<From B<<endl {
;{

Access a Method
{class Point
:protected
;int x, y
:public
void set(int a, int b)
;}x=a; y=b{
();void foo
();void print
;{
;Point A
A.set(30,50); // from base class Point
A.print(); // from base class Point

{class Circle : public Point

;private: double r
:public
{void set (int a, int b, double c)
Point :: set(a, b); //same name function call
;r = c
{
(); };void print

;Circle C
C.set(10,10,100); // from class Circle
C.foo (); // from base class Point
C.print(); // from class Circle

Putting Them Together

Time

ExtTime

Time is the base class

ExtTime is the derived class
with public inheritance
The derived class can
inherit all members from the base
class, except the constructor
access all public and protected
members of the base class
define its private data member
provide its own constructor
define its public member functions
override functions inherited from
the base class

Take Home Message

Inheritance is a mechanism for defining new
class types to be a specialization or an
.augmentation of existing types
In principle, every member of a base class is
inherited by a derived class with different
access permissions, except for the
constructors

POLYMORPHISM

Polymorphism:Definition

.It is an important feature of OOPs

.It simply means one name, multiple forms

Types of polymorphism
Primitively divided into two types
polymorphism

Compile-time
polymorphism

Function Overloading

Operator overloading

Run-time
polymorphism

Virtual functions

Compile time polymorphism

Binding of Function call and function
definition is done during compile time. This
.is known as static binding
In function overloading and operator
overloading static binding happens, hence
they
come
under
compile
time
.polymorphism

Run-time polymorphism
Binding of Function call and function
definition is done during Run time. This is
.known as late or dynamic binding
If late binding happens in polymorphism it is
known as run-time polymorphism
C++ supports a mechanism known as
virtual functions to achieve run-time
.polymorphism

:Example
Class person
}
;char name[30]
;float age
:public
person)char *s,float a(
}
;strcpy)name,s(
;age=a
{
person& greater)person &x(
}
if)x.age>=age(
;return x
else
;return *this
{
void display )void(
}
;cout<<name<<age
{
;{

Abstract Classes
An abstract class represents an abstract concept in C++ (such
as Shape class)
Shape

Circle

Polygon

Rectangle

1. Defines the interfaces that all of

the concrete classes (subclasses)
share
2. Does not define state and
implementation unless it is
common to all concrete classes
3. Cannot be instantiated

()int main
}
;Person P1(john,32)
;Person P2(ahmed,38)
;Person P3(karthik,30)
;Person p=P1.greater(P2)
;cout <<elder person
();p.display
;p=P3.greater(P2)
;cout<<younger person
();p.display
{

Abstract Classes
An abstract class represents an abstract concept in C++ (such
as Shape class)
Shape

Circle

Polygon

Rectangle

1. Defines the interfaces that all of

the concrete classes (subclasses)
share
2. Does not define state and
implementation unless it is
common to all concrete classes
3. Cannot be instantiated

Function Overloading
C++ supports writing more than one function
with the same name but different argument
:lists. This could include
different data types
different number of arguments

The advantage is that the same apparent

function can be called to perform similar but
different tasks. The following will show an
.example of this

Function Overloading

; void swap (int *a, int *b)

; void swap (float *c, float *d)
; void swap (char *p, char *q)
( ) int main
}
; int a = 4, b = 6
; float c = 16.7, d = -7.89
;' char p = 'M' , q = 'n
;swap (&a, &b)
; swap (&c, &d)
; swap (&p, &q)
{

Function Overloading
void swap (int *a, int *b)
; }int temp; temp = *a; *a = *b; *b = temp{
void swap (float *c, float *d)
} ;float temp; temp = *c; *c = *d; *d = temp {
void swap (char *p, char *q)
} ;char temp; temp = *p; *p = *q; *q = temp {

Friend functions, operator

overloading
Friend functions, operator overloading

Its good to have friends

A friend function of a class is defined outside the
classs scope (I.e. not member functions), yet has
the right to access the non-public members of the
.class
Single functions or entire classes may be declared
.as friends of a class
These are commonly used in operator
overloading. Perhaps the most common use of
.friend functions is overloading << and >> for I/O

Friends
Basically, when you declare something as a friend,
.you give it access to your private data members
This is useful for a lot of things for very
interrelated classes, it more efficient (faster) than
using tons of get/set member function calls, and
they increase encapsulation by allowing more
.freedom is design options

Friends
A class doesn't control the scope of friend
functions so friend function declarations are
usually written at the beginning of a .h file. Public
. and private don't apply to them

Friends (a few gory details)

.Friendship is not inherited, transitive, or reciprocal
Derived classes dont receive the privileges of friendship (more on
this when we get to inheritance in a few classes)
The privileges of friendship arent transitive. If class A declares
class B as a friend, and class B declares class C as a friend, class
.C doesnt necessarily have any special access rights to class A
If class A declares class B as a friend (so class B can see class As
private members), class A is not automatically a friend of class B
(so class A cannot necessarily see the private data members of
.class B)

Friends
{class someClass
;friend void setX( someClass&, int)
;int someNumber
}rest of class definition
a function called setX defined in a program //
{void setX( someClass &c, int val)
; }c.someNumber = val
inside a main function//
;someClass myClass
//this will work, since we declared setX (myClass, 5);
// setX as a friend

ass Declarations
n be declared within the scope of another clas
ass." Nested classes are considered to be with
class and are available for use within that scop
a scope other than its immediate enclosing sc
name

value class Outside { value class Inside { }; }; In the same way, you can
nest as many classes as you wish in another class and you can nest
as many classes inside of other nested classes if you judge it
necessary. Just as you would manage any other class so can you
exercise control on a nested class. For example, you can declare all
necessary variables or methods in the nested class or in the nesting
class. When you create one class inside of another, there is no special
programmatic relationship between both classes: just because a class
is nested doesn't mean that the nested class has immediate access to
the members of the nesting class. They are two different classes and
. they can be used separately
The name of a nested class is not "visible" outside of the nesting class.
To access a nested class outside of the nesting class, you must qualify
the name of the nested class anywhere you want to use it. This is done
using the :: operator. For example, if you want to declare an Inside
variable somewhere in the program but outside of Outside, you must
:qualify its name. Here is an example

; using namespace System

value class COutside
}
()public: void ShowOutside

; Console::WriteLine(L"=-= Outside =-=")

{
value class CInside
}

() public: void ShowInside

; Console::WriteLine(L"-=- Inside -=-")
{
;{ ;{ {