Why are Standard Iterator Ranges [begin, end) Instead of [begin, end]?

In C++, the Standard Template Library (STL) uses a half-open range convention [begin, end) for iterator ranges. This means the range includes the begin iterator but excludes the end iterator. A common question arises: Why does the STL adopt this convention instead of the fully closed range [begin, end]?

In this article, we will learn the advantages of using half-open ranges [begin, end) over closed ranges [begin, end], and provide examples to demonstrate their effective use.

What are Iterator Ranges in C++?

Iterator ranges are pairs of iterators that define a sequence of elements within a container. The half-open range [begin, end) includes all elements starting from begin up to, but not including, end.

Reasons to Use Half-Open Ranges Instead of Closed Ranges in C++

There are several reasons for using half-open ranges [begin, end) in C++:

1. Simplified Range Calculations

Using a half-open range [begin, end) simplifies many common range calculations. For example, the length of a range can be easily computed as end - begin. This straightforward arithmetic is not possible with a closed range [begin, end], where the length would be end - begin + 1.

2. Consistency with Zero-Based Indexing

C++ uses zero-based indexing for arrays and other container types. The half-open range [begin, end) aligns well with this convention. It means that for an array of size n, valid indices range from 0 to n-1, and the end iterator points to n, one past the last valid element.

3. Ease of Iteration

Iterating over a half-open range [begin, end) naturally excludes the end iterator, preventing out-of-bounds access. This simplifies loop constructs and iterator comparisons.

for (auto it = begin; it != end; ++it) {
    // Process *it
}

In contrast, a closed range [begin, end] would require an additional comparison to avoid out-of-bounds errors:

for (auto it = begin; it != end + 1; ++it) {
    // Process *it
}

4. Algorithm Compatibility

Many STL algorithms, such as std::sort, std::find, and std::copy, are designed to work with half-open ranges. Adopting the [begin, end) convention ensures seamless integration and consistent behavior across the library.

5. Simplified Partitioning

When dividing a range into sub-ranges, half-open ranges simplify the process. The end of one sub-range can be directly used as the beginning of the next sub-range without overlap or gaps.

auto mid = begin + (end - begin) / 2;
sort(begin, mid);
sort(mid, end);

C++ Program to Demonstrate Half-Open Ranges

The below program demonstrates the advantages of using half-open ranges [begin, end) in C++.

// C++ Program to Demonstrate Half-Open Ranges

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

int main()
{
    // Initialize a vector with values
    vector<int> vec = { 1, 2, 3, 4, 5 };

    // Traverse using half-open range [begin, end)
    cout << "Elements in the vector: ";
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    // Using STL algorithm with a half-open range
    vector<int> vec_copy(vec.size());
    copy(vec.begin(), vec.end(), vec_copy.begin());

    cout << "Copied elements: ";
    for (const auto& elem : vec_copy) {
        cout << elem << " ";
    }
    cout << endl;

    return 0;
}

Elements in the vector: 1 2 3 4 5 
Copied elements: 1 2 3 4 5 

Alternatives to Standard Iterator Ranges and Their Limitations

Closed Ranges

A closed range [begin, end] would include both the begin and end iterators. However, this requires careful handling to avoid out-of-bounds errors and complicates many operations, such as calculating the range size and iterating through elements.

Open Ranges

An open range (begin, end) excludes both begin and end, which is rarely useful in practical programming scenarios. It complicates accessing elements and typically requires additional logic to manage range boundaries.