Object-Oriented

Programming (OOP) in C++:

This document serves as a comprehensive guide to Object-Oriented Programming (OOP) in C++. It will delve into the
fundamental concepts, syntax, and implementation of OOP in C++ through a series of detailed explanations and illustrative
examples. By exploring key OOP principles such as classes, objects, inheritance, polymorphism, and encapsulation, this guide
aims to provide a solid foundation for understanding and applying OOP techniques in your C++ programs.

KH by Krish Hackz
Introduction to Object-
Oriented Programming
(OOP)
Object-Oriented Programming (OOP) is a programming paradigm that emphasizes the use of objects and classes to design
and develop software systems. In OOP, data and the operations that act on that data are bundled together into units called
objects. OOP concepts help to model real-world scenarios into code, making it more understandable, manageable, and
reusable. The core idea is to break down a complex program into smaller, self-contained units called objects, each
representing a distinct entity with its own properties (data) and actions (methods).

Let's understand the core principles of OOP:

Abstraction Encapsulation
Abstraction focuses on representing essential features Encapsulation is the process of bundling data and
of an object while hiding unnecessary details. This methods that operate on that data within a single unit
allows developers to work with objects in a more called a class. It controls access to the data, ensuring
simplified way without needing to know their internal data integrity and preventing unintended
workings. Think of it as using a remote to control your modifications. Encapsulation promotes code
TV – you interact with the essential functions (volume, reusability and makes it easier to maintain and modify
channel, etc.) without knowing the intricate electronics classes without affecting other parts of the program.
inside.

Inheritance Polymorphism
Inheritance is a powerful mechanism that allows a Polymorphism means "many forms." In OOP,
new class to inherit properties and methods from an polymorphism refers to the ability of an object to take
existing class. This promotes code reuse and reduces on multiple forms. This enables a single interface to
redundancy. For example, a "Car" class can inherit handle different data types and behaviors, making
properties like "engine" and "wheels" from a more code more flexible and adaptable. For example, a
general "Vehicle" class. "Shape" class can have methods to calculate area and
perimeter, and different derived classes like "Circle"
and "Rectangle" can override these methods to
implement the specific calculations for their shapes.
Syntax of OOP: Classes
and Objects
In C++, classes serve as blueprints for creating objects. A class defines the properties (data members) and actions (member
functions) that objects of that class will possess. Objects are instances of classes, representing concrete entities. Let's
illustrate this with a simple example:

class Dog {
public:
string name;
int age;

void bark() {
cout << "Woof!" << endl;
}
};

int main() {
Dog myDog; // Create an object of the Dog class
myDog.name = "Buddy";
myDog.age = 3;
myDog.bark();
return 0;
}

Here, we define a class named "Dog" with properties "name" (a string) and "age" (an integer). The "bark()" function represents
an action that a Dog object can perform. In the main function, we create an object called "myDog" of the "Dog" class. We
assign values to "myDog" and call the "bark()" method.
Defining Classes and
Creating Objects
Let's delve deeper into the process of defining classes and creating objects.

**Defining a Class:**

A class definition in C++ uses the keyword "class" followed by the class name and curly braces that enclose the class
members (data and methods). For example:

class Car {
public:
string make;
string model;
int year;

void startEngine() {
cout << "Engine started!" << endl;
}
};

In this example, the class "Car" has three data members ("make," "model," and "year") and one member function
"startEngine()."

**Creating Objects:**

To create an object of a class, you use the class name followed by the object name. For instance:

Car myCar; // Creates an object named "myCar" of the "Car" class

This creates an instance of the "Car" class named "myCar." You can now access its members (data and methods) using the
dot operator (.).

myCar.make = "Toyota";
myCar.model = "Camry";
myCar.startEngine();
Class Methods and
Member Functions
Member functions define the actions that objects of a class can perform. They operate on the data members within the
class.

class Circle {
public:
double radius;

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

double calculateCircumference() {
return 2 * 3.14159 * radius;
}
};

Here, we have a "Circle" class with a data member "radius." It has two member functions: "calculateArea()" and
"calculateCircumference()." These functions work specifically with the "radius" to calculate the area and circumference of a
circle, respectively.

**Using Member Functions:**

To use member functions, you call them on an object using the dot operator.

Circle myCircle;
myCircle.radius = 5;

double area = myCircle.calculateArea();

double circumference = myCircle.calculateCircumference();
Constructors and
Destructors
Constructors are special member functions that are automatically invoked when an object of a class is created. They are
used to initialize the data members of an object.

class Rectangle {
public:
int length;
int width;

Rectangle(int l, int w) { // Constructor

length = l;
width = w;
}
};

In this example, the "Rectangle" class has a constructor that takes two parameters ("l" and "w") to initialize the "length" and
"width" data members when a "Rectangle" object is created.

