OOP in C++

Methodology for software design / Programming Paradigm

Dr. K. Veningston
Department of Computer Science and Engineering
National Institute of Technology Srinagar
[email protected]
 Other methodologies
• Procedure Oriented Programming (POP)
– Developing software in terms of modules and functions (job to do).
– It gives less importance to data on which job (function) is applied.
– When the complexity of the problem is high, at some stage, the POP fails, as it cannot cope with the
complexity.
• It cannot sustain high complexity, where OOP comes in with the solution.
– Example:
• C, C++, Python
• Functional Programming (FP)
– A technique where most of the activities will be done directly with the help of functions
– Example:
• Python, LISP, Prolog
• Object Oriented Programming (OOP)
– It gives equal importance to both the activities/jobs/functions we do and the data on which these jobs are
performed.
– Examples:
• C++ is OOP & POP
• Java – Pure OOP
• Python is OOP, POP, and FP.
 Object Oriented Programming (OOP)
• It is a powerful technique that reflects real-world entities.
• OOP’s Guru:
– Grady Booch (who developed Unified Modeling Language (UML))
defines it as a methodology in which programs are organized/built as
a cooperative collection of objects (interaction/communication
between the objects).
• The object is an instance of a class.
Key terms in OOP
• The class is taken from the hierarchy of classes. Cred
it
Card
User ATM
SB
Acco
unt
 What is OOP?
• Object oriented programming (OOP) is the principle of design & development of programs
using modular approach.
– Define real-life problems in a more systematic way (using certain principles).
• The procedural programming focuses on processing of instructions in order to perform a
desired computation.
– It emphasises more on doing things like algorithms.
– Used in programming languages like C & Pascal.
• OOP combines both the data and the functions that operate on that data into a single unit
called the object.
– It follows bottom-up design technique, it is piecing together the smaller systems to give rise to
more complex systems.
• Another major component that plays a major role in OOP is the class.
– It is a template that represents a group of objects which share common properties and
relationships.
 Why OOP?
• It is a programming paradigm
– A set of rules, ideas, and concepts.
– A standard in programming that we use to solve a specific type of
problem.
• Other programming paradigms - why?
– We have a lot of different types of problems.
• The main reason is that the traditional procedural
programming is unable to model real-world problems.
 C++ as Object Oriented Language?
• It is an object-oriented, general purpose programming language, derived
from C.
• Existing code on C can be used with C++, hence mode compatible.
– Even existing pre-compiled libraries can be used with new C++ code.
– Also there is no additional cost for using C++, hence efficient.
• Major improvements over C
– Stream I/O
– Strong typing
– Default argument values
– Parameter passing by reference
– OOP principles
 Idea behind OOP paradigm
• To represent real-time objects/entities.
– To get with their characteristics, attributes, and behaviors.
• To explain those objects to our computer.
– To represent those objects in our programs.
 How does it work on a real-life example?
• Example: Consider “Car” as an entity.
– In real life, it has many attributes or characteristics.
• Manufacturer, color, price, max speed, etc.
– Behaviors of Car
• Drive, accelerate, stop, open door, fuel level, etc.
• Other examples:
– Student, Book, Animal, etc.
 Objects
• The object represents a real-world entity.
– Entities are tangible that they can be seen, noticed, or at least felt.
– Examples: room, table, chair, book, paper, student, employee, vehicle, pen,
fan, animal, box, air, etc.
– What are not objects?
• Alien
– Entities are represented in programming as objects.
– Entity possesses some properties and behaviors.
• Properties describe the entity.
• Behaviors describe actions/functionality/operations performed on the object or by
the object.
Object – Example 1

ROOM

Properties: length,
width, height,
colour

Behaviours: area(),
getRent(), paint()
 Objects – Example 2
• A neat approach of developing a software.
LIBRARY
BOOK
Properties: length,
width, height,
Properties: title,
colour, capacity,
author, publisher
#books
Behaviours: read(),
Behaviours: stock(),
copier(), getPrice(),
procureBooks(),
getQtyInStock()
issueBook(),
returnBook()
 Objects – Example 3
• A neat approach of developing a software.
EMPLOYEE
COMPANY
Properties: empID,
Properties: name, name, department,
location contact, salary

Behaviours: DEPARTMENT Behaviours:

revenue(), getSalary(),
Properties: name, #projects()
deptID,
#employees,
manager

