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

FreeBSD Manual Pages

  
 
  

home | help 
deductiongu...td::multimap(3) C++ Standard Libarydeductiongu...td::multimap(3)

NAME
       deductionguidesforstd::multimap - deductionguidesforstd::multimap

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)
	  multimap( InputIt, InputIt, Comp = Comp(), Alloc = Alloc() )

	      -> multimap<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>> >
	  multimap( std::initializer_list<std::pair<Key, T>>, Comp =
	  Comp(), Alloc	= Alloc() )

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

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

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

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

	      -> multimap<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>> >
	  multimap(  std::from_range_t,	 R&&,  Compare = Compare(), Alloc  (5)
       (since C++23)
	  = Alloc() )

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

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

	      -> multimap<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 multimap	to  allow  de-
       duction from an
	  iterator  range  (overloads  (1,3)) and std::initializer_list	(over-
       loads (2,4)).
	  5,6) These deduction guides are provided for multimap	to  allow  de-
       duction 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::multimap m1	= {{"foo", 1}, {"bar", 2}};
		// Error: braced-init-list has no type;	cannot deduce
		// pair<Key, T>	from {"foo", 1}	or {"bar", 2}

	    std::multimap m1 = {std::pair{"foo", 2}, {"bar", 3}}; // guide #2
	    std::multimap 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	 deductiongu...td::multimap(3)

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

home | help