Introduction

Object-Oriented Programming (OOP) is a programming paradigm that organizes code into objects, which can contain data and behavior. C++ is a powerful programming language that supports OOP concepts. In this blog post, we will explore the fundamentals of OOP in C++ and discuss how it can be used to write clean and maintainable code.

Encapsulation

Encapsulation is one of the fundamental concepts of OOP, and it refers to the bundling of data and methods within a class. This allows for data hiding, where the internal implementation details of a class are kept private and can only be accessed through well-defined methods. Encapsulation promotes abstraction and information hiding, making code more secure and modular.

In C++, encapsulation is achieved using classes. A class is a blueprint for creating objects, and it defines the properties (data members) and behaviors (member functions) of those objects. The data members are declared as private, preventing direct access from outside the class. Access to these private members is provided through public member functions, known as getters and setters.

class Person {
private:
    std::string name;
    int age;

public:
    void setName(const std::string& newName) {
        name = newName;
    }

    void setAge(int newAge) {
        if(newAge >= 0) {
            age = newAge;
        }
    }

    std::string getName() const {
        return name;
    }

    int getAge() const {
        return age;
    }
};

Inheritance

Inheritance is a mechanism in OOP that allows a class to inherit properties and behaviors from another class. The class that inherits is called the derived class or subclass, and the class it inherits from is called the base class or superclass. In C++, inheritance is achieved using the class keyword, followed by a colon and the access specifier (private, protected, or public), and the name of the base class.

class Vehicle {
protected:
    int wheels;

public:
    Vehicle(int numWheels) : wheels(numWheels) {}

    void drive() {
        std::cout << "Driving the vehicle with " << wheels << " wheels" << std::endl;
    }
};

class Car : public Vehicle {
private:
    std::string brand;

public:
    Car(const std::string& carBrand, int numWheels) : Vehicle(numWheels), brand(carBrand) {}

    void honk() {
        std::cout << "Honking the car of brand: " << brand << std::endl;
    }
};

Polymorphism

Polymorphism is another important aspect of OOP, where objects of different classes can be treated as objects of a common base class. This allows for code reusability and flexibility. C++ supports two types of polymorphism: compile-time polymorphism (function overloading and templates) and runtime polymorphism (virtual functions and abstract classes).

class Shape {
public:
    virtual double area() const = 0;

    virtual void draw() const = 0;
};

class Rectangle : public Shape {
private:
    double length;
    double width;

public:
    Rectangle(double len, double wid) : length(len), width(wid) {}

    double area() const override {
        return length * width;
    }

    void draw() const override {
        std::cout << "Drawing a rectangle" << std::endl;
    }
};

class Circle : public Shape {
private:
    double radius;

public:
    Circle(double rad) : radius(rad) {}

    double area() const override {
        return 3.14159 * radius * radius;
    }

    void draw() const override {
        std::cout << "Drawing a circle" << std::endl;
    }
};

Conclusion

Object-Oriented Programming allows for modular and reusable code, making it easier to develop and maintain complex systems. In C++, encapsulation, inheritance, and polymorphism are essential concepts that enable the implementation of OOP principles. By understanding and utilizing these concepts, developers can write more efficient and robust C++ code.

#OOP #C++