What is abstraction in C++?

Abstraction in C++ is one of the key principles of Object-Oriented Programming (OOP). It refers to the concept of hiding the internal implementation details of a class and exposing only the essential features or functionalities to the outside world. Abstraction helps to reduce complexity by focusing on what an object does rather than how it does it.

Key Concepts of Abstraction:

1. Hiding Implementation Details: Abstraction allows the user to interact with the object without knowing the details of how its methods are implemented.
2. Exposing Relevant Information: The class exposes necessary details through public methods while hiding the complexity in private or protected members.

Achieving Abstraction in C++:

1. Using Classes

Abstraction is commonly achieved through the use of classes. By declaring member variables as private or protected, and defining public methods to manipulate them, the internal workings are hidden from the user.

Example:

class Car {
private:
    int speed;  // Hidden from outside
public:
    void setSpeed(int s) {  // Public method for setting speed
        speed = s;
    }
    int getSpeed() {  // Public method for accessing speed
        return speed;
    }
};

In this example, the speed variable is hidden (abstracted), and the user interacts with the object only through the public setSpeed() and getSpeed() methods.

2. Abstract Classes

In C++, you can define abstract classes using pure virtual functions. An abstract class cannot be instantiated on its own, and it serves as a blueprint for other classes.

Example:

class Shape {
public:
    virtual void draw() = 0;  // Pure virtual function
};
class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing Circle" << endl;
    }
};

Here, Shape is an abstract class, and Circle implements the abstract function draw(). Abstract classes force derived classes to provide implementations for the abstract methods, achieving abstraction.

Benefits of Abstraction:

• Modularity: By dividing the program into classes with distinct functionality, the program becomes more modular and easier to manage.
• Security: Abstraction helps protect the integrity of data by preventing unintended access to sensitive information.
• Ease of Maintenance: Since the implementation details are hidden, changes can be made to the internal logic without affecting other parts of the code.

Conclusion:

Abstraction in C++ is about simplifying complex systems by exposing only what is necessary and hiding the internal workings. This leads to cleaner, more maintainable code, making it easier to develop and scale software.

Sources:

• GeeksforGeeks: Abstraction in C++
• Programiz: C++ Abstraction