OOP in C++

What is Object-Oriented Programming (OOP)?

OOP is a programming paradigm that organizes code into objects, each representing a real-world entity or concept. It provides a structured approach to code organization and promotes code reusability.

Key Concepts of OOP:

• Encapsulation: Bundling data and methods into a single unit (class).
• Inheritance: Deriving new classes from existing ones.
• Polymorphism: Providing multiple forms for a single function or method.
• Abstraction: Hiding complex implementation details and showing only the essential features.

Why Use OOP?

• Modularity: Code is organized into classes and objects.
• Reusability: Inheritance allows you to reuse existing code.
• Flexibility: Polymorphism allows you to use a single interface for multiple data types.
• Maintainability: Encapsulated code is easier to maintain.

Classes and Objects

What is a Class?

A class is a blueprint for creating objects. It defines properties (data members) and methods (member functions) that the objects will have.

Syntax:

class ClassName {
    // Access Specifiers (public, private, protected)
    data_members;
    member_functions;
};

Example:

#include <iostream>
using namespace std;

// Defining a class
class Car {
private:
    string brand;
    int speed;

public:
    // Method to set car details
    void setDetails(string b, int s) {
        brand = b;
        speed = s;
    }

    // Method to display car details
    void displayDetails() {
        cout << "Brand: " << brand << ", Speed: " << speed << " km/h" << endl;
    }
};

// Main function
int main() {
    Car car1;
    car1.setDetails("Tesla", 200);
    car1.displayDetails();
    return 0;
}

Output:

Brand: Tesla, Speed: 200 km/h

Explanation:

• The class Car has two private data members (brand and speed).
• It has two public member functions (setDetails and displayDetails).
• An object car1 is created from the Car class and used to call the methods.

Access Specifiers in Classes

Access specifiers define the accessibility of data members and member functions of a class.

Types of Access Specifiers:

• Public: Accessible from anywhere.
• Private: Accessible only within the class.
• Protected: Accessible within the class and derived classes.

Example:

#include <iostream>
using namespace std;

class Example {
private:
    int privateVar;

public:
    int publicVar;

protected:
    int protectedVar;
};

int main() {
    Example obj;
    obj.publicVar = 10; // Accessible
    // obj.privateVar = 20; // Error: Not accessible
    // obj.protectedVar = 30; // Error: Not accessible
    return 0;
}

Constructors and Destructors

What is a Constructor?

A constructor is a special member function that is automatically called when an object of a class is created. It initializes the object.

Characteristics:

• Has the same name as the class.
• No return type (not even void).
• Can be overloaded.

Types of Constructors:

1. Default Constructor: No parameters.
2. Parameterized Constructor: Accepts parameters.
3. Copy Constructor: Creates an object as a copy of another object.

Example:

#include <iostream>
using namespace std;

class Student {
private:
    string name;
    int age;

public:
    // Default Constructor
    Student() {
        name = "Unknown";
        age = 0;
    }

    // Parameterized Constructor
    Student(string n, int a) {
        name = n;
        age = a;
    }

    // Copy Constructor
    Student(const Student &s) {
        name = s.name;
        age = s.age;
    }

    void display() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

// Main function
int main() {
    Student s1;           // Default constructor
    Student s2("Alice", 21);  // Parameterized constructor
    Student s3 = s2;      // Copy constructor

    s1.display();
    s2.display();
    s3.display();
    return 0;
}

Output:

Name: Unknown, Age: 0
Name: Alice, Age: 21
Name: Alice, Age: 21

What is a Destructor?

A destructor is a special member function that is automatically called when an object is destroyed. It is used to clean up resources.

Characteristics:

• Has the same name as the class, preceded by a tilde (~).
• No parameters and no return type.
• Only one destructor can exist per class.

Example:

#include <iostream>
using namespace std;

class Demo {
public:
    Demo() {
        cout << "Constructor called." << endl;
    }

