Object Oriented programming

Imagine you're building with Legos. You have individual bricks (like variables) that come together to form specific structures (like objects). Object-Oriented Programming (OOP) in C++ is similar. It's a way of organizing code around real-world things (objects) and their interactions. This chapter delves into the core concepts of OOP, making you a C++ pro at building well-structured and reusable programs.

Note : We will discuss all the these concepts individually in more detail with code example. Here is the basic overview

Building Blocks of OOP

Objects

Objects are the fundamental units in OOP. They represent real-world or abstract entities with two key aspects:

Properties (Data): Imagine the individual bricks of your Lego model. These bricks hold information about the object, like its color, size, or type. In C++, these properties are represented by member variables within a class.

Behaviors (Functions): Think of the actions your Lego creation can perform. It might roll, open a door, or make a sound. In C++, these actions are represented by member functions within a class.

Real-World Example: Consider a Car object. Its properties (member variables) could be color, model, and year. Its behaviors (member functions) could be startEngine(), accelerate(), and brake().

Classes The Blueprints

A class acts as a blueprint or template for creating objects. It defines the properties (data members) and behaviors (member functions) that objects of that class will share.
Think of a class like a cookie cutter. You can use the same cutter to create multiple cookies (objects) with the same basic shape and features, but each cookie might have its own unique details.

				
					class Car {
public:
    std::string color;  // Member variable (data)
    std::string model;  // Member variable (data)
    int year;           // Member variable (data)

    void startEngine() { // Member function (behavior)
        std::cout << "Engine started!" << std::endl;
    }
};

Creating and Using Objects

Bringing the Blueprint to Life: Object Creation

Once you have a class definition (the blueprint), you can create objects (instances) of that class. Imagine using the Lego instructions to build your car model.

				
					Car myCar; // Declares an object named myCar of class Car

myCar.color = "Red";   // Assigning value to a member variable
myCar.model = "Tesla Model S";
myCar.year = 2024;

myCar.startEngine();  // Calling a member function

Accessing Object Properties and Behaviors

You use the dot operator (.) to access the member variables and functions of an object. It’s like using instructions to interact with the built Lego model.

				
					std::cout << "Car Color: " << myCar.color << std::endl;
std::cout << "Car Model: " << myCar.model << std::endl;
std::cout << "Car Year: " << myCar.year << std::endl;

Inheritance

The Power of Inheritance: Reusing Code

Inheritance allows you to create new classes (derived classes) that inherit properties and behaviors from an existing class (base class). This promotes code reusability and simplifies complex relationships between objects.

Real-World Example: Imagine a hierarchy of vehicles. You can have a base class Vehicle with common properties like color and speed. Then, derived classes like Car and Truck can inherit these properties and add their own specific features like trunkSpace (for Truck) or doorCount (for Car).

				
					class Vehicle {
public:
    std::string color;
    int speed;

    void move() {
        std::cout << "Vehicle is moving." << std::endl;
    }
};

class Car : public Vehicle { // Car inherits from Vehicle
public:
    int doorCount;

    void accelerate() {
        std::cout << "Car is accelerating!" << std::endl;
    }
};

Polymorphism: Responding Differently

Sending One Message, Getting Multiple Responses

Polymorphism allows objects of different derived classes to respond differently to the same function call when the function is declared as virtual in the base class. This enables flexible and dynamic behavior at runtime.
Real-World Example: Imagine a race with various vehicles (derived classes) participating. They all respond to a “startRace()” message (function call) but in their own ways (a car accelerates, a bike pedals, etc.). Polymorphism allows you to call “startRace()” on any vehicle object, and the correct derived class implementation will be executed based on the object’s type.

				
					class Vehicle {
public:
    virtual void move() { // Declared as virtual in the base class
        std::cout << "Vehicle is moving." << std::endl;
    }
};

class Car : public Vehicle {
public:
    void move() override { // Override keyword for derived class implementation
        std::cout << "Car is accelerating!" << std::endl;
    }
};

class Bike : public Vehicle {
public:
    void move() override {
        std::cout << "Bike is pedaling!" << std::endl;
    }
};

int main() {
    Vehicle* myVehicle; // Pointer to a base class (can hold addresses of derived class objects)

    Car myCar;
    Bike myBike;

    myVehicle = &myCar; // Assigning address of a Car object
    myVehicle->move(); // Output: Car is accelerating! (polymorphic behavior)

    myVehicle = &myBike; // Assigning address of a Bike object
    myVehicle->move(); // Output: Bike is pedaling! (polymorphic behavior)
}

Advanced OOP Concepts

Constructors and Destructors

Constructors are special member functions that are automatically called when an object is created. They are typically used to initialize the object’s member variables.
Destructors are special member functions that are automatically called when an object goes out of scope or is explicitly destroyed using the delete keyword. They are used to clean up any resources allocated by the object (like deallocating memory).

				
					class Book {
public:
    std::string title;
    int year;

    Book(const std::string& title, int year) : title(title), year(year) { // Constructor with arguments
        std::cout << "Book created!" << std::endl;
    }

    ~Book() { // Destructor
        std::cout << "Book destroyed." << std::endl;
    }
};

Access Specifiers

C++ provides access specifiers (public, private, and protected) to control access to members within a class and its derived classes.
public members are accessible from anywhere in the program.
private members are only accessible within the class and its friend classes (if declared).
protected members are accessible within the class, its derived classes, and friend classes.

				
					class Book {
public:
    std::string title;
    int year;

    Book(const std::string& title, int year) : title(title), year(year) { // Constructor with arguments
        std::cout << "Book created!" << std::endl;
    }

    ~Book() { // Destructor
        std::cout << "Book destroyed." << std::endl;
    }
};

Operator Overloading

Operator overloading allows you to define custom behavior for operators (like +, -, or <<) when used with objects of a class. This can improve code readability and maintainability.

Overloading the + operator for complex numbers

				
					class Complex {
public:
    double real;
    double imag;

    Complex(double real, double imag) : real(real), imag(imag) {}

    Complex operator+(const Complex& other) { // Overloading the + operator
        return Complex(real + other.real, imag + other.imag);
    }
};

By overloading operators, you can make your code more intuitive and expressive, allowing you to use operators with user-defined types in a way that mimics their behavior with built-in types.

For example, you can overload the + operator to concatenate two strings, the << operator to output custom objects to the console, or the == operator to compare the equality of two objects based on their internal state.

Object-Oriented Programming in C++ provides a powerful and flexible way to design and organize code. By encapsulating data and behavior into objects, and utilizing concepts like inheritance and polymorphism, developers can create modular, reusable, and maintainable software solutions.In conclusion, mastering OOP concepts is essential for becoming proficient in C++ programming and building robust, scalable applications.Happy coding! ❤️