FreeBSD Manual Pages

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

NAME
       std::unordered_map::unordered_map - std::unordered_map::unordered_map

Synopsis
	  unordered_map() : unordered_map(
	  size_type(/*implementation-defined*/)	) {}

	  explicit	  unordered_map(	size_type	 bucket_count,
       (1) (since C++11)
	  const	Hash& hash = Hash(),
	  const	key_equal& equal = key_equal(),

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

	  const	Allocator& alloc )
	  : unordered_map(bucket_count,	Hash(),	key_equal(), alloc) {}
	  unordered_map(		size_type		 bucket_count,
       (1) (since C++14)
	  const	Hash& hash,
	  const	Allocator& alloc )

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

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

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

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

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

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

	  bucket_count,	hash, key_equal(), alloc) {}
	  unordered_map(       const	   unordered_map&	other	    );
       (3) (since C++11)
	  unordered_map( const unordered_map& other,  const  Allocator&	 alloc
       (3) (since C++11)
	  );
	  unordered_map(	   unordered_map&&	     other	    );
       (4) (since C++11)
	  unordered_map( unordered_map&&  other,  const	 Allocator&  alloc  );
       (4) (since C++11)
	  unordered_map( std::initializer_list<value_type> init,

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

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

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

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

	  size_type bucket_count,
	  const				  Hash&				 hash,
       (5) (since C++14)
	  const	Allocator& alloc )
	  : unordered_map(init,	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)  Constructs  empty	 container. Sets max_load_factor() to 1.0. For
       the default
	  constructor, the number of buckets is	implementation-defined.
	  2) constructs	the container with the contents	of the	range  [first,
       last). Sets
	  max_load_factor()  to	 1.0.  If  multiple elements in	the range have
       keys that compare
	  equivalent, it is unspecified	which  element	is  inserted  (pending
       LWG2844).
	  3)  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.

	  4) 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.

	  5)  constructs  the  container  with the contents of the initializer
       list init, same as
	  unordered_map(init.begin(), init.end()).

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 to copy the elements	from
	  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) constant
	  2)  average  case  linear  worst  case quadratic in distance between
       first and last
	  3) linear in size of other
	  4) constant. If alloc	is given and alloc  !=	other.get_allocator(),
       then linear.
	  5) average case linear worst case quadratic in size of init

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.requirements.general]/12, and	a more	direct
       guarantee is
	  under	consideration via LWG 2321.

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

Example
       // Run this code

	#include <unordered_map>
	#include <vector>
	#include <bitset>
	#include <string>
	#include <utility>

	struct Key {
	    std::string	first;
	    std::string	second;
	};

	struct KeyHash {
	 std::size_t operator()(const Key& k) const
	 {
	     return std::hash<std::string>()(k.first) ^
		    (std::hash<std::string>()(k.second)	<< 1);
	 }
	};

	struct KeyEqual	{
	 bool operator()(const Key& lhs, const Key& rhs) const
	 {
	    return lhs.first ==	rhs.first && lhs.second	== rhs.second;
	 }
	};

	struct Foo {
	    Foo(int val_) : val(val_) {}
	    int	val;
	    bool operator==(const Foo &rhs) const { return val == rhs.val; }
	};

	namespace std {
	    template<> struct hash<Foo>	{
		std::size_t operator()(const Foo &f) const {
		    return std::hash<int>{}(f.val);
		}
	    };
	}

	int main()
	{
	    // default constructor: empty map
	    std::unordered_map<std::string, std::string> m1;

	    // list constructor
	    std::unordered_map<int, std::string> m2 =
	    {
		{1, "foo"},
		{3, "bar"},
		{2, "baz"},
	    };

	    // copy constructor
	    std::unordered_map<int, std::string> m3 = m2;

	    // move constructor
	    std::unordered_map<int, std::string> m4 = std::move(m2);

	    // range constructor
	    std::vector<std::pair<std::bitset<8>,  int>>  v  =	{  {0x12,  1},
       {0x01,-1} };
	    std::unordered_map<std::bitset<8>, double> m5(v.begin(), v.end());

	    //Option 1 for a constructor with a	custom Key type
	    //	Define	the  KeyHash  and KeyEqual structs and use them	in the
       template
	    std::unordered_map<Key, std::string, KeyHash, KeyEqual> m6 = {
		    { {"John", "Doe"}, "example"},
		    { {"Mary", "Sue"}, "another"}
	    };

	    //Option 2 for a constructor with a	custom Key type
	    // Define a	const == operator for the class/struct and  specialize
       std::hash
	    // structure in the	std namespace
	    std::unordered_map<Foo, std::string> m7 = {
		{ Foo(1), "One"}, { 2, "Two"}, { 3, "Three"}
	    };

	    //Option 3:	Use lambdas
	    // Note that the initial bucket count has to be passed to the con-
       structor
	    struct Goo {int val; };
	    auto hash =	[](const Goo &g){ return std::hash<int>{}(g.val); };
	    auto comp =	[](const Goo &l, const Goo &r){	return l.val ==	r.val;
       };
	    std::unordered_map<Goo,  double,  decltype(hash),  decltype(comp)>
       m8(10, hash, comp);
	}

	 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 is explicit made non-ex-
       plicit

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

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

Peripheral Links

Site Navigation

FreeBSD Manual Pages

Header And Logo

Peripheral Links

Search

Site Navigation

FreeBSD Manual Pages
