NAME¶

std::ranges::iter_move - std::ranges::iter_move

Synopsis¶

Defined in header <iterator>
inline namespace /* unspecified */ {

inline constexpr /* unspecified */ iter_move = /* (since C++20)
unspecified */; (customization point object)

}
Call signature
template< class T >

requires /* see below */ (since C++20)

constexpr decltype(auto) iter_move( T&& t )
noexcept(/* see below */);

Obtains an rvalue reference or a prvalue temporary from a given iterator.

A ranges::iter_move(t) is expression-equivalent to:

1. iter_move(t), if t has a class or enumeration type and the expression is
well-formed when treated as an unevaluated operand, where the overload
resolution of iter_move is performed only with the candidates found by
argument-dependent lookup.
2. Otherwise, std::move(*t) if *t is well-formed and is an lvalue.
3. Otherwise, *t if *t is well-formed and is an rvalue.

In all other cases, a call to ranges::iter_move is ill-formed, which can result in
substitution failure when ranges::iter_move(e) appears in the immediate context of a
template instantiation.

If ranges::iter_move(e) is not equal to *e, the program is ill-formed, no diagnostic
required.

Customization point objects

The name ranges::iter_move denotes a customization point object, which is a const
function object of a literal semiregular class type. For exposition purposes, the
cv-unqualified version of its type is denoted as __iter_move_fn.

All instances of __iter_move_fn are equal. The effects of invoking different
instances of type __iter_move_fn on the same arguments are equivalent, regardless of
whether the expression denoting the instance is an lvalue or rvalue, and is
const-qualified or not (however, a volatile-qualified instance is not required to be
invocable). Thus, ranges::iter_move can be copied freely and its copies can be used
interchangeably.

Given a set of types Args..., if std::declval<Args>()... meet the requirements for
arguments to ranges::iter_move above, __iter_move_fn models

* std::invocable<__iter_move_fn, Args...>,
* std::invocable<const __iter_move_fn, Args...>,
* std::invocable<__iter_move_fn&, Args...>, and
* std::invocable<const __iter_move_fn&, Args...>.

Otherwise, no function call operator of __iter_move_fn participates in overload
resolution.

Example¶

This section is incomplete
Reason: no example

See also¶

iter_move casts the result of dereferencing the adjusted underlying iterator to its
(C++20) associated rvalue reference type
(function)
iter_move casts the result of dereferencing the underlying iterator to its
(C++20) associated rvalue reference type
(function)

Category:¶

* Todo no example