Wsrtjtyk

In C++, the constness of an object is forwarded through iterators. std::begin(a) will generally return A::iterator if a is not const, A::const_iterator if a is const.

I tried to extend this concept to move behaviour, in order to have better generic code. The basic idea is something like this:

struct A {

  using value_type = std::string;

  using iterator = AIter<A>;

  using const_iterator = AIter<A const>;

  using move_iterator = AIter<A &&>;



  iterator begin() &;

  iterator end() &;

  const_iterator begin() const &;

  const_iterator end() const &;

  move_iterator begin() &&;

  move_iterator end() &&;

};



template <typename A> struct AIter {

  using a_type = A;

  using value_type = typename std::decay_t<A>::value_type;

  using reference = std::conditional_t<

      std::is_rvalue_reference_v<A>, value_type &&,

      std::conditional_t<std::is_const_v<std::remove_reference_t<A>>,

                         value_type const &, value_type &>>;

};

It is a bit convoluted, especially the conditional type in the iterator. The concept is simply that the type of the iterator completely depends on the reference type of A.

Unfortunately, the problem arises when, instead of directly using member functions, I try to use std::begin and std::end (and all the similar ones), because they are not designed to work in a perfect forwarding manner. Here you can find a small demo on compiler explorer, if you want to make some tests.

Given the current situation, my point is:

• Am I asking too much to the standard iterators? Are there any unexpected behaviour of this approach? I have never seen something like std::begin(std::move(a)) around (you generally use std::make_move_iterator to do so), but in generic code I think that using std::begin(std::forward<A>(a)) could be useful... or not?


• I don't have a clear idea of how this approach would work with C++20 ranges. What do you think?


• If you consider that this approach could be valuable, do you think that it could be better using the .begin() method or a custom free function that performs perfect forwarding? Something like in the link to compiler explorer.

EDIT: Nelfeal found this other question that is very related to mine.