codelessgenie blog

Deque::begin() and deque::end() in C++ STL: A Comprehensive Guide

In C++, the Standard Template Library (STL) provides a rich set of containers to manage collections of data. Among these, std::deque (double-ended queue) stands out for its efficient insertion and deletion operations at both the front and the back. To traverse and manipulate elements in a deque, iterators play a critical role. Two fundamental iterators provided by std::deque are begin() and end(), which mark the start and end of the container’s element sequence.

This blog dives deep into deque::begin() and deque::end(), explaining their behavior, use cases, best practices, and potential pitfalls. Whether you’re a beginner learning STL or an experienced developer refining your skills, this guide will help you master these essential iterators.

2026-07

Table of Contents#

  1. What is std::deque?
  2. Understanding Iterators in C++ STL
  3. deque::begin() – Detailed Explanation
  4. deque::end() – Detailed Explanation
  5. Example Usage
  6. Common Practices
  7. Best Practices
  8. Edge Cases and Pitfalls
  9. Conclusion
  10. References

What is std::deque?#

std::deque (pronounced "deck") is a sequence container in C++ STL designed to support fast insertion and deletion at both the front (push_front(), pop_front()) and the back (push_back(), pop_back()) of the container. Unlike std::vector, which uses a single contiguous memory block, deque typically uses multiple memory blocks (called "chunks") to store elements, allowing efficient expansion in both directions.

Key features of std::deque:

  • Random access iterator support (enables O(1) time access to elements via indices).
  • O(1) time complexity for insertion/deletion at both ends.
  • Dynamic size (automatically resizes as elements are added/removed).

Understanding Iterators in C++ STL#

Iterators are objects that act as "pointers" to elements in a container, enabling traversal, access, and modification of elements. They bridge the gap between containers and algorithms, allowing STL algorithms (e.g., std::for_each, std::find) to work generically across different container types.

Iterator Categories#

STL iterators are categorized based on their capabilities:

  • Input Iterators: Read-only, single-pass traversal (e.g., std::istream_iterator).
  • Output Iterators: Write-only, single-pass traversal (e.g., std::ostream_iterator).
  • Forward Iterators: Read/write, multi-pass traversal (e.g., std::forward_list iterators).
  • Bidirectional Iterators: Forward + backward traversal (e.g., std::list iterators).
  • Random Access Iterators: Bidirectional + O(1) time arithmetic (e.g., std::vector, std::deque iterators).

std::deque iterators are random access iterators, meaning they support operations like +, -, +=, -=, and subscripting ([]).

deque::begin() – Detailed Explanation#

The begin() method returns an iterator pointing to the first element of the deque. It is used to mark the starting point of a traversal.

Function Signatures#

std::deque provides two overloads of begin() to support both mutable and read-only access:

  1. Non-const version:

    iterator begin() noexcept;

    Returns a mutable iterator (iterator) pointing to the first element. Modifying the element via this iterator is allowed.

  2. Const version:

    const_iterator begin() const noexcept;

    Returns a read-only iterator (const_iterator) pointing to the first element. Modifying the element via this iterator is not allowed.

Key Notes#

  • For a non-const deque, begin() returns a mutable iterator.
  • For a const deque, begin() automatically returns a const_iterator (enforcing read-only access).
  • C++11 introduced cbegin(), a dedicated method to return a const_iterator even for non-const deques: 
    const_iterator cbegin() const noexcept; // Always returns const_iterator

deque::end() – Detailed Explanation#

The end() method returns an iterator pointing past the last element of the deque. It acts as a sentinel to mark the end of the sequence and is not a valid element itself.

Function Signatures#

Like begin(), end() has two overloads:

  1. Non-const version:

    iterator end() noexcept;

    Returns a mutable iterator pointing past the last element.

  2. Const version:

    const_iterator end() const noexcept;

    Returns a read-only iterator pointing past the last element.

Key Notes#

  • end() does not point to a valid element. Dereferencing end() results in undefined behavior (e.g., crashes, garbage values).
  • The range [begin(), end()) is half-open: it includes begin() but excludes end(). This ensures all elements are covered in a loop from begin() to end().
  • C++11 introduced cend() for explicit read-only access: 
    const_iterator cend() const noexcept; // Always returns const_iterator

Example Usage#

Let’s explore practical examples of begin() and end() in action.

Example 1: Basic Traversal with begin() and end()#

#include <iostream>
#include <deque>
 
