home | help
std::ranges::iter_move(3)      C++ Standard Libary     std::ranges::iter_move(3)

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  itera-
     tor.

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

	 1.  iter_move(t),  if t has a class or enumeration type and the expres-
     sion is
	    well-formed when treated as an unevaluated operand, where the  over-
     load
	    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 pur-
     poses, 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 dif-
     ferent
	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 re-
     quirements 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 it-
     erator 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

http://cppreference.com 	   2024.06.10	       std::ranges::iter_move(3)

home | help