FreeBSD Manual Pages

home | help
std::unorde...red_multimap(3) C++ Standard Libarystd::unorde...red_multimap(3)

NAME
       std::unordered_multimap::unordered_multimap    -	   std::unordered_mul-
       timap::unordered_multimap

Synopsis
	  unordered_multimap()
       (since C++11)
	      :	    unordered_multimap(size_type(/*	implementation-defined
       (until C++20)
	  */)) {}
	  unordered_multimap();
       (since C++20)
	  explicit unordered_multimap( size_type bucket_count,

				       const Hash& hash	= Hash(),
				       const	  key_equal&	  equal	     =
       (2)  (since C++11)
	  key_equal(),

				       const Allocator&	alloc =
	  Allocator() );
	  unordered_multimap( size_type	bucket_count,

			      const	    Allocator&	       alloc	     )
       (3)  (since C++14)

	      :	unordered_multimap(bucket_count, Hash(), key_equal(),
	  alloc) {}
	  unordered_multimap( size_type	bucket_count,

			      const Hash& hash,
			      const	    Allocator&	       alloc	     )
       (4)  (since C++14)

	      :	unordered_multimap(bucket_count, hash, key_equal(),
	  alloc) {}
	  explicit   unordered_multimap(    const    Allocator&	   alloc    );
       (5)  (since C++11)
	  template< class InputIt >

	  unordered_multimap( InputIt first, InputIt last,
			      size_type	bucket_count = /*
	  implementation-defined					   */,
       (6)  (since C++11)
			      const Hash& hash = Hash(),
			      const key_equal& equal = key_equal(),

			      const Allocator& alloc = Allocator() );
	  template< class InputIt >

	  unordered_multimap( InputIt first, InputIt last,
			      size_type	bucket_count,
			      const	    Allocator&	       alloc	     )
       (7)  (since C++14)
	      :	unordered_multimap(first, last,

				   bucket_count, Hash(), key_equal(),
	  alloc) {}
	  template< class InputIt >

	  unordered_multimap( InputIt first, InputIt last,
			      size_type	bucket_count,
			      const		    Hash&		 hash,
       (8)  (since C++14)
			      const Allocator& alloc )
	      :	unordered_multimap(first, last,

				   bucket_count, hash, key_equal(),
	  alloc) {}
	  unordered_multimap(	 const	  unordered_multimap&	  other	    );
       (9)  (since C++11)
	  unordered_multimap(	 const	  unordered_multimap&	other,	 const
       (10) (since C++11)
	  Allocator& alloc );						(1)
	  unordered_multimap(	    unordered_multimap&&       other	    );
       (11) (since C++11)
	  unordered_multimap(	   unordered_multimap&&	     other,	 const
       (12) (since C++11)
	  Allocator& alloc );
	  unordered_multimap( std::initializer_list<value_type>	init,

			      size_type	bucket_count = /*
	  implementation-defined					   */,
       (13) (since C++11)
			      const Hash& hash = Hash(),
			      const key_equal& equal = key_equal(),

			      const Allocator& alloc = Allocator() );
	  unordered_multimap( std::initializer_list<value_type>	init,

			      size_type	bucket_count,
			      const	    Allocator&	       alloc	     )
       (14) (since C++14)
	      :	unordered_multimap(init, bucket_count,

				   Hash(), key_equal(),	alloc) {}
	  unordered_multimap( std::initializer_list<value_type>	init,

			      size_type	bucket_count,
			      const		   Hash&		 hash,
       (15) (since C++14)
			      const Allocator& alloc )
	      :	unordered_multimap(init, bucket_count,

				   hash, key_equal(), alloc) {}
	  template< container-compatible-range<value_type> R >

	  unordered_multimap( std::from_range_t, R&& rg,
			      size_type	bucket_count = /* see
	  description							   */,
       (16) (since C++23)
			      const Hash& hash = Hash(),
			      const key_equal& equal = key_equal(),

			      const Allocator& alloc = Allocator() );
	  template< container-compatible-range<value_type> R >

	  unordered_multimap( std::from_range_t, R&& rg,
			      size_type	bucket_count,
			      const	    Allocator&	       alloc	     )
       (17) (since C++23)
	      :	unordered_multimap(std::from_range,
	  std::forward<R>(rg),

				   bucket_count, Hash(), key_equal(),
	  alloc) {}
	  template< container-compatible-range<value_type> R >

	  unordered_multimap( std::from_range_t, R&& rg,
			      size_type	bucket_count,
			      const Hash& hash,
			      const	      Alloc&	      alloc	     )
       (18) (since C++23)
	      :	unordered_multimap(std::from_range,
	  std::forward<R>(rg),

				   bucket_count, hash, key_equal(),
	  alloc) {}

	  Constructs new container from	a variety of data sources.  Optionally
       uses user
	  supplied bucket_count	as a minimal number of buckets to create, hash
       as the hash
	  function, equal as the function to compare keys and alloc as the al-
       locator.

	  1-5)	Constructs empty container. Sets max_load_factor() to 1.0. For
       the default
	  constructor, the number of buckets is	implementation-defined.
	  6-8) Constructs the container	with the contents of the range [first,
       last). Sets
	  max_load_factor() to 1.0.
	  9,10)	Copy constructor. Constructs the container with	 the  copy  of
       the contents of
	  other,  copies the load factor, the predicate, and the hash function
       as well.	If
	  alloc	is not provided, allocator is obtained by calling
	  std::allocator_traits<allocator_type>::select_on_container_copy_con-
       struction(other.get_allocator()).

	  The template parameter Allocator is  only  deduced  from  the	 first
       (since C++23)
	  argument while used in class template	argument deduction.

	  11,12)  Move constructor. Constructs the container with the contents
       of other	using
	  move semantics. If alloc is not provided, allocator is  obtained  by
       move-construction
	  from the allocator belonging to other.

	  The  template	 parameter  Allocator  is  only	deduced	from the first
       (since C++23)
	  argument while used in class template	argument deduction.

	  13-15) Initializer-list constructor. Constructs the  container  with
       the contents of
	  the  initializer list	init, same as unordered_multimap(init.begin(),
       init.end()).
	  16-18) Constructs the	container with the contents of rg.

