The Standard Template Library (STL) in C++ is a powerful software library that’s a set of C++ template classes. It provides built-in algorithms, functions, iterators, and containers. This article focuses on the C++ STL container Deque.

STL containers are objects that can store multiple elements, manage any storage required for the elements, and offer member functions that we can use to access them. A container may allow elements of either the same type or different types to be stored in it. Depending on this, and on whether it is unordered, the containers are divided into three types:

• Sequence Containers: deque, arrays, vector, list, and forward_list
• Associative Containers: set, multiset, map, and multimap
• Unordered Associative Containers: unordered_set, unordered_multiset, unordered_map, and unordered_multimap

There are also Container Adapters, queue, priority_queue, and stack, which are a subset of containers. These container adapters offer a different interface for sequential containers. 

To help you harness the power of STL and be a more efficient developer, we’re doing a series on C++ STL container fundamentals. This article focuses on the C++ STL container, Deque (check out the learn page for more).

Having trained over 10,000 software engineers, we know what it takes to crack the toughest tech interviews. Our alums consistently land offers from FAANG+ companies. The highest ever offer received by an IK alum is a whopping $1.267 Million!

At IK, you get the unique opportunity to learn from expert instructors who are hiring managers and tech leads at Google, Facebook, Apple, and other top Silicon Valley tech companies.

Want to nail your next tech interview? Sign up for our FREE Webinar.

In this article, we’ll cover:

• Basic Difference Between Unordered Associative, Associative, and Sequence Containers In C++
• C++ STL Container Fundamentals: Deque (std::deque)
• Use of the C++ STL Container Deque
• Methods of std::deque
• How to Use C++ STL Container Deque
• FAQs on C++ STL Container Fundamentals: Deque

Basic Difference Between Unordered Associative, Associative, and Sequence Containers In C++

The three types of C++ STL containers implement different types of data structures, and that is the basis of their differentiation:

• Sequence containers provide data structures that can be sequentially accessed.
• Associative containers provide sorted/ordered data structures so that they can be efficiently searched and retrieved with O(logN) complexity. 
• Unordered associative containers provide unsorted and hashed data structures that can be efficiently searched and retrieved. 

C++ STL Container Fundamentals: Deque (std::deque)

Deque, pronounced as “deck,” is an implementation of the double-ended queues data structure and is a type of sequence container. It is like a special case of the data structure queue, where insertion and deletion can happen on both ends. It can be sequentially accessed, expanded, and contracted on both ends.

Deque is also like a more efficient vector for insertion and deletion at the beginning and end, where contiguous storage isn’t guaranteed. The functions offered for deque are the same as those provided for a vector (except push and pop). 

Use of the C++ STL Container Deque

C++ STL container std::deque is most commonly used for:

• Priority queuing 
• Scanning the queue
• Storing an application's list of undo operations
• Fast access to insert or delete at both ends of a line

Methods of std::deque

Here are the several methods associated with deque:

In the next section, we’ll look at some examples to understand how to use some of these methods (we’ve covered the most commonly used methods).

How to Use C++ STL Container Deque

Here, we take a look at how you can use Deque as a C++ STL container for a smoother coding experience:

Code Using std::deque

// Using the C++ STL container Deque 
#include 
#include 
 
using namespace std;
 
// Function to print Deque
void printDeque(deque q)
{
    deque::iterator iter;
    for (iter = q.begin(); iter != q.end(); ++iter)
        {
          cout <<" "<< *iter;
        }
    cout << "\n";
}
 
int main()
{
    // Creating a deque
    deque ascendingDequeExample;
 
    // Adding elements to deque
    ascendingDequeExample.push_back('c');
    ascendingDequeExample.push_back('d');
    ascendingDequeExample.push_front('b');
    ascendingDequeExample.push_front('a');
    ascendingDequeExample.push_back('e');
 
    cout << "The deque ascendingDequeExample currently is: ";
    printDeque(ascendingDequeExample);
 
    // Printing some properties of Deque using built-in functions provided 
    cout << "The size of ascendingDequeExample is: " << ascendingDequeExample.size() <<"\n";

    cout << "The max size of ascendingDequeExample is: " << ascendingDequeExample.max_size()<<"\n";
 
    cout << "The element at index 3 in ascendingDequeExample is: " << ascendingDequeExample.at(3)<<"\n";

    cout << "The element at the front of ascendingDequeExample is: " << ascendingDequeExample.front()<<"\n";

    cout << "The element at the back of ascendingDequeExample is: " << ascendingDequeExample.back()<<"\n";
 
    cout << "After deleting the frontmost element, ascendingDequeExample becomes: ";
    ascendingDequeExample.pop_front();
    printDeque(ascendingDequeExample);
 
    cout << "Then after deleting the last element, ascendingDequeExample becomes: ";
    ascendingDequeExample.pop_back();
    printDeque(ascendingDequeExample);
 
    return 0;
}

Output

The deque ascendingDequeExample currently is:  a b c d e
The size of ascendingDequeExample is: 5
The max size of ascendingDequeExample is: 18446744073709551615
The element at index 3 in ascendingDequeExample is: d
The element at the front of ascendingDequeExample is: a
The element at the back of ascendingDequeExample is: e
After deleting the frontmost element, ascendingDequeExample becomes:  b c d e
Then after deleting the last element, ascendingDequeExample becomes:  b c d

Want to learn more? Check out other posts on C++ STL container fundamentals on the learn page!

FAQs on C++ STL Container Fundamentals: Deque

Q1. What is std::deque in C++ STL, and what is its use?

Deque in C++ STL is a sequential container that implements a double-ended queue. We use it where insertion and deletion operations, specifically at the beginning and end, are frequently required. 

Q2. How is std::deque implemented in CPP STL?

Instead of being implemented as a linked list, the deque is implemented as an array of pointers to blocks of data in STL. Depending on the storage requirements, the number of these blocks and the size of the array of pointers dynamically change.

Q3. What is the difference between dequeue function and deque data structure in C++?

Dequeue is an operation that removes an item from a queue, while deque is a C++ STL sequential container that implements a double-ended queue. 

Q4. When is CPP deque not useful?

If frequent insertion or deletion of elements at positions other than the beginning and the end is required, deque performs worse and is less valuable.

Q5. What is the syntax for creating a deque container in STL?

The syntax for creating a deque container in STL is:

deque<dataType> dequeName;

Ready to Nail Your Next Coding Interview?

Whether you’re a coding engineer gunning for a software developer or software engineer role, a tech lead, or you’re targeting management positions at top companies, IK offers courses specifically designed for your needs to help you with your technical interview preparation!

If you’re looking for guidance and help with getting started, sign up for our FREE webinar. As pioneers in the field of technical interview preparation, we have trained thousands of software engineers to crack the toughest coding interviews and land jobs at their dream companies, such as Google, Facebook, Apple, Netflix, Amazon, and more!

Sign up now!

‍