Why are Standard iterator ranges [begin, end) instead of [begin, end]?

by

The best argument easily is the one made by Dijkstra himself:

  • You want the size of the range to be a simple difference end − begin;

  • including the lower bound is more “natural” when sequences degenerate to empty ones, and also because the alternative (excluding the lower bound) would require the existence of a “one-before-the-beginning” sentinel value.

You still need to justify why you start counting at zero rather than one, but that wasn’t part of your question.

The wisdom behind the [begin, end) convention pays off time and again when you have any sort of algorithm that deals with multiple nested or iterated calls to range-based constructions, which chain naturally. By contrast, using a doubly-closed range would incur off-by-ones and extremely unpleasant and noisy code. For example, consider a partition [n0, n1)[n1, n2)[n2,n3). Another example is the standard iteration loop for (it = begin; it != end; ++it), which runs end - begin times. The corresponding code would be much less readable if both ends were inclusive – and imagine how you’d handle empty ranges.

Finally, we can also make a nice argument why counting should start at zero: With the half-open convention for ranges that we just established, if you are given a range of N elements (say to enumerate the members of an array), then 0 is the natural “beginning” so that you can write the range as [0, N), without any awkward offsets or corrections.

In a nutshell: the fact that we don’t see the number 1 everywhere in range-based algorithms is a direct consequence of, and motivation for, the [begin, end) convention.

More Related Contents:

  1. Why use iterators instead of array indices?
  2. What happens if you call erase() on a map element while iterating from begin to end?
  3. Removing item from vector while iterating?
  4. comparing iterators from different containers
  5. Why use non-member begin and end functions in C++11?
  6. Is there a way to access the underlying container of STL container adaptors?
  7. Sorting a vector in descending order
  8. Is the order of iterating through std::map known (and guaranteed by the standard)?
  9. How are iterators and pointers related?
  10. What’s faster, iterating an STL vector with vector::iterator or with at()?
  11. What is an iterator’s default value?
  12. Custom Iterator in C++
  13. Why is “!=” used with iterators instead of “
  14. how portable is end iterator decrement?
  15. Can std::begin work with array parameters and if so, how?
  16. std::vector iterator invalidation
  17. Checking if an iterator is valid
  18. How does std::copy work with stream iterators
  19. Why does a push_back on an std::list change a reverse iterator initialized with rbegin?
  20. Can raw pointers be used instead of iterators with STL algorithms for containers with linear storage?
  21. What happens if you increment an iterator that is equal to the end iterator of an STL container
  22. Standard Library Containers with additional optional template parameters?
  23. Are const_iterators faster?
  24. How to check that the passed Iterator is a random access iterator?
  25. Do STL iterators guarantee validity after collection was changed?
  26. Incrementing iterators: Is ++it more efficient than it++? [duplicate]
  27. what is the difference between const_iterator and iterator? [duplicate]
  28. How to increment an iterator by 2?
  29. Types of iterator : Output vs. Input vs. Forward vs. Random Access Iterator
  30. iterator for 2d vector

Leave a Comment