Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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
       reference 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
       objects 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
       projected. When
	  an associated	class of I or Proj is an incomplete  class  type,  the
       indirect	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<>>); //
       Error 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 be-
       fore 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)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::projected&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help