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

NAME
     std::projected - std::projected

Synopsis
	Defined in header <iterator>
	template< std::indirectly_readable I,

		  std::indirectly_regular_unary_invocable<I> Proj >
	struct projected
	{
     (since C++20)
	    using			   value_type			       =
     (until C++26)
	std::remove_cvref_t<std::indirect_result_t<Proj&, I>>;
	    std::indirect_result_t<Proj&, I> operator*() const; //
	not defined

	};
	template< std::indirectly_readable I,

		  std::indirectly_regular_unary_invocable<I>	   Proj        >
     (since C++26)

	using projected = /*projected-impl*/<I, Proj>::/*__type*/; //
	see (3)
	template< std::weakly_incrementable I, class Proj >

	struct	  incrementable_traits<std::projected<I,   Proj>>	     (1)
     (since C++20)
	{								     (2)
     (until C++26)
	    using difference_type = std::iter_difference_t<I>;

	};
	template< class I, class Proj >

	struct /*projected-impl*/
	{
	    struct /*__type*/
	    {
		using			     value_type 		       =
     (since C++26)
	std::remove_cvref_t<std::indirect_result_t<Proj&,  I>>; 	     (3)
     (exposition
		using	 difference_type    =	 std::iter_difference_t<I>;   //
     only*)
	conditionally present

		std::indirect_result_t<Proj&, I> operator*() const;
	// not defined
	    };

	};

	1)
	Class
	(until C++26)
	Alias
	(since C++26) template projected combines an indirectly_readable type  I
     and a
	callable object type Proj into a new indirectly_readable type whose ref-
     erence type
	is the result of applying Proj to the std::iter_reference_t<I>.
	2)  This  specialization  of  std::incrementable_traits  makes std::pro-
     jected<I, Proj> a
	weakly_incrementable type when I is also a weakly_incrementable type.
	3) An indirect layer used  for	avoiding  unexpected  argument-dependent
     lookup. The
	member	type  difference_type  exists  only  if  I  models weakly_incre-
     mentable.

	projected is used only to constrain algorithms that accept callable  ob-
     jects and
	projections, and hence its operator*() is not defined.

Template parameters
	I    - an indirectly readable type
	Proj - projection applied to a dereferenced I

Notes
	The  indirect layer prevents I and Proj to be associated classes of pro-
     jected. When
	an associated class of I or Proj is an incomplete class type, the  indi-
     rect layer
	avoids	the  unnecessary  attempt to inspect the definition of that type
     that results
	in hard error.

Example
     // Run this code

      #include <algorithm>
      #include <cassert>
      #include <functional>
      #include <iterator>

      template<class T>
      struct Holder
      {
	  T t;
      };

      struct Incomplete;

      using P = Holder<Incomplete>*;

      static_assert(std::equality_comparable<P>); // OK
      static_assert(std::indirectly_comparable<P*, P*, std::equal_to<>>); // Er-
     ror before C++26
      static_assert(std::sortable<P*>); // Error before C++26

      int main()
      {
	  P a[10] = {}; // ten null pointers
	  assert(std::count(a, a + 10, nullptr) == 10); // OK
	  assert(std::ranges::count(a, a + 10, nullptr) == 10); // Error  before
     C++26
      }

See also
	projected_value_t computes the value type of an indirectly_readable type
     by
	(C++26) 	  projection
			  (alias template)

http://cppreference.com 	   2024.06.10		       std::projected(3)
home | help