    ~Demo() {
        cout << "Destructor called." << endl;
    }
};

int main() {
    Demo obj;
    return 0;
}

Output:

Constructor called.
Destructor called.

Inheritance

Inheritance is a feature of OOP that allows you to create a new class (derived class) from an existing class (base class), inheriting its properties and methods.

Types of Inheritance:

1. Single Inheritance: One base class, one derived class.
2. Multiple Inheritance: Multiple base classes, one derived class.
3. Multilevel Inheritance: Derived class is inherited by another class.
4. Hierarchical Inheritance: One base class, multiple derived classes.
5. Hybrid Inheritance: Combination of multiple and multilevel inheritance.

Example :

#include <iostream>
using namespace std;

// ================== Single Inheritance ==================
class SingleBase {
public:
    void showSingle() {
        cout << "Single Inheritance: Base Class Method." << endl;
    }
};

// Derived class (Single Inheritance)
class SingleDerived : public SingleBase {
public:
    void showDerived() {
        cout << "Single Inheritance: Derived Class Method." << endl;
    }
};

// ================== Multiple Inheritance ==================
class MultipleBase1 {
public:
    void showBase1() {
        cout << "Multiple Inheritance: Base1 Method." << endl;
    }
};

class MultipleBase2 {
public:
    void showBase2() {
        cout << "Multiple Inheritance: Base2 Method." << endl;
    }
};

// Derived class (Multiple Inheritance)
class MultipleDerived : public MultipleBase1, public MultipleBase2 {
public:
    void showMultipleDerived() {
        cout << "Multiple Inheritance: Derived Method." << endl;
    }
};

// ================== Multilevel Inheritance ==================
class MultilevelBase {
public:
    void showMultilevelBase() {
        cout << "Multilevel Inheritance: Base Class Method." << endl;
    }
};

// Derived from MultilevelBase
class Intermediate : public MultilevelBase {
public:
    void showIntermediate() {
        cout << "Multilevel Inheritance: Intermediate Class Method." << endl;
    }
};

// Further Derived from Intermediate
class MultilevelDerived : public Intermediate {
public:
    void showMultilevelDerived() {
        cout << "Multilevel Inheritance: Derived Class Method." << endl;
    }
};

// ================== Hierarchical Inheritance ==================
class HierarchicalBase {
public:
    void showHierarchicalBase() {
        cout << "Hierarchical Inheritance: Base Class Method." << endl;
    }
};

// First Derived Class from Base (Hierarchical)
class HierarchicalDerived1 : public HierarchicalBase {
public:
    void showDerived1() {
        cout << "Hierarchical Inheritance: Derived1 Class Method." << endl;
    }
};

// Second Derived Class from Base (Hierarchical)
class HierarchicalDerived2 : public HierarchicalBase {
public:
    void showDerived2() {
        cout << "Hierarchical Inheritance: Derived2 Class Method." << endl;
    }
};

// ================== Hybrid Inheritance ==================
class HybridBase1 {
public:
    void showHybridBase1() {
        cout << "Hybrid Inheritance: Base1 Method." << endl;
    }
};

class HybridBase2 {
public:
    void showHybridBase2() {
        cout << "Hybrid Inheritance: Base2 Method." << endl;
    }
};

// Hybrid Inheritance using Multiple and Hierarchical
class HybridDerived1 : public HybridBase1 {
public:
    void showHybridDerived1() {
        cout << "Hybrid Inheritance: Derived1 Method." << endl;
    }
};

// Derived from HybridBase2 and HybridDerived1
class HybridDerived2 : public HybridBase2, public HybridDerived1 {
public:
    void showHybridDerived2() {
        cout << "Hybrid Inheritance: Final Derived Method." << endl;
    }
};

// ================== Main Function ==================
int main() {
    // Single Inheritance
    cout << "=== Single Inheritance ===" << endl;
    SingleDerived single;
    single.showSingle();
    single.showDerived();
    
    // Multiple Inheritance
    cout << "\n=== Multiple Inheritance ===" << endl;
    MultipleDerived multiple;
    multiple.showBase1();
    multiple.showBase2();
    multiple.showMultipleDerived();
    
    // Multilevel Inheritance
    cout << "\n=== Multilevel Inheritance ===" << endl;
    MultilevelDerived multilevel;
    multilevel.showMultilevelBase();
    multilevel.showIntermediate();
    multilevel.showMultilevelDerived();
    
    // Hierarchical Inheritance
    cout << "\n=== Hierarchical Inheritance ===" << endl;
    HierarchicalDerived1 hier1;
    HierarchicalDerived2 hier2;
    hier1.showHierarchicalBase();
    hier1.showDerived1();
    hier2.showHierarchicalBase();
    hier2.showDerived2();
    
    // Hybrid Inheritance
    cout << "\n=== Hybrid Inheritance ===" << endl;
    HybridDerived2 hybrid;
    hybrid.showHybridBase1();
    hybrid.showHybridBase2();
    hybrid.showHybridDerived1();
    hybrid.showHybridDerived2();
    
    return 0;
}

Output:

=== Single Inheritance ===
Single Inheritance: Base Class Method.
Single Inheritance: Derived Class Method.

=== Multiple Inheritance ===
Multiple Inheritance: Base1 Method.
Multiple Inheritance: Base2 Method.
Multiple Inheritance: Derived Method.

=== Multilevel Inheritance ===
Multilevel Inheritance: Base Class Method.
Multilevel Inheritance: Intermediate Class Method.
Multilevel Inheritance: Derived Class Method.

=== Hierarchical Inheritance ===
Hierarchical Inheritance: Base Class Method.
Hierarchical Inheritance: Derived1 Class Method.
Hierarchical Inheritance: Base Class Method.
Hierarchical Inheritance: Derived2 Class Method.

=== Hybrid Inheritance ===
Hybrid Inheritance: Base1 Method.
Hybrid Inheritance: Base2 Method.
Hybrid Inheritance: Derived1 Method.
Hybrid Inheritance: Final Derived Method.

Explanation:

1. Single Inheritance: A single derived class (SingleDerived) inherits from a single base class (SingleBase).
2. Multiple Inheritance: The derived class (MultipleDerived) inherits from two base classes (MultipleBase1, MultipleBase2).
3. Multilevel Inheritance: A derived class (MultilevelDerived) is derived from another derived class (Intermediate), which itself is derived from a base class (MultilevelBase).
4. Hierarchical Inheritance: Multiple derived classes (HierarchicalDerived1, HierarchicalDerived2) inherit from a single base class (HierarchicalBase).
5. Hybrid Inheritance: Combines multiple inheritance and hierarchical inheritance.
   • HybridDerived1 inherits from HybridBase1.
   • HybridDerived2 inherits from both HybridBase2 and HybridDerived1.
     

Polymorphism

Polymorphism means "many forms". It allows you to perform a single action in different ways.

Types:

• Compile-time Polymorphism: Function overloading, operator overloading.
• Run-time Polymorphism: Function overriding (using virtual functions).

Example (Function Overloading):

#include <iostream>
using namespace std;

// Compile-time Polymorphism: Function Overloading
class Calculator {
public:
    // Overloaded add() function for integers
    int add(int a, int b) {
        return a + b;
    }

