C++ Object-Oriented Programming: Complete Guide

Introduction to Object-Oriented Programming

Object-Oriented Programming (OOP) is a programming paradigm that organizes software design around data, or objects, rather than functions and logic. C++ is a multi-paradigm language that fully supports OOP.

C++ OOP Concepts Overview

The following table explains the fundamental concepts of Object-Oriented Programming in C++:

1. Classes and Objects: The Foundation

A class is a user-defined data type that holds both data (attributes) and functions (methods). An object is an instance of a class.

class ClassName {
private:
    // Private members (accessible only within class)
    dataType privateVariable;
    
protected:
    // Protected members (accessible within class and derived classes)
    dataType protectedVariable;
    
public:
    // Public members (accessible from anywhere)
    dataType publicVariable;
    
    // Constructor
    ClassName(parameters) {
        // Initialization code
    }
    
    // Member functions (methods)
    returnType methodName(parameters) {
        // Method implementation
    }
    
    // Destructor
    ~ClassName() {
        // Cleanup code
    }
};

Class and Object Examples

class Account {
  int id; double bal;
public:
  void deposit(double a);
};

Account acc;
acc.deposit(100);

cout << acc.getBalance();

void setId(int id){ this->id=id; }

static int count;
Account::count++;

void Account::deposit(double a){ bal+=a; }

2. Constructors and Destructors

Constructors initialize objects when they are created. Destructors clean up when objects are destroyed. C++ provides several types of constructors.

Constructor Examples

Student() { name=""; }

Student(string n): name(n) {}

Student(const Student& o): name(o.name) {}

Point(int x,int y): x(x),y(y) {}

~Student() { cout<<"bye"; }

Student(const Student&)=delete;

3. Encapsulation: Data Hiding and Protection

Encapsulation is the bundling of data and methods that operate on that data within a single unit (class), and restricting direct access to some of the object's components.

class Example {
private:    // Accessible ONLY within this class
    int secretData;
    
protected:  // Accessible within this class AND derived classes
    int familyData;
    
public:     // Accessible from ANYWHERE
    int publicData;
    
    // Getter method (accessor)
    int getSecretData() const {
        return secretData;
    }
    
    // Setter method (mutator) with validation
    void setSecretData(int value) {
        if (value >= 0) {
            secretData = value;
        }
    }
};

Encapsulation Examples

private:
  string name;
  int marks;

string getName() const { return name; }

void setMarks(int m){ if(m>=0) marks=m; }

friend ostream& operator<<(ostream& os, const Student& s);

int getMarks() const { return marks; }

// users call deposit(), not bal+=

4. Inheritance: Code Reusability and Hierarchy

Inheritance allows a new class (derived class) to inherit properties and behaviors from an existing class (base class). This promotes code reusability and establishes relationships between classes.

// BASE CLASS (Parent)
class BaseClass {
protected:
    int protectedData;
public:
    void baseMethod() { }
};

// DERIVED CLASS (Child) - Single Inheritance
class DerivedClass : public BaseClass {
public:
    void derivedMethod() {
        protectedData = 10; // Can access protected members
        baseMethod();       // Can access public methods
    }
};

// MULTIPLE INHERITANCE
class MultiDerived : public Base1, public Base2 {
    // Inherits from both Base1 and Base2
};

Inheritance Examples

class Vehicle { protected: int speed; };

class Car : public Vehicle { };

void start() override { speed=10; }

Car(): Vehicle() {}

Vehicle* v = new Car();

virtual ~Vehicle()=default;

5. Polymorphism: One Interface, Multiple Forms

Polymorphism allows objects of different classes to be treated as objects of a common base class. It enables one interface to be used for a general class of actions.

// BASE CLASS with virtual function
class Base {
public:
    virtual void show() {        // Virtual function
        cout << "Base show()" << endl;
    }
    
    virtual void display() = 0;  // Pure virtual function (abstract)
    
    virtual ~Base() {}           // Virtual destructor
};

// DERIVED CLASS overriding virtual function
class Derived : public Base {
public:
    void show() override {       // Override keyword (C++11)
        cout << "Derived show()" << endl;
    }
    
    void display() override {
        cout << "Derived display()" << endl;
    }
};

Polymorphism Examples

virtual double pay() const = 0;

double pay() const override { return base+bonus; }

Employee* e = new Manager();
cout<<e->pay();

// runtime picks Manager::pay

class Shape { virtual double area()=0; };

Manager* m = dynamic_cast<Manager*>(e);

6. Abstraction: Hiding Complexity

Abstraction is the process of hiding complex implementation details and showing only essential features to the user. In C++, abstraction is achieved through abstract classes and interfaces.

// ABSTRACT CLASS (contains pure virtual function)
class AbstractClass {
public:
    // Pure virtual function - makes class abstract
    virtual void essentialOperation() = 0;
    
    // Virtual destructor
    virtual ~AbstractClass() {}
    
    // Can have implemented methods too
    void commonOperation() {
        cout << "Common implementation" << endl;
    }
};

// CONCRETE CLASS implementing abstraction
class ConcreteClass : public AbstractClass {
public:
    void essentialOperation() override {
        cout << "Concrete implementation" << endl;
    }
};

Abstraction Examples

class Device { public: virtual void on()=0; };

void use(Device& d){ d.on(); }

class Printer : public Device { /* ... */ };

printer.print(doc); // not driver bytes

// header declares, cpp defines

App depends on Device*, not Printer

7. OOP Best Practices and Design Principles

OOP Design Examples

class Invoice { void total(); };

class App { void ui(); void db(); };

class Car { Engine engine; };

class X: public Y: public Z {}

class Logger { virtual void log(string)=0; };

int getX() const { return x; }