OBJECT ORIENTED PROGRAMMING (CST-004/CSO-053)

Dr. Ahmad Jamal

Associate Professor
Computer Science & Engineering

Unit – 1

Object Oriented Programming Concepts

Course Outcomes
Course Description Mapping with Program
Outcomes Outcomes and Program
Specific Outcomes

CO1 Recognize features of object-oriented design such as encapsulation, PO[1,2,3,4,6,12]

polymorphism, inheritance, and
composition of systems based on object identity.

CO2 Apply some common object-oriented design patterns. PO[1,2,3,4,5,6,7,12]

CO3 Specify simple abstract data types and design implementations using abstraction PO[1,2,4,6,12]
functions to document
them.

CO4 Design a convenient way for the handling problems using templates and use PO[1,2,3,4,5,6,7,12]
simple try-catch blocks for
Exception Handling.

CO5 Manage I/O streams and File I/O oriented interactions. PO[1,2,3,4,5,6,9,11,12]
Assessment and Evaluation Plan

Assessment Tools Evaluation

 Google form Internal examination= 50
 Assignments External examination=100
 Sessional
 Tutorial sheets
C++ Basic Program Example
#include <iostream>
using namespace std;
int main()
{
cout<<"Hello";
return 0;
}

Prepared by : Dr. Ahmad Jamal

Principle of OOP’s

Prepared by : Dr. Ahmad Jamal

 Procedural Programming

Procedural Programming can be defined as a programming model
which is derived from structured programming, based upon the concept
of calling procedure. Procedures, also known as routines, subroutines
or functions, simply consist of a series of computational steps to be
carried out. During a program’s execution, any given procedure might
be called at any point, including by other procedures or itself.


Languages used in Procedural Programming

C, FORTRAN, ALGOL, COBOL,

Prepared by : Dr. Ahmad Jamal

 Object-Oriented Programming

Object-oriented programming can be defined as a programming model which is
based upon the concept of objects. Objects contain data in the form of attributes
and code in the form of methods. In object-oriented programming, computer
programs are designed using the concept of objects that interact with the real
world. Object-oriented programming languages are various but the most popular
ones are class-based, meaning that objects are instances of classes, which also
determine their types.


Languages used in Object-Oriented Programming

Java, C++, C#, Python,

PHP, JavaScript, Ruby, Perl,
Prepared by : Dr. Ahmad Jamal
 Procedural Oriented Programming Object-Oriented Programming

In procedural programming, the program is divided into In object-oriented programming, the program is divided
small parts called functions. Heading into small parts called objects.

Procedural programming follows a top-down approach. Object-oriented programming follows a bottom-up

approach.

There is no access specifier in procedural programming. Object-oriented programming has access specifiers like
private, public, protected, etc.

Adding new data and functions is not easy. Adding new data and function is easy.

Procedural programming does not have any proper way of Object-oriented programming provides data hiding so it is
hiding data so it is less secure. more secure.

In procedural programming, there is no concept of data In object-oriented programming, the concept of data
hiding and inheritance. hiding and inheritance is used.

Prepared by : Dr. Ahmad Jamal

 Procedural Oriented Programming Object-Oriented Programming

than the data.

Heading
In procedural programming, the function is more important In object-oriented programming, data is more important
than function.

Procedural programming is based on the unreal world. Object-oriented programming is based on the real world.

Procedural programming is used for designing medium- Object-oriented programming is used for designing large
sized programs. and complex programs.

Code reusability absent in procedural programming, Code reusability present in object-oriented programming.

Examples: C, FORTRAN, Pascal, Basic, etc. Examples: C++, Java, Python, C#, etc

Prepared by : Dr. Ahmad Jamal

 Class and Object

A class is a blueprint which defines properties and behaviour

of similar objects or entities. Each object is an instance of a
class which has those properties and behaviors associated
with them.

When classes are defined, no memory is allocated to them

as these classes are merely a concept or user-defined data
type. However, when we create objects of these classes,
memory is allocated in the heap. Prepared by : Dr. Ahmad Jamal
 Class and Object Example
#include <iostream>
using namespace std;
class Myclass {
public:
string name;
void printname() { cout << "My Name is:" << name; }
};
int main()
{
Myclass obj1;
obj1.name = "Dr. Ahmad Jamal";
obj1.printname();
return 0;
}
Prepared by : Dr. Ahmad Jamal
 Abstraction
Abstraction is the concept of object-oriented programming
that “shows” only essential attributes and “hides” unnecessary
information. The main purpose of abstraction is hiding the
unnecessary details from the users. Abstraction is selecting
data from a larger pool to show only relevant details of the
object to the user. It helps in reducing programming
complexity and efforts. It is one of the most important
concepts of OOPs.
Prepared by : Dr. Ahmad Jamal
 Encapsulation