    // Overloaded add() function for doubles
    double add(double a, double b) {
        return a + b;
    }
};

// Run-time Polymorphism: Virtual Functions
class Animal {
public:
    // Virtual function for sound (will be overridden)
    virtual void sound() {
        cout << "Animal makes a sound." << endl;
    }
};

// Derived class: Dog
class Dog : public Animal {
public:
    void sound() override {
        cout << "Dog barks." << endl;
    }
};

// Derived class: Cat
class Cat : public Animal {
public:
    void sound() override {
        cout << "Cat meows." << endl;
    }
};

int main() {
    // Compile-time Polymorphism
    Calculator calc;
    cout << "Compile-time Polymorphism (Function Overloading):" << endl;
    cout << "Sum of 2 and 3: " << calc.add(2, 3) << endl;
    cout << "Sum of 2.5 and 3.5: " << calc.add(2.5, 3.5) << endl;
    cout << endl;

    // Run-time Polymorphism
    cout << "Run-time Polymorphism (Virtual Functions):" << endl;
    Animal *animalPtr;
    Dog dog;
    Cat cat;

    animalPtr = &dog;
    animalPtr->sound(); // Calls Dog's sound()

    animalPtr = &cat;
    animalPtr->sound(); // Calls Cat's sound()

    return 0;
}

Output:

Compile-time Polymorphism (Function Overloading):
Sum of 2 and 3: 5
Sum of 2.5 and 3.5: 6

Run-time Polymorphism (Virtual Functions):
Dog barks.
Cat meows.

Explanation:

✅ Compile-time Polymorphism (Function Overloading):

• The Calculator class has two add() functions with different parameter types:
  • One for integers.
  • One for double values.
• The correct version is chosen during compile-time.

✅ Run-time Polymorphism (Virtual Functions):

• The Animal class has a virtual function sound().
• The Dog and Cat classes inherit from Animal and override the sound() method.
• A pointer of type Animal* can point to both Dog and Cat.

At run-time, the correct version of sound() is called based on the object type (Dog or Cat).

Abstraction

Abstraction hides complex implementation details and shows only essential information.

Example:

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() = 0; // Pure virtual function (abstract)
};

class Circle : public Shape {
public:
    void draw() {
        cout << "Drawing Circle" << endl;
    }
};

int main() {
    Circle c;
    c.draw();
    return 0;
}

Output:

Drawing Circle

Summary

In this tutorial, you learned:

• What OOP is and its core concepts (Encapsulation, Inheritance, Polymorphism, Abstraction).
• How to create and use classes and objects.
• The importance of constructors and destructors.
• How to implement inheritance, polymorphism, and abstraction in C++.