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

FreeBSD Manual Pages

  
 
  

home | help 
deductionguidesforstd::map(3) C++ Standard Libarydeductionguidesforstd::map(3)

NAME
       deductionguidesforstd::map - deductionguidesforstd::map

Synopsis
	  Defined in header <map>
	  template< class InputIt,

		    class Comp = std::less<iter_key_t<InputIt>>,
		    class Alloc	=
	  std::allocator<iter_to_alloc_t<InputIt>>   >			   (1)
       (since C++17)
	  map( InputIt,	InputIt, Comp =	Comp(),	Alloc =	Alloc()	)

	      -> map<iter_key_t<InputIt>, iter_val_t<InputIt>, Comp,
	  Alloc>;
	  template< class Key,

		    class T,
		    class Comp = std::less<Key>,
		    class Alloc	=  std::allocator<std::pair<const  Key,	   (2)
       (since C++17)
	  T>> >
	  map( std::initializer_list<std::pair<Key, T>>, Comp =	Comp(),
	  Alloc	= Alloc() )

	      -> map<Key, T, Comp, Alloc>;
	  template< class InputIt, class Alloc >

	  map(	InputIt,  InputIt,  Alloc )				   (3)
       (since C++17)
	      -> map<iter_key_t<InputIt>, iter_val_t<InputIt>,

		     std::less<iter_key_t<InputIt>>, Alloc>;
	  template< class Key, class T,	class Alloc >

	  map( std::initializer_list<std::pair<Key, T>>,  Alloc	 )	   (4)
       (since C++17)

	      -> map<Key, T, std::less<Key>, Alloc>;
	  template< ranges::input_range	R, class Compare =
	  std::less<range_key_t<R>,

		    class Alloc	= std::allocator<range_to_alloc_t<R>> >
	  map(	std::from_range_t,  R&&,  Compare = Compare(), Alloc =	   (5)
       (since C++23)
	  Alloc() )

	      -> map<range_key_t<R>, range_mapped_t<R>,	Compare,
	  Alloc>;
	  template< ranges::input_range	R, class Alloc >

	  map( std::from_range_t, R&&,	Alloc  )			   (6)
       (since C++23)

	      -> map<range_key_t<R>, range_mapped_t<R>,
	  std::less<range_key_t<R>>, Alloc>;
	  Exposition-only helper type aliases
	  template< class InputIter >

	  using				 iter_val_t			     =
       (exposition only*)

	      typename std::iterator_traits<InputIter>::value_type;
	  template< class InputIter >

	  using				 iter_key_t			     =
       (exposition only*)

	      std::remove_const_t< std::tuple_element_t<0,
	  iter_val_t<InputIter>>>;
	  template< class InputIter >

	  using				iter_mapped_t			     =
       (exposition only*)

	      std::tuple_element_t<1, iter_val_t<InputIter>>;
	  template< class InputIter >

	  using	iter_to_alloc_t	=
	      std::pair<std::add_const_t<tuple_element_t<0,
       (exposition only*)
	  iter_val_t<InputIter>>>,

			std::tuple_element_t<1,
	  iter_val_t<InputIter>>>;
	  template< ranges::input_range	Range >

	  using				range_key_t			     =
       (since C++23)
									    (ex-
       position	only*)
	      std::remove_const_t<typename
	  ranges::range_value_t<Range>::first_type>;
	  template< ranges::input_range	Range >
									    (since
       C++23)
	  using			       range_mapped_t			     =
       (exposition only*)

	      typename ranges::range_value_t<Range>::second_type;
	  template< ranges::input_range	Range >

	  using	range_to_alloc_t =
	      std::pair<std::add_const_t<typename
       (since C++23)
	  ranges::range_value_t<Range>::first_type>,
       (exposition only*)

			typename
	  ranges::range_value_t<Range>::second_type>;

	  1-4) These deduction guides are provided for map to allow  deduction
       from an iterator
	  range	(overloads (1,3)) and std::initializer_list (overloads (2,4)).
	  5,6)	These deduction	guides are provided for	map to allow deduction
       from a
	  std::from_range_t tag	and an input_range.

	  These	overloads participate in overload resolution only  if  InputIt
       satisfies
	  LegacyInputIterator,	Alloc  satisfies  Allocator, and Comp does not
       satisfy Allocator.

	  Note:	the extent to which the	library	determines that	 a  type  does
       not satisfy
	  LegacyInputIterator  is  unspecified,	except that as a minimum inte-
       gral types do not
	  qualify as input iterators. Likewise,	the extent to which it	deter-
       mines that a type
	  does	not satisfy Allocator is unspecified, except that as a minimum
       the member type
	  Alloc::value_type must exist and the expression
	  std::declval<Alloc&>().allocate(std::size_t{}) must  be  well-formed
       when treated as
	  an unevaluated operand.

Notes
	      Feature-test macro       Value	Std		      Feature
	  __cpp_lib_containers_ranges  202202L	(C++23)	Ranges-aware construc-
       tion and	insertion;
						      overload (5,6)

Example
       // Run this code

	#include <map>

	int main()
	{
	    // std::map	m1 = {{"foo", 1}, {"bar", 2}};
		// Error: braced-init-list has no type;	cannot deduce
		// pair<Key, T>	from {"foo", 1}	or {"bar", 2}

	    std::map m1	= {std::pair{"foo", 2},	{"bar",	3}}; //	guide #2
	    std::map m2(m1.begin(), m1.end()); // guide	#1
	}

	  Defect reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	      Applied	 to		 Behavior     as     published
       Correct behavior
	  LWG  3025  C++17	initializer-list guides	take		   use
       std::pair<Key, T>
			      std::pair<const Key, T>

http://cppreference.com		  2024.06.10	 deductionguidesforstd::map(3)

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

home | help