Encapsulation is defined as the wrapping up of data under a single unit. It is the

mechanism that binds together code and the data it manipulates. Another way to
think about encapsulation is, that it is a protective shield that prevents the data
from being accessed by the code outside this shield.

Advantages of Encapsulation:


Data Hiding:

Increased Flexibility:

Reusability:

Testing code is easy:
Prepared by : Dr. Ahmad Jamal
 Inheritance
The capability of a class to derive properties and characteristics from another class is called
Inheritance. Inheritance is one of the most important features of Object-Oriented Programming.

Inheritance is a feature or a process in which, new classes are created from the existing classes.
The new class created is called “derived class” or “child class” and the existing class is known as
the “base class” or “parent class”. The derived class now is said to be inherited from the base
class.
When we say derived class inherits the base class, it means, the derived class inherits all the
properties of the base class, without changing the properties of base class and may add new
features to its own. These new features in the derived class will not affect the base class. The
derived class is the specialized class for the base class.

Sub Class: The class that inherits properties from another class is called Subclass or Derived
Class.
Super Class: The class whose properties are inherited by a subclass Prepared
is calledbyBase ClassJamal
: Dr. Ahmad or
Inheritance

Prepared by : Dr. Ahmad Jamal

 Types of Inheritance
Single Inheritance − A subclass derives from a single super-class.
Multiple Inheritance − A subclass derives from more than one super-
classes.
Multilevel Inheritance − A subclass derives from a super-class which in
turn is derived from another class and so on.
Hierarchical Inheritance − A class has a number of subclasses each of
which may have subsequent subclasses, continuing for a number of
levels, so as to form a tree structure.
Hybrid Inheritance − A combination of multiple and multilevel inheritance
so as to form a lattice structure.
Prepared by : Dr. Ahmad Jamal
Prepared by : Dr. Ahmad Jamal
 Polymorphism
Polymorphism is the ability of any data to be processed in more than one form. The word
itself indicates the meaning as poly means many and morphism means types.
Polymorphism is one of the most important concepts of object-oriented programming
languages. The most common use of polymorphism in object-oriented programming occurs
when a parent class reference is used to refer to a child class object. Here we will see how
to represent any function in many types and many forms. In a real-life example of
polymorphism, a person at the same time can have different roles to play in life. Like a
woman, at the same time is a mother, a wife, an employee and a daughter. So the same
person has to have many features but has to implement each as per the situation and the
condition.

It is the ability of an object or reference to take many forms in different instances. It

implements the concept of function overloading, function overriding and virtual functions.
Prepared by : Dr. Ahmad Jamal
 Methods
(Member Functions)
Member functions are functions that are defined within a class and operate on the
data members of that class. They encapsulate the behavior associated with the
class and allow you to interact with the class's data. Member functions can be
public, private, or protected, controlling the visibility and accessibility of these
functions from outside the class.
Example:
class MyClass {
public:
void printMessage() {
cout << "Hello I am inside the Methods";
}
};

Prepared by : Dr. Ahmad Jamal

 Messages
(Method Calls)

Method calls, also known as function calls, are used to invoke a particular member function
of an object. You call a member function on an instance of the class using the dot operator
(.).

Example:

int main() {
MyClass obj;
obj.printMessage(); // Calling the member function
return 0;
}

Prepared by : Dr. Ahmad Jamal

 Introduction to C++
C++ is a powerful and widely used general-purpose programming language that was developed as an extension
of the C programming language. It combines both high-level features for easy program development and low-
level features for efficient system programming. C++ is known for its flexibility, performance, and object-oriented
programming (OOP) capabilities.

1: History and Development

C++ was created by Bjarne Stroustrup in the early 1980s. It was developed to extend the capabilities of the C
programming language by adding support for object-oriented programming. The name "C++" reflects this
extension; it signifies "incremented C."

Prepared by : Dr. Ahmad Jamal

 2: Features C++
C++ inherits many features from C while introducing new concepts, including:
Object-Oriented Programming (OOP): C++ supports classes, objects, encapsulation, inheritance, and
polymorphism, enabling the development of complex, modular software.
Templates: C++ introduced templates, which allow for generic programming and code reusability by writing
code that works with multiple data types.
Standard Template Library (STL): The STL provides a collection of template classes and functions for common
data structures (like vectors, lists, and maps) and algorithms (like sorting and searching).
Strong Typing: C++ enforces strong type checking, which can help catch errors at compile time and improve
program reliability.
Efficiency and Low-Level Features: C++ allows direct memory manipulation, pointer arithmetic, and access to
hardware resources, making it suitable for systems programming and performance-critical applications.
Exception Handling: C++ provides mechanisms for handling exceptions, enabling better error management
and recovery in programs.
Operator Overloading: C++ lets you define custom behaviors for operators when used with user-defined types.
Multiple Inheritance: C++ supports multiple inheritance, allowing a class to inherit characteristics from more
than one parent class.

