Object Oriented Programming
Lecture 3
Dr. Jawad Manzoor
Original slides by: Dr. Naveed Anwar Bhatti
Object Oriented Modeling
Concepts
Last Class
• Model
• Object Oriented Model
• Object
Stores Change internal state
• State Fields
• Behavior
Implementation
• Identity
Interfaces
Exposes their
functionality through
3
Abstraction
• Abstraction is a way to cope with complexity.
• Principle of abstraction:
“ Capture only those details about an object that are relevant to
current perspective ”
4
Abstraction - Example
unclassified “organisms" organisms, mammals, humans organisms, mammals,
dangerous mammals
5
Abstraction - Example
The selection of significant attributes (to allow us to classify the
items that possess them) is abstraction
unclassified "things" organisms, mammals, humans organisms, mammals,
dangerous mammals
6
Abstraction – Advantages
• The selection of significant attributes (to allow us to classify the items
that possess them) is abstraction.
• We can abstract by appearance, structure, purpose, functionality,
privilege etc.
• In OOP we specify classes that will form the elements of our
programs. When the program is executed it makes software objects
that are instances of these classes and allows them to interact with
one another (by passing messages) to solve the problems that we set.
7
Class
• In an OO model, some of the objects exhibit
identical characteristics (information
structure and behavior)
Organisms
Mammals
• We say that they belong to the same class
Humans 8
Class
• What is Class?
o Class is a blueprint from which individual objects are created
o An expanded concept of data structures: like data structures, they can
contain data members, but they can also contain functions as members.
Classname Rectangle Circle
width radius
Class
Data Memebers
height color
Member Functions setValues() getRadius()
area() area()
Few More Examples – Class
• Ali studies mathematics
• Anam studies physics
• Sohail studies chemistry
• Each one is a Student
• We say these objects are instances of the Student class
10
Few More Examples – Class
• Ahsan teaches mathematics
• Aamir teaches computer science
• Atif teaches physics
• Each one is a Teacher
• We say these objects are instances of the Teacher class
11
Graphical Representation of Classes
(Class Name)
(Class Name)
(states)
Suppressed
(behavior) Form
Normal Form
Example - Graphical Representation of Classes
Circle
• center Circle
• radius Suppressed
Suppressed
draw() Form
Form
computeArea()
Normal
NormalForm
Form
13
Example - Graphical Representation of Classes
Person
• Name
• Age Person
• Gender
Suppressed
eat() Form
walk()
Normal Form
14
Member Functions
• Member functions are the functions that operate on the data
encapsulated in the class
• Public member functions are the interface to the class
Member Functions
• Member functions are the functions that operate on the data
encapsulated in the class
• Public member functions are the interface to the class
o Class members (both data and functions)can restrict their access
through access specifiers
Classes Intro: Access Specifier
• An access specifier determines what kind of access do you
want to give to class members
• Access can be of three types:
• Private: members of a class are accessible only from within the same
class
• Protected: members of a class are not accessible from outside, but is
accessible from the members of any class derived from same class
• Public: members are accessible from anywhere where the object is
visible
Class definition
• A class definition starts with the keyword class followed by the
class name
Class definition
• Complete example:
Accessor
Functions
Member Functions (contd.)
• Define member function inside the class definition
OR
• Define member function outside the class definition
• But they must be declared inside class definition
Class: Scope Operator
• Outside Class:
Scope Operator
Class: Scope Operator
• Another Example:
#include <iostream>
using namespace std;
class Student
{
int rollNo;
public:
void setRollNo(int aRollNo);
}; Scope Operator
void Student::setRollNo(int aRollNo)
{
rollNo = aRollNo;
}
Inline Functions
Inline Functions
• Instead of calling an inline function compiler places a copy of the
code at the function call point
• Keyword ‘inline’ is used to request compiler to make a function inline
Example
#include <iostream> #include <iostream>
using namespace std; using namespace std;
inline void hello()
{ int main()
cout << "Hello World"; {
} cout << "Hello World";
}
int main()
{
hello();
}
Inline Functions
• It is a request and not a command. Compiler may not perform inlining
in such circumstances like:
1. If a function contains a loop. (for, while, do-while)
2. If a function contains static variables.
3. If a function is recursive.
4. If a function contains switch or goto statement.
Inline Functions – Advantages and Disadvantages
Advantages:
1. Function call overhead doesn’t occur.
2. It also saves the overhead of push/pop variables on the stack when function
is called.
3. It also saves overhead of a return call from a function.
Disadvantages:
1. Too many inline functions will increase the size of the binary executable because
of the duplication of same code.
2. Inline function may increase compile time overhead. If someone changes the
code inside the inline function then all the calling location has to be recompiled.
3. Inline functions may not be useful for many embedded systems. Because in
embedded systems code size is more important than speed.
Inline Functions and Classes
• If we define the function inside the class body then the function is by
default an inline function
• In case function is defined outside the class body then we must use
the keyword ‘inline’ to make a function inline
Inline Functions and Classes: Example
#include <iostream>
using namespace std;
class Student
{
int rollNo;
public:
inline void setRollNo(int aRollNo);
};
inline void Student::setRollNo(int aRollNo)
{
rollNo = aRollNo;
}
Constructor & Destructor
What would happen if we called member function area() before
having called set_values(int, int)?
Class: Constructor
• Class can include a special function called its constructor
• Constructor is used to ensure that object is in well defined state at the time
of creation
• Automatically called when new object is created, allowing class to initialize
member variables or (allocate storage). Cannot be called explicitly using
existing object
• Declared just like regular member function, but with a name that matches
the class name and without any return type; not even void
Class: Constructor
Output:
Types of Constructor
• Default constructor
• Parameterized constructor
• Copy constructor
Default Constructor
• Constructor without any argument is called default constructor
• If we do not define a default constructor the compiler will generate a
default constructor
• Compiler created default constructor has empty body, i.e., it doesn’t
assign default values to data members
• User created default constructor can assign default values to data
members
Constructors Overloading
o Like function, constructor can also be overloaded with different versions
taking different parameters
Constructors Overloading
• Complete Example
default constructor
Constructors Overloading
Note:
Whenever we define one or more non-default constructors( with
parameters ) for a class, a default constructor( without parameters
) should also be explicitly defined as the compiler will not provide a
default constructor in this case
Constructors Overloading
• Use default parameter value to reduce the writing effort
Rectangle::Rectangle(int a=0, int b=0)
{
width = a;
height = b;
}
• Is equivalent to
Rectangle::Rectangle()
Rectangle::Rectangle(int a)
Rectangle::Rectangle(int a, int b)
Class: Destructor
• Automatically called when class object passes out of scope or is explicitly
deleted
• Mainly used to de-allocate the memory that has been allocated for the
object by the constructor (or any other member function).
• Syntax is same as constructor except preceded by the tilde sign
• Neither takes any arguments nor does it returns value
• Can’t be overloaded
Class: Destructor
• If we do not write our own destructor in class, compiler creates a default
destructor for us.
• The default destructor works fine unless we have dynamically allocated
memory or pointer in class.
• When a class contains a pointer to memory allocated in class, we should
write a destructor to release memory before the class instance is
destroyed. This must be done to avoid memory leak.
Class: Destructor
• Example
Dynamic memory
• In the programs seen in previous chapters, all memory needs were
determined before program execution by defining the variables
needed.
• But there may be cases where the memory needs of a program can
only be determined during runtime.
• For example, when the memory needed depends on user input.
• On these cases, programs need to dynamically allocate memory,
for which the C++ language integrates the
operators new and delete.
Dynamic memory
•There are two ways that memory gets allocated for data storage
•Compile Time (or static) Allocation
• Memory for named variables is allocated by the compiler
• Exact size and type of storage must be known at compile time
• For standard array declarations, this is why the size has to be constant
•Dynamic Memory Allocation
• Memory allocated "on the fly" during run time
• Exact amount of space or number of items does not have to be known
by the compiler in advance.
• For dynamic memory allocation, pointers are crucial
Dynamic memory
•We can dynamically allocate storage space while the program is
running, but we cannot create new variable names "on the fly"
•For this reason, dynamic allocation requires two steps:
• Creating the dynamic space.
• Storing its address in a pointer (so that the space can be accessed)
•To dynamically allocate memory in C++, we use
the new operator.
Dynamic memory
• Examples
int * p = new int; // dynamic integer, pointed to by p
*p = 10; // assigns 10 to the dynamic integer
cout << *p; // prints 10
double * numList = new double[size]; // dynamic array
for (int i = 0; i < size; i++)
numList[i] = 0; // initialize array elements to 0
Dynamic memory
Problem:
Cant create a shape object with different
number of sides at runtime.
Dynamic memory
Output:
Dynamic memory
Output:
Sequence of Calls
•[Again Remember] Constructors and destructors are called
automatically
•Constructors are called in the sequence in which object is
declared
•Destructors are called in reverse order
Sequence of Calls
#include <iostream>
using namespace std;
int main()
{
class Sequence {
int check; Sequence rect1(1);
public: Sequence rect2(2);
Sequence(int a);
~Sequence(); return 0;
}; }
Sequence::Sequence(int a)
{
check = a;
cout << "I am in constructor " << check << endl;
}
Sequence::~Sequence()
{
cout << "I am in destructor " << check << endl;
}
