Range TS idioms and the mysterious auto &&

by

This idiom is being used because the Range TS and the C++20-equivalent actually requires this idiom. The reason for this requirement has to do with the fact that proxy iterators are now legal constructs for all categories of iterators.

A proxy iterator’s operator* does not return a value_type&; it returns a prvalue of an object that acts like an reference. Therefore, if you tried to store a reference to the value with auto&, your code would fail to compile with a proxy iterator.

The Range TS’s iterator concepts never require that the return value from operator* is actually a language reference. The Readable concept only requires that the return value is convertible to a value_type. The Writable concept only requires that a value_type can be assigned to the return value.

So code getting references from iterators of all kinds under the Range feature must now use auto&&, which can bind to prvalues without making them const. So when dealing with ranges, if you want to get a possibly non-const reference to the value, auto&& is the most convenient way. If you want just a const reference, you can continue to use const auto &.

Note that auto&& also handles iterators that directly return prvalues of type value_type from their operator*. Obviously these are only useful for Readable iterators, but they’re quite useful. The simplest example would be an iterator for a counting range over some number of integers. The iterator returns an int, not a reference to some memory. Such iterators can be RandomAccessIterators in the Range TS due to not having a hard requirement for returning a language reference.

Such iterators would also make sense for regular expression matching. The current regex_iterator returns a reference to an internal object; that’s necessary for being a ForwardIterator. Instead, it could have been much smaller by having operator* do the search and return the match object as a prvalue. But the old system wouldn’t allow that.

Given such an iterator, auto& cannot be used to capture “references” to their results.

More Related Contents:

  1. What is a “span” and when should I use one?
  2. What is the (“spaceship”, three-way comparison) operator in C++?
  3. What exactly are C++ modules?
  4. Why does same_as concept check type equality twice?
  5. How to use source_location in a variadic template function?
  6. Can class template constructors have a redundant template parameter list in c++20
  7. Designated initializers in C++20
  8. Why do we require requires requires?
  9. How to use c++20 modules with CMake?
  10. Why does aggregate initialization not work anymore since C++20 if a constructor is explicitly defaulted or deleted?
  11. What is `constinit` in C++20?
  12. Does constraint subsumption only apply to concepts?
  13. C++20 constexpr vector and string not working
  14. C++ Concept that requires a member function with an OutputIterator as parameter
  15. Ramifications of C++20 requiring two’s complement
  16. Familiar template syntax for generic lambdas
  17. Why is volatile deprecated in C++20?
  18. ‘auto’ as a template argument placeholder for a function parameter
  19. Comparing 3 modern c++ ways to convert integral values to strings
  20. In which access control context are concepts evaluated?
  21. Is C++20 ‘char8_t’ the same as our old ‘char’?
  22. What is the purpose of C++20 std::common_reference?
  23. Contiguous iterator detection
  24. Is lambdification of a concept an improvement or bad practice?
  25. Why is operator!= removed in C++20 for many standard library types?
  26. C++ check if statement can be evaluated constexpr
  27. Why must a std::ranges::filter_view object be non-const for querying its elements?
  28. Why don’t I need to specify “typename” before a dependent type in C++20?
  29. How to use C++20’s likely/unlikely attribute in if-else statement
  30. if constexpr – why is discarded statement fully checked?

Leave a Comment