Prepared by : Dr. Ahmad Jamal

 3: Basic Syntax: C++

C++ syntax shares many similarities with C, but with added features for OOP. Here's a simple example of a
"Hello, World!" program in C++:

#include <iostream> using namespace std;

int main() {
cout << "Hello, World!";
return 0;
}

Prepared by : Dr. Ahmad Jamal

4: Compilation: Like C, C++ source code is compiled into machine code using a compiler. The compiled output
can then be executed.

5: IDEs and Tools: Various Integrated Development Environments (IDEs) and text editors support C++
development. Examples include Dev C++, Visual Studio, Visual Studio Code etc.

6: Applications: C++ is used in a wide range of applications, including:

• Systems programming (operating systems, drivers, etc.)
• Game development
• Real-time simulations
• Embedded systems
• High-performance software
• Graphics and multimedia applications
• Scientific computing

C++ provides a balance between high-level abstractions and low-level control, making it suitable for a diverse
set of programming tasks. It has a rich ecosystem of libraries and tools that contribute to its popularity and
versatility.

Prepared by : Dr. Ahmad Jamal

 Class and Object: C++
Classes:
• Blueprints or templates that define attributes and behaviors.
• Encapsulate data (attributes) and functions (methods).
• Foundation for creating objects.

Objects:
• Instances of classes, representing specific data and behavior.
• Created based on class templates.
• Access class attributes and methods through objects.

Prepared by : Dr. Ahmad Jamal

 Class and Object: C++ Example
#include <iostream>
class Rectangle {
public:
double length; • The Rectangle class has public attributes
double width; length and width.
double calculateArea() { • We create an object myRectangle and directly
return length * width; assign values to its attributes.
} • The calculateArea method calculates the area
based on the attributes.
}; • The rest of the program remains similar,
int main() { calculating and displaying the area of the
Rectangle myRectangle; rectangle.
myRectangle.length = 5.0;
myRectangle.width = 3.0;
double area = myRectangle.calculateArea();
std::cout << "Rectangle Area: " << area << std::endl;
return 0;
}

Prepared by : Dr. Ahmad Jamal

 Structures and Classes
1: Structure:
Default Access Control:
Members of a structure have public access by default.
This means that the attributes (variables) are accessible directly from outside the structure.

Usage:
Structures are often used for grouping related variables together.
They do not support member functions (methods) by default, although you can define functions outside the
structure to operate on its data.

Prepared by : Dr. Ahmad Jamal

 Structure Example

struct Point {
double x;
double y;
};

int main() {
Point p;
p.x = 3.0;
p.y = 5.0;

return 0;
}

Prepared by : Dr. Ahmad Jamal

2: Classes

Default Access Control:

Members of a class have private access by default.
This means that the attributes (variables) are not accessible directly from outside the class.

Usage:
Classes are used for creating objects that encapsulate data and behavior.
They can have member functions (methods) which allow the manipulation of data.

Prepared by : Dr. Ahmad Jamal

 Class Example
class Circle {
private:
double radius;

public:
double calculateArea() {
return 3.14159 * radius * radius;
}
};

int main() {
Circle c;
c.radius = 4.0; // This would be an error since radius is private
c.calculateArea();
return 0;
}

Prepared by : Dr. Ahmad Jamal

Commonalities: Structures and Classes

• Both structures and classes can be used to group data members together.
• Both can have constructors and destructors for initialization and cleanup.
• Both can use access specifiers (public, private, protected) to control
member visibility.

When to Use Which:

• Use structures when you need a simple data container with no specific
behavior.
• Use classes when you need to encapsulate data and behavior, and when
you want to follow the principles of object-oriented programming.
Prepared by : Dr. Ahmad Jamal
 Unions and Classes
Union:

