Understanding Abstraction in C++ OOP

Understanding Abstraction in OOP

Hello, fellow coder! Today, we'll delve into the concept of Abstraction in C++, a cornerstone of Object-Oriented Programming . Abstraction is our ally against the complexities of software systems, allowing us to expose only the necessary details. Are you ready to navigate this fascinating concept? Think of Abstraction as a filtration system, extracting only what's essential for your needs while keeping unnecessary complexity at bay. It's not about dissecting each intricate detail; it’s about concentrating on what truly matters. Imagine driving a car; you interact with its controls without needing to understand the engine’s inner workings.

Abstraction in C++

In C++, objects are defined by classes, which act as blueprints for objects. Each class defines data (attributes) and potential behaviors (methods), like an intuitive interface in a vehicle, abstracting the underlying mechanics. This allows you to work with complex systems without needing to grasp all internal processes. C++ classes use access specifiers like public, protected, and private to hide data. By leveraging these, developers can isolate complex logic, employing a clean interface for users, thereby encapsulating and abstracting internal operations.

C++ Abstract Classes

In C++, abstract classes are defined by including pure virtual functions. A pure virtual function is declared by assigning 0 to a virtual function. Abstract classes can't be instantiated but can be subclassed, and they ensure derived classes implement particular functionalities. The virtual keyword is used to declare a function as virtual, which allows it to be overridden in any derived class. Conversely, the override keyword in a derived class is used to specify that a particular virtual function is meant to override a base class method. This aids in preventing errors during method overriding and enhances code readability by explicitly marking the overridden functions. Here's a simple example: C++ #include <iostream> using namespace std; class AbstractClass {public: // Pure virtual function (abstract method) virtual void doSomething() = 0;}; // Derived class must implement doSomething class DerivedClass : public AbstractClass {public: void doSomething() override {cout << "Doing something in DerivedClass." << endl;}}; int main() {DerivedClass derivedObj; derivedObj.doSomething(); // Outputs: Doing something in DerivedClass. AbstractClass abstractObj;// error: cannot declare variable 'abstractObj' to be of abstract type 'AbstractClass'} As illustrated, you can’t create instances of the abstract class AbstractClass, as it primarily serves as a blueprint for derived classes.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Real-world Example of Abstraction in C++

For instance, when creating an app for managing shapes, you'd define an abstract class Shape. It would contain pure virtual functions area and perimeter:

C++

#include <iostream>
#include <cmath>
using namespace std;

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

class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    
    double area() const override {
        return width * height;
    }

    double perimeter() const override {
        return 2 * (width + height);
    }
};

class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}

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

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

int main() {
    // Using pointers to the abstract class Shape
    Shape* rectangle = new Rectangle(2, 3);
    cout << "Rectangle area: " << rectangle->area() << endl;        // Outputs: 6
    cout << "Rectangle perimeter: " << rectangle->perimeter() << endl; // Outputs: 10

    Shape* circle = new Circle(5);
    cout << "Circle area: " << circle->area() << endl;             // Outputs: 78.5398
    cout << "Circle perimeter: " << circle->perimeter() << endl;   // Outputs: 31.4159

    delete rectangle; // Clean up the allocated memory
    delete circle;    // Clean up the allocated memory

    return 0;
}

#include <iostream>
#include <cmath>
using namespace std;

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

class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    
    double area() const override {
        return width * height;
    }

    double perimeter() const override {
        return 2 * (width + height);
    }
};

class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}

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

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

int main() {
    // Using pointers to the abstract class Shape
    Shape* rectangle = new Rectangle(2, 3);
    cout << "Rectangle area: " << rectangle->area() << endl;        // Outputs: 6
    cout << "Rectangle perimeter: " << rectangle->perimeter() << endl; // Outputs: 10

    Shape* circle = new Circle(5);
    cout << "Circle area: " << circle->area() << endl;             // Outputs: 78.5398
    cout << "Circle perimeter: " << circle->perimeter() << endl;   // Outputs: 31.4159

    delete rectangle; // Clean up the allocated memory
    delete circle;    // Clean up the allocated memory

    return 0;
}

In this example, the Shape class serves as an abstract base class for Rectangle and Circle, providing a unified interface with the pure virtual functions area and perimeter. Moreover, by using pointers to Shape (such as Shape* rectangle = new Rectangle(2, 3);), you can handle objects of these derived classes using the same interface, allowing for polymorphic behavior. This means you can invoke the derived class methods via the abstract class pointer without needing to know the specific type of shape in advance. This approach highlights how abstraction and inheritance work together to simplify complex systems and enhance flexibility in software design.

Understanding Abstraction in OOP

Abstraction in C++

C++ Abstract Classes

Join the 1M+ learners on CodeSignal

Real-world Example of Abstraction in C++

When to Use Abstraction

Lesson Summary and Practice