Behaviours:
revenue(),
promoteEmp()
 class
• Template where properties and behaviors of an entity/object are
kept.
– Class is an area/place holder/template/prototype which is holding all the
properties and behaviors of a particular entity.
– Object represents the entity itself.
• Example (class vs. object)
– Class: “Plan of a House” → class says how entity/house should be in the
form of a template/description.
– Object: “House” → entity itself/the real entity is object.
• From a class, we can create any # of objects. Class Object
• From a plan, we can construct any # of houses. Type of Variable Variable itself
Data type describes Every variable has
size, operations, etc. associated attributes
and operations
 class
• The building block of OOP.
– Class is a user-defined datatype as opposed to a pre-defined datatype
(int, float, bool, double, etc.).
– It is a bit more complex datatype.
• To define a user, we need to store user characteristics including ‘name’,
‘gender’, ‘email’, etc.,
• All of the variables together are going to make a group called class.
• Applications that need to store users:
– FB: ‘name’, ‘gender’, ‘email’, ‘age’
– Fitness App: ‘name’, ‘gender’, ‘email’, ‘age’, ‘height’, ‘weight’
 OOAD – Approaching a real-world problems
• (i) Identification of Entities (Noun phrase approach)
• (ii) Abstraction of each entity
– Identifying/finding the essential characteristics/behaviours of an
entity in the perspective of the user in the problem
space/application domain.
PERSON
– It is a way of looking/viewing towards an object/entity.
Properties: name,
ID, DoB, height, – Class is a good example. EMPLOYEE
weight, PATIENT
bloodGroup,BP, STUDENT CUSTOMER Properties: name,
bodyTemp, Properties: name, ID, DoB,
qualification, Properties: name, ID, DoB, height, Properties: name, qualification,
parentage, 10th ID, DoB, parentage, weight, BP, ID, DoB, parentage, 10th
mark, 12th mark, 10th mark, 12th bodyTemp, qualification, mark, 12th mark,
address, etc. mark, address parentage, address parentage, address address
GENERAL PERSON ENTITY COLLEGE HOSPITAL BANK COMPANY
 OOAD – Approaching a real-world problems
• (iii) Encapsulation of entities
– Combining the properties and behaviours of an entity into a
capsule/template called class.
– A kind of hiding the details
– Class is a good example.
PERSON

Properties: name,
ID, DoB, height, EMPLOYEE
weight, PATIENT
bloodGroup,BP, STUDENT CUSTOMER Properties: name,
bodyTemp, Properties: name, ID, DoB,
qualification, Properties: name, ID, DoB, height, Properties: name, qualification,
parentage, 10th ID, DoB, parentage, weight, BP, ID, DoB, parentage, 10th
mark, 12th mark, 10th mark, 12th bodyTemp, qualification, mark, 12th mark,
address, etc. mark, address parentage, address parentage, address address
GENERAL PERSON ENTITY COLLEGE HOSPITAL BANK COMPANY
 How to create class in C++?
• Members of a class = attributes + behavior

• This class represents a

blueprint, not the data.
• This will serve as a model
for the Employee.
 How to create an instance/object of this class
Employee in C++?
• Members of a class = attributes + behavior
• Object is an instance of a Class.

Why we call object as

instance? Object resides in
memory.
 How to access these members/attributes of this
class Employee in C++?
• Members of a class = attributes + behavior
#include <iostream>
• Every member inside the
class in C++ is private by
using namespace std; default.
class Employee { • Access modifiers
string Name; • In C++, we have
string Company; private, public,
int Age; protected.
};

Access modifiers Scope

private private members in class are not accessible (hidden)
outside the class.
public public members in class are accessible outside the class
as well.
protected In-between private & public [let’s discuss in detail when
we learn about Inheritance later]
 How to access these members/attributes of this
class Employee in C++?
• Members of a class = attributes + behavior

We have set values for the

properties.
 How to describe the behaviors of this class
Employee in C++?
• Members of a class = attributes + behavior (functions)

Class Method
 Scope resolution operator ::
• The functions can be defined outside the class
– however they should be declared inside the class.
What if we have to create many Employee objects?
• We may need to repeat lines 19 to 21 for every Employee
object.
– This is not really optimal.
– There is a better approach to constructing objects.
• Constructors
– A constructor is a special type of method that is invoked each time an
object of a class is created.
Default constructor
• The output is the work of the
default constructor.
– Constructor that is
automatically generated by the
compiler, in case we do not
create constructors of our
own.
 How we can create our own constructor?