Memory Sharing:
All members of a union share the same memory location. This means that only one member can
hold a value at a time.
Changing the value of one member affects the other members.
Memory Size:
The memory size of a union is determined by the largest member.
This can be useful for conserving memory when you need to store different types of data at
different times.
Accessing Members:
You can access members of a union using the dot (.) operator, just like with structures.
Only one member should be accessed at a time, and it's your responsibility to know which member
is currently valid.
Use Cases:
Used when you want to save memory by storing different types of data in the same memory
location.
Useful for scenarios where only one member needs to hold a value at a time, like different types of
statuses.
Prepared by : Dr. Ahmad Jamal
Classes:
Memory Allocation:
Each member of a class has its own separate memory space.
Changing the value of one member does not affect the others.
Memory Size:
The memory size of a class is the sum of the memory used by its members and any padding
added for alignment.
Member Functions:
Classes can have member functions (methods) that provide behavior and operations related to the
data members.
Encapsulation allows you to control access to the members and enforce proper usage.
Object Creation:
Objects of a class can be created, which encapsulate data and behavior.
Each object has its own separate memory for data members.
Use Cases:
Used when you want to group related data and behavior together in a modular and organized way.
Suitable for creating instances of objects that can interact with each other.

Prepared by : Dr. Ahmad Jamal

 Example : Union and Class
int main() {
#include <iostream>
// Union usage
union NumberUnion {
NumberUnion numUnion;
int intValue;
numUnion.intValue = 42;
double doubleValue;
std::cout << "Union integer value: " <<
};
numUnion.intValue;
class NumberClass {
public:
// Class usage
int intValue;
NumberClass numClass;
double doubleValue;
numClass.intValue = 42;
void printInt() {
numClass.doubleValue = 3.14;
std::cout << "Integer value: " << intValue;
numClass.printInt();
}
numClass.printDouble();
void printDouble() {
return 0;
std::cout << "Double value: " << doubleValue;
}
}
In this example, the NumberUnion union stores an integer or a double value in the same
};
memory location. The NumberClass class stores an integer and a double value in separate
memory locations. The class also has member functions to print the values, providing more
encapsulation and behavior.
Prepared by : Dr. Ahmad Jamal
 Access Modifier/Specifier

Protecte
Public Private
d
Access modifiers in C++ are keywords that determine the visibility and
accessibility of class members (attributes and methods) from different parts
of the program. C++ supports three main access modifiers: public, private,
and protected. These modifiers control the level of encapsulation and the
ability to interact with class members from various contexts.

Prepared by : Dr. Ahmad Jamal

 Public
Members declared as public are accessible from anywhere in the program, both inside and outside the
class.
There are no restrictions on accessing public members.

Example:

class MyClass {
public:
int publicAttribute;
void publicMethod() {
// ...
}
};

Prepared by : Dr. Ahmad Jamal

 Private
Members declared as private are accessible only from within the same class.
Outside the class, private members cannot be accessed directly.

Example:

class MyClass {
private:
int privateAttribute;
void privateMethod() {
// ...
}
};

Prepared by : Dr. Ahmad Jamal

 Protected
Members declared as protected are similar to private members, but they can also be accessed by
derived classes (subclasses).
Example:

class BaseClass {
protected:
int protectedAttribute;
void protectedMethod() {
// ...
}
};

class DerivedClass : public BaseClass {

void someFunction() {
protectedAttribute = 42; // Accessible due to inheritance
}
};
Prepared by : Dr. Ahmad Jamal
Access modifiers provide the following benefits:
Encapsulation: You can control the level of exposure of your class members, protecting the integrity of
your data.
Abstraction: You can hide the implementation details from users of your class, providing only the
essential interface.
Inheritance: Access modifiers play a role in the inheritance hierarchy, allowing derived classes to
access certain members of their base classes.

class MyClass {
public: // Accessible everywhere
int publicAttribute;

private: // Accessible only within the class

int privateAttribute;

protected: // Accessible within the class and its derived classes

int protectedAttribute;
};

Prepared by : Dr. Ahmad Jamal

 Friend Function
Friend function is a function that is not a member of a class but is granted access to the private and
protected members of that class. This allows the friend function to interact with the private and
protected members of the class as if it were a member function, even though it is not defined within the
class itself.

Friend functions are often used in situations where you want to provide external functions with special
privileges to access class members that are not accessible to the general public.

Prepared by : Dr. Ahmad Jamal

 Friend Class
In C++, a friend class is a class that is granted special access to the private and protected members of
another class. This means that the friend class can access these members as if they were its own,
even though they are not accessible by other classes or functions.

Friend Declaration:
A class can be declared as a friend of another class using the friend keyword in the class that is
granting access.
This allows the friend class to access private and protected members of the class it's friends with.
Access Control:
A friend class has access to all the members (including private members) of the class it's friends
with.
The friend class does not inherit from the class it's friends with; it simply gains access to its
members.

Prepared by : Dr. Ahmad Jamal

 Abstract Classes
