Introduction

Abstraction is one of the four pillars of OOP (alongside Encapsulation, Inheritance, Polymorphism).
It means hiding complex implementation details and exposing only what’s necessary.
The user of a class/function only needs to know what it does, not how it does it.
In C++, abstraction is achieved via abstract classes, interfaces (all-pure-virtual classes), and access modifiers.

Real-World Analogy

A car — you use the steering wheel, pedals, and gear shift. You don’t need to know how the engine combustion works internally.
A TV remote — press a button, channel changes. The IR signal encoding is hidden.

Architectural View

flowchart LR
    User["👤 Client Code"] -- "Uses Interface\n(Public Methods)" --> Interface["🟢 Abstraction Layer"]
    Interface -- "Hides Complexity" --> Impl["⚙️ Internal Implementation\n(Private Data & Complex Logic)"]
    style Interface fill:#22c55e,color:#fff
    style Impl fill:#ef4444,color:#fff

Advantages

Reduces complexity — users interact with a simple interface.
Improves maintainability — internal changes don’t affect users.
Enables code reuse and polymorphism.
Enforces separation of concerns.

Disadvantages

Over-abstraction can make code harder to trace and debug.
Adds indirection — slight performance overhead (vtable).
Requires careful design upfront.

Types of Abstraction

Data Abstraction

Hiding internal data representation — expose only through controlled methods.
Achieved via private/protected members + public getters/setters.

class BankAccount {
private:
    double balance;  // hidden — user can't access directly
 
public:
    BankAccount(double initial) : balance(initial) {}
 
    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
 
    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) balance -= amount;
    }
 
    double getBalance() const { return balance; }
};
 
BankAccount acc(1000.0);
acc.deposit(500);
acc.withdraw(200);
std::cout << acc.getBalance(); // 1300
// acc.balance = 99999; // ERROR — private

Procedural Abstraction

Hiding the steps of an algorithm behind a function name.
Caller only knows the function signature, not the internal logic.

// User calls sort() — doesn't need to know it's introsort internally
#include <algorithm>
#include <vector>
 
std::vector<int> v = {5, 2, 8, 1, 9};
std::sort(v.begin(), v.end());
// [1, 2, 5, 8, 9] — how it sorted is abstracted away

Abstract Class Abstraction

Define a common interface via pure virtual functions.
Each subclass provides its own implementation.

class Logger {
public:
    virtual void log(const std::string& msg) = 0;
    virtual ~Logger() {}
};
 
class ConsoleLogger : public Logger {
public:
    void log(const std::string& msg) override {
        std::cout << "[Console] " << msg << "\n";
    }
};
 
class FileLogger : public Logger {
public:
    void log(const std::string& msg) override {
        // write to file — implementation hidden
        std::cout << "[File] " << msg << "\n";
    }
};
 
// User only knows about Logger interface
void process(Logger& logger) {
    logger.log("Processing started");
    logger.log("Processing done");
}
 
ConsoleLogger cl;
process(cl);
// [Console] Processing started
// [Console] Processing done

Implementation

Shape Abstraction

#include <iostream>
#include <cmath>
 
class Shape {
public:
    virtual double area() = 0;
    virtual double perimeter() = 0;
    virtual void describe() {
        std::cout << "Area: " << area()
                  << ", Perimeter: " << perimeter() << "\n";
    }
    virtual ~Shape() {}
};
 
class Circle : public Shape {
    double r;
public:
    Circle(double r) : r(r) {}
    double area() override { return M_PI * r * r; }
    double perimeter() override { return 2 * M_PI * r; }
};
 
class Square : public Shape {
    double side;
public:
    Square(double s) : side(s) {}
    double area() override { return side * side; }
    double perimeter() override { return 4 * side; }
};
 
int main() {
    Shape* c = new Circle(5);
    Shape* s = new Square(4);
 
    c->describe(); // Area: 78.539..., Perimeter: 31.415...
    s->describe(); // Area: 16, Perimeter: 16
 
    delete c; delete s;
}

Payment System — Multi-Language

A PaymentProcessor abstract base with StripeProcessor and PayPalProcessor concrete implementations. Languages: Python · Cpp · Java · Java Script · CSharp

from abc import ABC, abstractmethod
 
class PaymentProcessor(ABC):
    @abstractmethod
    def process_payment(self, amount: float) -> bool: ...
 
    @abstractmethod
    def provider_name(self) -> str: ...
 
class StripeProcessor(PaymentProcessor):
    def process_payment(self, amount: float) -> bool:
        print(f"Stripe: charging ${amount}")
        return True
    def provider_name(self) -> str: return "Stripe"
 
class PayPalProcessor(PaymentProcessor):
    def process_payment(self, amount: float) -> bool:
        print(f"PayPal: charging ${amount}")
        return True
    def provider_name(self) -> str: return "PayPal"
 
def checkout(processor: PaymentProcessor, total: float):
    if processor.process_payment(total):
        print(f"Payment via {processor.provider_name()} successful")
 
checkout(StripeProcessor(), 99.99)
# Stripe: charging $99.99
# Payment via Stripe successful

class PaymentProcessor {
public:
    virtual bool processPayment(double amount) = 0;
    virtual std::string getProviderName() = 0;
    virtual ~PaymentProcessor() {}
};
 
class StripeProcessor : public PaymentProcessor {
public:
    bool processPayment(double amount) override {
        std::cout << "Stripe: charging $" << amount << "\n";
        return true;
    }
    std::string getProviderName() override { return "Stripe"; }
};
 
void checkout(PaymentProcessor& p, double total) {
    if (p.processPayment(total))
        std::cout << "Payment via " << p.getProviderName() << " successful\n";
}
 
StripeProcessor stripe;
checkout(stripe, 99.99);

interface PaymentProcessor {
    boolean processPayment(double amount);
    String getProviderName();
}
 
class StripeProcessor implements PaymentProcessor {
    public boolean processPayment(double amount) {
        System.out.printf("Stripe: charging $%.2f%n", amount);
        return true;
    }
    public String getProviderName() { return "Stripe"; }
}
 
static void checkout(PaymentProcessor p, double total) {
    if (p.processPayment(total))
        System.out.println("Payment via " + p.getProviderName() + " successful");
}
checkout(new StripeProcessor(), 99.99);

class PaymentProcessor {
    processPayment(amount) { throw new Error("Not implemented"); }
    get providerName() { throw new Error("Not implemented"); }
}
 
class StripeProcessor extends PaymentProcessor {
    processPayment(amount) { console.log(`Stripe: charging $${amount}`); return true; }
    get providerName() { return "Stripe"; }
}
 
function checkout(processor, total) {
    if (processor.processPayment(total))
        console.log(`Payment via ${processor.providerName} successful`);
}
checkout(new StripeProcessor(), 99.99);

interface IPaymentProcessor {
    bool ProcessPayment(double amount);
    string ProviderName { get; }
}
 
class StripeProcessor : IPaymentProcessor {
    public bool ProcessPayment(double amount) {
        Console.WriteLine($"Stripe: charging ${amount}");
        return true;
    }
    public string ProviderName => "Stripe";
}
 
static void Checkout(IPaymentProcessor p, double total) {
    if (p.ProcessPayment(total))
        Console.WriteLine($"Payment via {p.ProviderName} successful");
}
Checkout(new StripeProcessor(), 99.99);

When to Apply Abstraction

flowchart TD
    Q{"Is the system logic complex\nand liable to change?"}
    Q -- Yes --> R1["✅ Apply Abstraction\n(Hide implementation behind interface)"]
    Q -- No --> S1{"Is it a simple data holder\n(e.g., coordinates, DTO)?"}
    S1 -- Yes --> R2["❌ Minimal Abstraction\n(Use standard struct/class)"]
    S1 -- No --> R3["✅ Apply Abstraction\n(Keep internal state safe)"]

✅ Apply Abstraction When:

You are building a public API, library, or large system where implementation details might change without breaking client code.
The internal logic is complex (e.g., database connections, sorting algorithms, network protocols).
You want to support polymorphism and dependency injection.

❌ Avoid When:

Writing simple Data Transfer Objects (DTOs) or mathematical structs (e.g., Vector3 { x, y, z }) where getters/setters just add boilerplate without value.
Premature abstraction: Don’t abstract a simple script or one-off utility unless complexity demands it.

Concept	Relationship
Encapsulation	Abstraction hides complexity; Encapsulation hides data
Abstract Classes	Primary C++/Java tool for implementing abstraction
Interface	Pure abstraction — all methods are abstract
Polymorphism	Abstraction enables treating different types uniformly
Class	The container in which abstraction is applied

Abstraction vs Encapsulation

These two are related but distinct concepts.

Concept         What it does                          How in C++
Abstraction     Hides complexity, shows interface      Abstract classes, pure virtual
Encapsulation   Bundles data + methods, restricts      private/protected members
                direct access to internal state

Abstraction = design-level concept (what to expose).
Encapsulation = implementation-level concept (how to protect data).

Key Takeaways

Abstraction = show what, hide how.
Achieved in C++ via abstract classes (pure virtual), access modifiers, and well-designed APIs.
Reduces coupling — callers depend on interfaces, not implementations.
Combine with encapsulation for clean, maintainable OOP design.

Table of Contents

Explorer

Abstraction

Introduction

Real-World Analogy

Architectural View

Advantages

Disadvantages

Types of Abstraction

Data Abstraction

Procedural Abstraction

Abstract Class Abstraction

Implementation

Shape Abstraction

Payment System — Multi-Language

When to Apply Abstraction

✅ Apply Abstraction When:

❌ Avoid When:

Related Concepts

Abstraction vs Encapsulation

Key Takeaways

More Learn

GitHub & Webs

Enjoying the Notes?

Graph View

Backlinks

Recently Updated