• 3 Rules to create constructors
– (i) Despite it being a special method, the constructor does not have a
return type, unlike methods.
– (ii) The constructor has the same name as the class that it belongs to.
– (iii) The constructor must be public.
• Everything that is private is locked/hidden inside the class. We do not want to
make our constructor hidden.
• Note:
– When we decide to create our own constructors, the default
constructor will not be created.
Constructor - Example
• Code is reduced.

Constructs/Initializes the value of

the object
 this keyword/ this reference
• Each object gets its own copy of data members, and
• All objects share a single copy of member functions.
this pointer
 mutable Storage class
• The mutable storage class specifier is used only on a class data
member to make it modifiable even though the member is part
of an object declared as const.
• We cannot use the mutable specifier with names declared as
static, const, or reference members.
mutable Storage class - Example
 OOP Principles
• OOP is a methodology characterized by the following concepts.
– Encapsulation: The process of binding data members (variables,
properties) and member functions (methods/actions) into a single
unit. A class is the best example.
 4 important principles/pillars/concepts of OOP
• (i) Encapsulation
• (ii) Abstraction
• (iii) Inheritance
• (iv) Polymorphism
 (i) Encapsulation
• What is Encapsulation?
– Tying/binding together data and methods that operate on that data. So
that, they are grouped together within a class.
– Why?
• We do it with the purpose of preventing anything outside our class from being able
to directly access our data to interact with it and modify it.
• We want to provide our own way for that to happen, not directly.
– How do we provide a way for other classes to interact with the properties
of our class?
• We provide specific public methods that other class can invoke and interact with our
data.
 (i) Encapsulation
• What is Encapsulation?
– How do we provide a way for other classes to interact with the
properties of our class?
• We provide specific public methods that other class can invoke and interact
with our data.
– How do we access an encapsulated properties of a class?
• Through its methods.
• These methods are very often implemented as getters and setters.
 How getters & setters look like to obey the rule of
#include<iostream>
using namespace std;
class Employee {
private:
encapsulation?
string Name; Encapsulate these 3 properties void Introduce(){
string Company; and hide them within the cout <<"Name: "<<Name<<endl;
int Age; Employee class cout <<"Company: "<<Company<<endl;
public:
cout <<"Age: "<<Age<<endl;
void setName(string name){
}
Name = name;
Employee(string name, string company, int age){
}
Name = name;
string getName(){
Company = company;
return Name;
Age = age;
}
}
void setCompany(string company){
};
Company = company;
int main(){
}
Employee e1 = Employee("Veningston", "NIT Srinagar", 37);
string getCompany(){
Employee e2 = Employee("Oswald", "NIT Trichy", 35);
return Company;
e1.Introduce();
}
e2.Introduce();
void setAge(int age){
e1.setAge(40);
Age = age;
cout<<e1.getName() << " is "<<e1.getAge()<<" years old"<<endl;
}
return 0;
int getAge(){
}
return Age;
}
 What we can do with these getters & setters ?
• We can provide special validation rules to interact with the
class properties/variables.
– Let’s say, Employee cannot be anyone who is not older than 18 years.

void setAge(int age){

if (age >= 18){
Age = age;
}
}
Example
Example – with Validation Rules
 (ii) Abstraction
• What is abstraction?
– Hiding complex things behind a procedure that makes those things look
simple.
– Real-life example: Smart Phone
• Smart Phones can take pictures.
– How does the procedure of taking a picture looks like?
» User just press a button to click pictures
• We just press a button to make a call or send a message.
– These characteristics/functionalities are not that simple.
• For user, it is just a button click.
• For the company that makes Smart Phones, there is much more complex logic that
they need to implement in order for you to be able to press a button and then take a
picture.
 (ii) Abstraction
• There is some sort of interface between the user and the
company that produce Smart Phones.
– On user side, everything is pretty simple and easy.
– All of the complexities behind those functionalities is hidden from
users.
• The complexities are on the side of the company that produces Smart Phones.
– User do not need to know anything about the complexity in order to
be able to use the Smart Phone.
 (ii) Abstraction
