Abstract data types in C++

Within the realm of programming, data takes center stage. The way data is stored, manipulated, and accessed can wield considerable influence over the efficiency and effectiveness of the programs. C++ offers a potent concept known as Abstract Data Types (ADTs) to facilitate these tasks. ADTs furnish a means to encapsulate both data and the operations executed on it, promoting an organized and modular design of code. This blog post embarks on a comprehensive exploration of ADTs, featuring elucidative examples replete with accompanying code and output to elucidate their practical utility.

The Essence of Abstract Data Types (ADTs)

In C++, an Abstract Data Type stands as a lofty abstraction that encompasses a data structure in conjunction with the operations that can be performed upon it. The term "abstract" alludes to the fact that our primary focus revolves around the functionality and behavior of the data structure, while the internal intricacies remain obscured. ADTs serve a dual purpose, granting us the following advantages:

Abstraction: ADTs allow us to abstract the inherent intricacies of data structures, which helps to make them more comprehensible and easier to employ.
Encapsulation: They encapsulate both data and operations, restricting direct access to the internal state and furnishing controlled avenues for interaction.

Let us delve into common instances of ADTs in C++.

Example 1: The Stack ADT

A stack, a linear data structure, follows the Last-In-First-Out (LIFO) principle. Here is an illustration of a stack ADT implementation in C++:

#include <iostream>
#include <stack>
 
int main() {
    std::stack<int> mystack;
 
    mystack.push(1);
    mystack.push(2);
    mystack.push(3);
 
    while (!mystack.empty()) {
        std::cout << mystack.top() << " ";
        mystack.pop();
    }
 
    return 0;
}

Output

3 2 1

Explanation:

In this example, we employ the std::stack container provided by C++ to realize a stack ADT. Elements are pushed onto the stack, subsequently popped and displayed. The internal underpinnings of the stack remain hidden from us.

Example 2: The Queue ADT

A queue, yet another linear data structure, adheres to the First-In-First-Out (FIFO) principle. We can utilize the std::queue container in C++ as follows:

#include <iostream> 
#include <queue>
 
int main() {
    std::queue<int> myqueue;
 
    myqueue.push(1);
    myqueue.push(2);
    myqueue.push(3);
 
    while (!myqueue.empty()) {
        std::cout << myqueue.front() << " ";
        myqueue.pop();
    }
 
    return 0;
}

Output

1 2 3

Explanation:

In this instance, we harness the std::queue container to craft a queue ADT. We include elements to the queue and subsequently dequeue and print them. Once again, the inner workings of the queue's implementation remain veiled.

Example 3: The List ADT

A list, a versatile linear data structure, facilitates efficient insertion and deletion operations at various positions. C++ provides the std::list container for this purpose:

#include <iostream>
#include <list>
 
int main() {
    std::list<int> mylist;
 
    mylist.push_back(1);
    mylist.push_back(2);
    mylist.push_back(3);
 
    for (const auto& item : mylist) {
        std::cout << item << " ";
    }
 
    return 0;
}

Output

1 2 3

Explanation:

In this example, we establish a list ADT using std::list, add elements to the end of the list, and subsequently traverse it. Yet again, we are relieved of the need to grapple with the internal machinations of the list.

Example 4: Abstraction of a Custom Data Type

Abstract Data Types are not confined to pre-existing C++ containers; they readily accommodate the creation of custom ADTs. Let's consider a rudimentary ADT for a 2D point:

#include <iostream>
 
class Point {
private:
    int x, y;
 
public:
    Point(int x, int y) : x(x), y(y) {}
 
    int getX() const { return x; }
    int getY() const { return y; }
};
 
int main() {
    Point p(3, 4);
    std::cout << "Point: (" << p.getX() << ", " << p.getY() << ")" << std::endl;
 
    return 0;
}

Output

Point: (3, 4)

Explanation:

Within this example, we define an ADT labeled Point, which represents a 2D point encompassing x and y coordinates. Users are equipped with access to the coordinates via member functions, thereby safeguarding the internal details of the point representation.

Conclusion:

In summary, Abstract Data Types (ADTs) serve as a fundamental foundation in C++ for structuring well-organized and encapsulated code. They empower developers to work with various data structures, including stacks, queues, and lists, by concealing intricate internal details. Whether utilizing existing containers or designing bespoke ADTs, a profound comprehension of these abstractions enhances the clarity and efficiency of code in C++ programming.

Next TopicBubble Sort in C++

← prev next →