C++ Abstraction Tutorial

What is Abstraction?

Abstraction involves providing a clear separation between what an object does and how it does it. In C++, this is achieved through abstract classes and pure virtual functions.

#include <iostream>
using namespace std;

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

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

int main() {
    Shape* shape = new Circle();
    shape->draw();  // Outputs: Drawing Circle
    delete shape;
    return 0;
}
                

Abstract Classes

An abstract class is a class that contains at least one pure virtual function. You cannot instantiate an abstract class, but it can serve as a base class for derived classes that provide implementations for the pure virtual functions.

class Animal {
public:
    virtual void sound() = 0;  // Pure virtual function
};

class Dog : public Animal {
public:
    void sound() override {
        cout << "Bark!" << endl;
    }
};

int main() {
    Animal* animal = new Dog();
    animal->sound();  // Outputs: Bark!
    delete animal;
    return 0;
}
                

Pure Virtual Functions

A pure virtual function is a function that is declared in the base class, but has no definition. It forces the derived class to provide an implementation. This is key to achieving abstraction in C++.

class Vehicle {
public:
    virtual void start() = 0;  // Pure virtual function
};

class Car : public Vehicle {
public:
    void start() override {
        cout << "Car is starting" << endl;
    }
};

int main() {
    Vehicle* vehicle = new Car();
    vehicle->start();  // Outputs: Car is starting
    delete vehicle;
    return 0;
}
                

Benefits of Abstraction

• Hides complexity by only exposing the necessary parts of the code.
• Improves code reusability and maintainability.
• Provides a framework for extending functionality in the derived classes.