• If another company comes and they want to produce Smart
Phones as well.
– What they have to do? They have to sign this contract.
• They have to provide users with a clean, simple easy to use interface.
• They have to take care on their side to implement all of the complex logic
which are hidden from users.
– Hiding this complex things from the user is called abstraction.
 (ii) Abstraction
• How we can implement this concept of Contract where one side looks
simple, and the other side very complex?
– Using abstract class.
• What complex functionality we can implement on the Employee class?
– Every Employee can ask for promotion.
• Employee approaches Boss, and Boss needs to go through a very complex thought process in
order to decide if this Employee deserves the promotion or not.
• Boss needs to consider many things.
– How long this Employee has been working for the Company?
– How much knowledge this Employee possess?
– What kind of relationship that this Employee has with their colleagues?
– How much this Employee is contributing to the Company?
– Is this Employee always late for work?
– Is this Employee breaking deadlines?
– etc.
• How can we abstract this complex functionality?
 (ii) Abstraction
• How can we abstract this complex functionality?
– In this situation, we are doing that for another developer who is going to
use our class.
– Assuming we are the ones producing the Smart Phones, we are the ones
who must provide the functionalities that are complex.
• We should provide that simple, basic interface for anyone who wants to use this
abstract class.
– How can we create that Contract?
• By using abstract classes.
• In Java & C# world, there is a concept called interface.
• In C++, we can simulate the behaviour of interface by using abstract class.
How to create an abstract class?
How to create an abstract class?
 Default copying (Copy constructor)
• By default, objects can be copied.
– In particular, a class object can be initialized with a copy of an object of its class.
– By default, the copy of a class object is a copy of each member.
• Obj1 = Obj2; → Compiler knows how to assign members of one object to other, by default.
• The behaviour of assignment operator (=) is well defined.
– If that default is not the behaviour wanted for a class X, a more appropriate
behaviour can be provided using operator overloading for that particular class X.
• Obj1 + Obj2; → Compiler does not know how to add/subtract 2 objects, by default.
• Example: Initialization by copy
– Date my_birthday = Date(27, 11, 1985);
• Date dob = my_birthday; (or)
• Date dob {my_birthday}; (or)
• Date dob(my_birthday);
Default copying - Example
 static members of a C++ class
• We can define class members static using static keyword.
– Global to a class.
– If we declare some class attribute as static, there will be a single copy of that
attribute.
• 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 0 when the first object is created, if no other
initialization is present.
– The copy of static members can be accessed using class name also.
• Static members belong to the class, not all objects.
• Any object can change its value, but the value will be changed for the only copy present.
It is similar to static members of a Function
 static members of a C++ class
• Rule:
– We cannot initialize static members inside class definition, but it can
be initialized outside the class by redeclaring the static variable using
scope resolution operator (::) to identify which class it belongs to.
– When we define a class, no memory is allocated until the first object
is created.
• That is why, static variables cannot be initialized inside the class where there
is no memory.
• Memory belong to objects only, not class.

▪ Class member function definitions/ static variable initialization belong in the scope where the
class is defined. In this case, global scope.
▪ We cannot define them inside main().
Initializing static member
Initializing static member
 static member functions (static methods)
• By declaring a function member as static, you make it independent of any
particular object of the class.
– static functions belong to all the objects.
• 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 ::
• A static member function can only access static data member, other static
member functions and any other functions from outside the class.
– Non-static attributes of a class belong to the object. Is it okay that a static
method access non-static members? No.
• Static member functions have a class scope and they do not have access to
the ‘this’ pointer of the class.
 NOTE
• Static method cannot access non-static attributes of an object.
• Static method can only access static attributes present inside
the class. call

Other functions which are outside

use

the class (not methods of some

static attributes static methods

obj1 Same copy for every object cannot call

other class)
Non-static variables

Separate copy for

Local to all the

obj2

each object

objects
Non-static variables Non-static methods

obj3
Non-static variables
static member functions - Example
 Passing and Returning Objects in C++
• In C++, we can pass class objects as arguments and also return
them from a function the same way we pass and return other
variables.
• Passing objects as arguments
– The address/reference of the object will be sent, if we pass using pointers.
– If we pass the object directly, the entire copy of that object will be sent.
– To pass an object as an argument, we write the object name as the
argument while calling the function the same way we do it for other
variables.
– Syntax: fun(object_name)
Passing an object as argument - Example

Entire content of b1 is copied into b

Returning object as argument - Example