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,   T>>    >
       (2) (since C++17)
	  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 Allocator	>

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

	  -> map<Key, T, std::less<Key>, Allocator>;

	  where	 the  type aliases iter_key_t, iter_val_t, iter_to_alloc_t are
       defined as if as
	  follows

	  template< class InputIt >
										   (ex-
       position
	  using		 iter_key_t	      =		  std::remove_const_t<
       only)

	  typename std::iterator_traits<InputIt>::value_type::first_type>;
	  template<		   class	       InputIt		     >
       (exposition
	  using		     iter_val_t		      =		      typename
       only)
	  std::iterator_traits<InputIt>::value_type::second_type;
	  template< class InputIt >

	  using	iter_to_alloc_t	= std::pair<
	  std::add_const_t<typename
       (exposition
	  std::iterator_traits<InputIt>::value_type::first_type>,
       only)
	  typename std::iterator_traits<InputIt>::value_type::second_type

	  >

	  This	deduction guide	is provided for	map to allow deduction from an
       iterator	range
	  (overloads (1,3)) and	std::initializer_list (overloads (2,4)). These
       overloads
	  participate in overload resolution only if InputIt satisfies Legacy-
       InputIterator,
	  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.

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		  2022.07.31	 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.0>

home | help