Parameters
	  alloc	       - allocator to use for all memory allocations  of  this
       container
	  bucket_count	-  minimal number of buckets to	use on initialization.
       If it is	not
			 specified, implementation-defined  default  value  is
       used
	  hash	       - hash function to use
	  equal	       - comparison function to	use for	all key	comparisons of
       this container
	  first, last  - the range [first, last) to copy the elements from
	  rg	       - a container compatible	range, that is,	an input_range
       whose elements
			 are convertible to value_type
	  other		- another container to be used as source to initialize
       the elements of
			 the container with
	  init	       - initializer list to initialize	the  elements  of  the
       container with

Type requirements
	  -
	  InputIt must meet the	requirements of	LegacyInputIterator.

Complexity
	  1-5) Constant.
	  6-8) Average case linear (i.e. O(N), where N is std::distance(first,
       last)), worst
	  case quadratic, i.e. O(N^2).
	  9,10)	Linear in size of other.
	  11,12)  Constant.  If	 alloc is given	and alloc != other.get_alloca-
       tor(), then linear.
	  13-15) Average case O(N) (N is std::size(init)), worst case O(N^2).
	  16-18) Average case O(N) (N  is  ranges::distance(rg)),  worst  case
       O(N^2).

Exceptions
	  Calls	to Allocator::allocate may throw.

Notes
	  After	container move construction (overload (4)), references,	point-
       ers, and
	  iterators  (other  than the end iterator) to other remain valid, but
       refer to	elements
	  that are now in *this. The current standard makes this guarantee via
       the blanket
	  statement in [container.reqmts]/67, and a more direct	 guarantee  is
       under
	  consideration	via LWG	issue 2321.

	  Although  not	 formally  required  until C++23, some implementations
       have already put
	  the template parameter Allocator into	non-deduced contexts  in  ear-
       lier modes.

	      Feature-test macro       Value	Std		      Feature
	  __cpp_lib_containers_ranges  202202L	(C++23)	Ranges-aware construc-
       tion and	insertion;
						      overloads	(16-18)

Example
	   This	section	is incomplete
	   Reason: no example

	  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 2193 C++11      the default constructor (1)  was	explicit  made
       non-explicit

See also
	  operator= assigns values to the container
		    (public member function)

Category:
	    * Todo no example

http://cppreference.com		  2024.06.10	 std::unorde...red_multimap(3)
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::unordered_multimap::unordered_multimap&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>
home | help
Header And Logo

Peripheral Links

Site Navigation

FreeBSD Manual Pages

Header And Logo

Peripheral Links

Search

Site Navigation

FreeBSD Manual Pages
