Why was pair range access removed from C++11?

by

I think the 2009 paper “Pairs do not make good ranges” by Alisdair Meredith is at least part of the answer. Basically, many algorithms return pairs of iterators that are actually not guaranteed to be valid ranges. It seems they removed the support for pair<iterator,iterator> from the for-range loop for this reason. However, the proposed solution has not been fully adopted.

If you know for certain that some pair of iterators really represents a valid range then you could wrap them into a custom type which offers begin()/end() member functions:

template<class Iter>
struct iter_pair_range : std::pair<Iter,Iter> {
    iter_pair_range(std::pair<Iter,Iter> const& x)
    : std::pair<Iter,Iter>(x)
    {}
    Iter begin() const {return this->first;}
    Iter end()   const {return this->second;}
};

template<class Iter>
inline iter_pair_range<Iter> as_range(std::pair<Iter,Iter> const& x)
{ return iter_pair_range<Iter>(x); }

int main() {
    multimap<int,int> mm;
    ...
    for (auto& p : as_range(mm.equal_range(42))) {
       ...
    }
}

(untested)

I agree this is a bit of a wart. Functions which return valid ranges (like equal_range) should say so using an appropriate return type. It’s a bit embarrasing that we have to manually confirm this via something like as_range above.

More Related Contents:

  1. Generate random numbers using C++11 random library
  2. What is the correct way of using C++11’s range-based for?
  3. Range-for-loops and std::vector
  4. How does the range-based for work for plain arrays?
  5. Does a C++11 range-based for loop condition get evaluated every cycle?
  6. Range-based for loop on a dynamic array?
  7. Is the ranged based for loop beneficial to performance?
  8. Is there a range class in C++11 for use with range based for loops?
  9. What exactly is nullptr?
  10. Why don’t compilers merge redundant std::atomic writes?
  11. Copy constructor for a class with unique_ptr
  12. How to initialize std::array elegantly if T is not default constructible?
  13. lifetime of a std::initializer_list return value
  14. Brace-enclosed initializer list constructor
  15. Where can I use alignas() in C++11?
  16. Is it possible to determine if a type is a scoped enumeration type?
  17. Is there actually a reason why overloaded && and || don’t short circuit?
  18. Which cannot be implemented without compiler hooks?
  19. Should I delete the move constructor and the move assignment of a smart pointer?
  20. What is the value category of the operands of C++ operators when unspecified?
  21. Concat two `const char` string literals
  22. Waiting for multiple futures?
  23. How do memory_order_seq_cst and memory_order_acq_rel differ?
  24. converting a variable name to a string in C++
  25. When to make a type non-movable in C++11?
  26. Why was std::pow(double, int) removed from C++11?
  27. What is the class keyword before a function argument?
  28. Why can’t I replace std::map with std::unordered_map
  29. When must you pass io_context to boost::asio::spawn? (C++)
  30. C++11 random numbers

Leave a Comment