**Destructors:**

Destructors are also special member functions, but they are called automatically when an object is destroyed. They are used
to perform cleanup tasks, such as releasing resources allocated to the object. Destructor names are preceded by a tilde (~)
and have the same name as the class.

class MyResource {
public:
// ... other members
~MyResource() {
// Release resources, e.g., close files or free memory
}
};
Encapsulation: Data Hiding
and Access Modifiers
Encapsulation is a fundamental OOP principle that combines data and the methods that operate on that data into a single
unit called a class. It also controls access to the data, protecting it from unauthorized modifications. C++ uses access
modifiers to manage this access control.

**Access Modifiers:**

C++ provides three access modifiers: "public," "private," and "protected."

**Public:** Members declared as "public" are accessible from anywhere, including outside the class.
**Private:** Members declared as "private" are only accessible from within the class.
**Protected:** Members declared as "protected" are accessible from within the class and from classes that inherit from
it.

Here's an example of how to use access modifiers:

class Employee {
private:
int employeeId;
string name;

public:
void setEmployeeId(int id) {
employeeId = id;
}

int getEmployeeId() {
return employeeId;
}

void setName(string n) {
name = n;
}

string getName() {
return name;
}
};

In this example, "employeeId" and "name" are declared as "private," meaning that they can only be accessed within the
"Employee" class. To modify or access these data members, we use the "setEmployeeId," "getEmployeeId," "setName," and
"getName" public member functions.
Inheritance: Deriving New
Classes from Existing Ones
Inheritance is a powerful mechanism in OOP that allows you to create new classes (derived classes) that inherit properties
and methods from existing classes (base classes). This promotes code reuse, reduces redundancy, and makes it easier to
extend functionality.

**Syntax of Inheritance:**

class DerivedClass : public BaseClass {

// ... members of the derived class
};

Here, "DerivedClass" inherits from "BaseClass" using the colon (:) followed by the keyword "public" and the name of the base
class. The keyword "public" specifies the access mode of inherited members.

**Example of Inheritance:**

class Vehicle {
public:
string brand;
int year;

void startEngine() {
cout << "Engine started!" << endl;
}
};

class Car : public Vehicle {

public:
string model;

void honk() {
cout << "Beep beep!" << endl;
}
};

In this example, the "Car" class inherits from the "Vehicle" class. It inherits the "brand" and "year" properties and the
"startEngine()" function from the "Vehicle" class. It also has its own additional property "model" and a new member function
"honk()."
Polymorphism: Function
and Operator Overloading
Polymorphism (meaning "many forms") in OOP allows an object to take on multiple forms. This is achieved through function
overloading and operator overloading.

**Function Overloading:**

Function overloading allows you to define multiple functions with the same name but different parameter lists. The compiler
determines which function to call based on the arguments provided during the function call.

int add(int a, int b) {

return a + b;
}

double add(double a, double b) {

return a + b;
}

In this example, we have two functions named "add." The first function takes two integers and returns their sum. The second
function takes two doubles and returns their sum.

**Operator Overloading:**

Operator overloading enables you to redefine how existing operators work for custom data types. For instance, you can
overload the "+" operator to define addition for objects of your own classes.

class Complex {
private:
int real;
int imaginary;

public:
Complex(int r, int i) : real(r), imaginary(i) {}

Complex operator+(const Complex& other) const {

return Complex(real + other.real, imaginary + other.imaginary);
}
};

Here, we overload the "+" operator for the "Complex" class. The overloaded "+" operator takes two "Complex" objects and
returns a new "Complex" object representing their sum.
Conclusion: Benefits and
Applications of OOP in C++
Object-Oriented Programming in C++ offers numerous advantages, making it a highly popular and versatile programming
paradigm.

**Benefits of OOP:**

**Modularity:** Code is broken down into reusable, self-contained units called objects, making it easier to manage and
maintain large programs.
**Code Reusability:** Inheritance allows for code reuse, reducing development time and effort.
**Data Hiding:** Encapsulation protects data from unauthorized access, promoting data integrity and security.
**Flexibility:** Polymorphism allows for dynamic binding, making code more adaptable to changing requirements.
**Real-world Modeling:** OOP principles enable the modeling of real-world scenarios, making it easier to represent
complex systems in software.

**Applications of OOP in C++:**

OOP is widely used in various software development domains:

**Game Development:** OOP is ideal for creating complex game objects and interactions.
**GUI Applications:** OOP is often used in building graphical user interfaces with reusable components.
**Database Systems:** OOP concepts are applied in database design and management.
**Operating Systems:** OOP helps structure and organize complex operating system components.

**Web Development:** OOP frameworks like PHP and Ruby on Rails leverage OOP principles for web applications.