Introduction to C++ | Data Abstraction

Data Abstraction in C++

Data Abstraction is one of the fundamental principles of Object-Oriented Programming (OOP). It allows the programmer to hide the complex implementation details and show only the essential features of the object. In C++, data abstraction is achieved using abstract classes and interfaces. The idea is to expose only the necessary information to the user, hiding the internal workings.

What is Data Abstraction?

Data abstraction means providing only essential information to the outside world and hiding the implementation details. In C++, this is typically done by creating classes with private or protected data members and providing public member functions to access or modify those data members. This provides a controlled way to interact with the object, ensuring that its internal data is not directly modified.

How Does Data Abstraction Work?

In C++, data abstraction is implemented using:

• Abstract Classes: These are classes that have at least one pure virtual function. Abstract classes provide the blueprint for derived classes, ensuring that certain methods are implemented.
• Encapsulation: This concept involves bundling the data (variables) and methods that operate on the data into a single unit or class. Access to the data is restricted through access modifiers (public, private, protected).

Syntax of Data Abstraction

        class AbstractClass {
        public:
            virtual void display() = 0;  // Pure virtual function
        };
                    

Example of Data Abstraction in C++

Here’s an example of using data abstraction in C++ to hide the internal details of a class and provide a controlled way to interact with it:

        #include <iostream>
        using namespace std;
        
        // Abstract class for Vehicle
        class Vehicle {
        public:
            virtual void startEngine() = 0;  // Pure virtual function
        
            void showDetails() {
                cout << "This is a vehicle" << endl;
            }
        };
        
        // Derived class Car
        class Car : public Vehicle {
        private:
            string carModel;
        
        public:
            Car(string model) : carModel(model) {}
        
            // Implementing the abstract method
            void startEngine() override {
                cout << "Starting engine of car model: " << carModel << endl;
            }
        };
        
        // Derived class Bike
        class Bike : public Vehicle {
        private:
            string bikeModel;
        
        public:
            Bike(string model) : bikeModel(model) {}
        
            // Implementing the abstract method
            void startEngine() override {
                cout << "Starting engine of bike model: " << bikeModel << endl;
            }
        };
        
        int main() {
            Vehicle* vehicle1 = new Car("Toyota Corolla");
            Vehicle* vehicle2 = new Bike("Yamaha R15");
        
            vehicle1->startEngine();
            vehicle2->startEngine();
        
            delete vehicle1;
            delete vehicle2;
        
            return 0;
        }
                    

Output

Key Points About Data Abstraction

• It hides the implementation details and only exposes essential features.
• Achieved through the use of abstract classes and encapsulation in C++.
• Abstract classes cannot be instantiated directly; they must be inherited by derived classes.
• Data abstraction improves code maintainability, as internal changes do not affect external code.

Advantages of Data Abstraction

• Simplified Interface: Users can interact with a simplified interface and don’t need to understand the internal workings.
• Reduced Complexity: Hides unnecessary details and reduces the complexity of the system.
• Improved Security: Protects the data from unauthorized access by restricting direct access to class members.
• Code Reusability: Allows the reusability of code without exposing the internal details.

Pro Tip: