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

NAME
     std::unordered_multimap::unordered_multimap  - std::unordered_multimap::un-
     ordered_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 alloca-
     tor.

	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  con-
     tainer
	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  con-
     tainer 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_allocator(),
     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, pointers,
     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 earlier
     modes.

	    Feature-test macro	     Value    Std		    Feature
	__cpp_lib_containers_ranges 202202L  (C++23)  Ranges-aware  construction
     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 be-
     havior
	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)
home | help