An abstract class in C++ is a class that cannot be instantiated on its own, but serves as a blueprint for other classes. It
defines a common interface and may provide some basic implementation for its derived classes. Abstract classes are
used to create a common structure for a group of related classes, ensuring that certain methods are implemented by
the derived classes.
Pure Virtual Functions:
An abstract class must have at least one pure virtual function, which is declared using the syntax
virtual returnType functionName() = 0;.
A pure virtual function has no implementation in the abstract class and must be overridden by derived classes.
Abstract Class Instantiation:
Abstract classes cannot be instantiated directly. You can only create instances of classes that derive from the
abstract class.
Derived Classes:
Derived classes from an abstract class must provide implementations for all pure virtual functions inherited from
the abstract class. If they don't, they also become abstract classes.
Interface Definition:
Abstract classes provide a way to define interfaces, ensuring that derived classes implement specific methods.
Partial Implementation:
Abstract classes can provide partial implementation of methods that are common to all derived classes.
Derived classes can choose to override or use the provided implementation.

Prepared by : Dr. Ahmad Jamal

 Inline Functions
An inline function is a function that is expanded at the point of the call instead of being called through a
function call mechanism. This can potentially lead to performance improvements in certain cases, as it
avoids the overhead of a function call. Inline functions are defined using the inline keyword.

#include <iostream>
// Inline function declaration
inline int add(int a, int b) {
return a + b;
}
int main() {
int x = 5, y = 10;
// Inline function call
int result = add(x, y);
std::cout << "Result: " << result << std::endl;
return 0;
}

Prepared by : Dr. Ahmad Jamal

When the compiler encounters a call to an inline function, it replaces the function call with the actual
code of the function, effectively "inlining" the code at the call site. However, whether a function is
actually inlined or not is ultimately up to the compiler's optimization decisions. The inline keyword
serves as a hint to the compiler, but the compiler can still choose not to inline the function if it believes
that doing so might not result in performance improvements or if the function is too complex.

Inline functions are typically used for small, frequently called functions where the overhead of the
function call is more significant than the actual function execution. However, using inline excessively or
on large functions can actually lead to larger executable sizes and might not always result in
performance gains.

Modern C++ compilers often perform automatic inlining as part of their optimization process without
explicitly using the inline keyword. The inline keyword provides a suggestion to the compiler, but the
compiler can make its own decisions based on the code and optimization settings.

Prepared by : Dr. Ahmad Jamal

 Static Class Members
Static class members are class members (variables or functions) that are
shared among all instances of the class. They belong to the class itself rather
than to any specific instance of the class. This means that all instances of the
class will have access to the same static member, and there will be only one
copy of that member regardless of how many instances of the class are
created.

Static members are defined using the static keyword within the class
definition.

Prepared by : Dr. Ahmad Jamal

#include <iostream>
class MyClass {
public:
// Static member variable
static int staticVar;

// Static member function

static void staticFunction() {
std::cout << "This is a static function." << std::endl;
}
};
// Initializing the static member variable
int MyClass::staticVar = 0;
int main() {
// Accessing static member variable
MyClass::staticVar = 42;

// Accessing static member function

MyClass::staticFunction();
return 0;
}
Prepared by : Dr. Ahmad Jamal
 Key points about static class members:
●
Memory Allocation: Static member variables are stored in a single memory location shared by all
instances of the class. They are allocated memory once, and their value is consistent across all
instances.
●
Accessing Static Members: Static members are accessed using the class name followed by the
scope resolution operator ::.
●
Initialization: Static member variables are typically defined outside the class definition (in the global
scope) where you can also initialize them. Initialization is essential since static members do not have
constructors like instance members.
●
Visibility: Static member variables and functions are usually declared as public, private, or protected,
just like any other class member.
●
Inheritance: Static members are inherited by derived classes, but they remain associated with the
base class. Derived classes can also override static member functions with their own
implementations.
●
Friendship: Like non-static members, static members can also be declared as friend to grant specific
classes or functions access to them.

Prepared by : Dr. Ahmad Jamal

 Scope Resolution Operator (::)
Scope Resolution Operator (::) is a fundamental operator in C++ used to access names (such as
variables, functions, or types) defined in different scopes. It's used to specify the scope in which a
particular name is located. This operator is particularly important when working with namespaces,
classes, and their members.

Scope Resolution Operator is crucial for resolving ambiguity and accessing names defined in different
scopes. It's a key tool for managing namespaces, classes, and their members in C++.

Prepared by : Dr. Ahmad Jamal

 Nested Classes
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal

 Heading
Content.

Prepared by : Dr. Ahmad Jamal