Object Oriented

Programming
Open Source 34
Agenda

●
What is OOP ?
●
What is an Object ?
●
Structured vs Object Oriented Programming
●
Object Oriented Features
– Classes & Objects
– Abstraction
– Encapsulation
– Inheritance
– Polymorphism

2
References

●
Tutorials Point
http://www.tutorialspoint.com/cplusplus

●
C++ How to Program
http://www.deitel.com/books/cpphtp5/

●
Object-Oriented Programming in C++
Author: Robert Lafore

3
What is OOP ?

4
What is OOP ?

• Object-oriented programming is an approach to

design modular, reusable software systems.

• Programming methodology based on objects,

instead of just functions and procedures.

5
What is an Object ?!

• Ward is a division of a hospital or a suite of rooms

shared by patients who need a similar kind of care. In a
hospital, there are a number of wards, each of which may
be empty or have on it one or more patients.

• The doctors in the hospital are organized into teams.

Each team has a unique name or code and is headed by a
consultant doctor or attending physician.

6
Structured vs OOP

7
Programming Paradigms

• Structured Programming

• Object Oriented Programming

8
Structured Programming

• Its main focus is on the algorithms required to

perform the desired computations

• Importance is given to procedure (logic) and not to

the data on which these procedures operate

• Structured programming is often associated with

top-down design approach

9
Object Oriented Programming

• Used the bottom-up design approach

• Data and processes have equal importance

• Reduce complexity

• Promotes re-usability

10
Structured vs OOP

Top-down vs. bottom-up approaches

11
Structured vs OOP (Cont’d)

12
Object Oriented Features

13
Object Oriented Features

• Classes & Objects

• Abstraction
• Encapsulation
• Inheritance
• Polymorphism

14
Classes & Objects

15
Classes & Objects

• Objects
This is the basic unit of object oriented programming. That is both
data and function that operate on data are bundled as a unit called
as object.

• Classes
When you define a class, you define a blueprint for an object. 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.

16
Classes & Objects (Cont’d)

class Box
{
public:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};

17
Classes & Objects (Cont’d)

int main( )
{
Box box1; // Declare Box1 of type Box
Box box2; // Declare Box2 of type Box

// 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;

return 0;
}
18
Classes & Objects (Cont’d)

● Access Modifiers

● Constructor and Destructor

● Static Members

19
 Access Modifiers

● A public member is accessible from anywhere outside the class but

within a program.

● 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.

● 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.

20
Access Modifiers (Cont’d)

class Base
{
public:
// public members go here

protected:
// protected members go here

private:
// private members go here
};

21
Access Modifiers - Public

class Line{
public:
double length;
};

int main( ){
Line line;
line.length = 10.0;
return 0;
}

22
Access Modifiers - Private

class Box
{ // Main function for the program
public: int main( )
double length; {
void setWidth( double wid ){ Box box;
width = wid;
} // box.width = 10.0; // Error: because width is private
box.setWidth(10.0); // Use member function to set it.
double getWidth( void ){
return width ; return 0;
} }

private:
double width;
};

23
Access Modifiers - Protected

class Box
{ // Main function for the program
protected:
double width; int main( ){
}; SmallBox box;

class SmallBox:Box // set box width using member function

{ box.setSmallWidth(5.0);
public:
void setSmallWidth( double wid ){ return 0;
width = wid; }
}

double getSmallWidth( void ){

return width ;
}
};

24
 Constructor and Destructor

● 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.

25
Constructor and Destructor (Cont’d)

class Line
// Main function for the program
{
int main( )
public:
{
void setLength( double len );
Line line(10.0);
double getLength( void );
return 0;
Line(double len){ // This is the constructor
}
Length = len;
}

private:
double length;
};

26
 Static Members

● 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

● 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.
27
Static Members (Cont’d)

class Box
{
public:
static int objectCount;
// Constructor definition
Box()
{
objectCount++;
}
};

// Initialize static member of class Box

int Box::objectCount = 0;

int main(void)
{
Box Box1; // Declare box1
Box Box2; // Declare box2

return 0;
}

28
Abstraction 29
Abstraction

Data abstraction refers to, providing only essential information to

the outside world and hiding their background details.

30
Abstraction (Cont’d)

31
Abstraction (Cont’d)

• We can say a television clearly separates its internal

implementation from its external interface.

• You can interact with its interfaces like the power button,
channel changer, and volume control without having zero
knowledge of its internals.

• You do not know how it receives signals over the air or

through a cable, how it translates them, and finally
displays them on the screen.
32
Encapsulation

33
Encapsulation

• Encapsulation is an Object Oriented Programming concept that

binds together the data and functions that manipulate the data, and
that keeps both safe from outside interference and misuse.

• With procedural languages, it is not always clear which functions

work on which variables.

34
Encapsulation (Cont’d)

35
Encapsulation (Cont’d)

36
Encapsulation (Cont’d)

class Box
{
public:
double getVolume(void)
{
return length * breadth * height;
}
private:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};

37
Encapsulation vs Abstraction

• Data encapsulation is a mechanism of bundling the data, and the

functions that use them and data abstraction is a mechanism of
exposing only the interfaces and hiding the implementation details
from the user.

38
Inheritance

39
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 reuse the code functionality and fast
implementation time.

• The idea of inheritance implements the is a relationship. For

example, dog IS-A animal.

40
Inheritance (Cont’d)

41
Inheritance (Cont’d)

// Derived class
// Base class
class Rectangle: public Shape
class Shape
{
{
public:
public:
int getArea(){
void setWidth(int w){
return (width * height);
width = w;
}
}
};
void setHeight(int h) {
height = h; int main(void)
} {
protected: Rectangle Rect;
int width;
int height; Rect.setWidth(5);
}; Rect.setHeight(7);
int area = Rect.getArea();
return 0;
}

42
Polymorphism

43
Polymorphism

The ability to use an operator or function in different ways.

●
Overloading
●
Overriding

44
Overloading

●
C++ allows you to specify more than one definition for a
function name or an operator in the same scope

●
"Overloading" a function means that you have multiple
functions with the same name, but different arguments
and obviously different definition (implementation).

●
You can not overload function declarations that differ only
by return type.

45
Overloading (Cont’d)

int main(void)
class printData {
{ printData pd;
public:
void print(int i); // Call print to print integer
void print(double f); pd.print(5);
void print(char* c);
}; // Call print to print float
pd.print(500.263);

// Call print to print character

pd.print("Hello C++");

return 0;
}

46
Overriding

Call to a member function will cause a different function to

be executed depending on the type of object that invokes
the function.

47
Overriding (Cont’d)

class Shape {
protected:
int width, height;
public:
Shape( int a=0, int b=0){ width = a; height = b; }
virtual int area(){ return 0; }
};

class Triangle: public Shape{

public:
Triangle( int a=0, int b=0):Shape(a, b){ }
int area (){ return (width * height / 2); }
};

48
Overriding (Cont’d)

// Main function for the program

int main( )
{
Shape *shape;
Rectangle rec(10,7);

Triangle tri(10,5);
shape = &rec;
shape->area();

Rectangle rec(10,7);
shape = &tri;
shape->area();

return 0;
}

49
Thank
You
50