int main() {
    std::deque<int> dq = {10, 20, 30, 40, 50};
 
    // Traverse using non-const iterators (mutable access)
    std::cout << "Deque elements (mutable traversal): ";
    for (auto it = dq.begin(); it != dq.end(); ++it) {
        std::cout << *it << " "; // Dereference iterator to access element
    }
    std::cout << "\n";
 
    // Modify elements using non-const iterators
    for (auto it = dq.begin(); it != dq.end(); ++it) {
        *it *= 2; // Double each element
    }
 
    // Traverse using const iterators (read-only access)
    std::cout << "Modified elements (const traversal): ";
    for (auto it = dq.cbegin(); it != dq.cend(); ++it) {
        std::cout << *it << " "; // Cannot modify *it here
    }
    std::cout << "\n";
 
    return 0;
}

Output:

Deque elements (mutable traversal): 10 20 30 40 50 
Modified elements (const traversal): 20 40 60 80 100

Example 2: Range-Based For Loop (Implicit begin()/end())#

Modern C++ (C++11+) supports range-based for loops, which internally use begin() and end() to iterate over the container:

std::deque<std::string> fruits = {"apple", "banana", "cherry"};
 
// Range-based for loop (uses begin() and end() under the hood)
std::cout << "Fruits: ";
for (const auto& fruit : fruits) { // 'const auto&' for read-only access
    std::cout << fruit << " ";
}

Output:

Fruits: apple banana cherry

Example 3: Using begin()/end() with STL Algorithms#

STL algorithms like std::for_each or std::find rely on begin() and end() to define the range of elements to process:

#include <algorithm> // For std::for_each
 
// Print an element (lambda function)
auto print = [](int x) { std::cout << x << " "; };
 
std::deque<int> nums = {3, 1, 4, 1, 5};
std::cout << "Elements: ";
std::for_each(nums.begin(), nums.end(), print); // Uses begin() and end()

Output:

Elements: 3 1 4 1 5

Common Practices#

  • Traversal: Use begin() and end() to loop through elements (e.g., for (auto it = dq.begin(); it != dq.end(); ++it)).
  • Algorithm Integration: Pass begin() and end() to STL algorithms (e.g., std::sort(dq.begin(), dq.end())).
  • Range-Based Loops: Prefer range-based for loops (for (auto& elem : dq)) for readability, as they implicitly use begin() and end().

Best Practices#

  1. Prefer cbegin()/cend() for Read-Only Access
    Use cbegin() and cend() when you don’t need to modify elements. This enforces const-correctness and prevents accidental modifications:

    const std::deque<int> dq = {1, 2, 3};
for (auto it = dq.cbegin(); it != dq.cend(); ++it) {
    // *it = 4; // Compile error (read-only)
}

  2. Check for Empty Deque Before Dereferencing begin()
    Dereferencing begin() on an empty deque is undefined behavior. Always verify the deque is non-empty first:

    std::deque<int> dq;
if (!dq.empty()) {
    std::cout << "First element: " << *dq.begin();
} else {
    std::cout << "Deque is empty.";
}

  3. Avoid Invalidation of Iterators
    std::deque iterators can be invalidated when elements are added or removed:

    • Insertions at front/back: Invalidate all iterators (including past-the-end) according to the C++ standard; do not rely on iterator stability after any insertion.
    • Insertions in the middle: Always invalidates all iterators.
    • Deletions: May invalidate iterators (e.g., deleting an element invalidates iterators pointing to it).

    Rule of thumb: After modifying the deque (e.g., push_back(), erase()), re-fetch iterators with begin()/end() if needed.

Edge Cases and Pitfalls#

  • Dereferencing end(): Never dereference end()—it points past the last element. Example of undefined behavior:

    std::deque<int> dq = {1, 2, 3};
auto it = dq.end();
// std::cout << *it; // Undefined behavior!

  • Empty Deque: For an empty deque, begin() == end(). This is safe for loops (the loop body won’t execute):

    std::deque<int> dq;
for (auto it = dq.begin(); it != dq.end(); ++it) {
    // Loop body never runs (begin() == end())
}

  • Mixing Const and Non-Const Iterators: Comparing iterator with const_iterator is legal (since iterator can implicitly convert to const_iterator), but use with caution. For clarity and type consistency, consider using explicit casts:

    std::deque<int> dq = {1, 2, 3};
auto it = dq.begin();       // iterator
auto c_it = dq.cbegin();    // const_iterator
// if (it == c_it) { ... }  // Legal, but may cause confusion

Conclusion#

deque::begin() and deque::end() are foundational to working with std::deque in C++. They define the range of elements, enabling traversal, modification, and integration with STL algorithms. By understanding their behavior—including const-correctness, iterator invalidation, and edge cases—you can write efficient, safe, and maintainable code.

Remember: Use begin()/end() for mutable access, cbegin()/cend() for read-only access, and always validate the deque is non-empty before dereferencing begin().

References#