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

FreeBSD Manual Pages

  
 
  

home | help
std::unordered_set(3)	      C++ Standard Libary	 std::unordered_set(3)

NAME
       std::unordered_set - std::unordered_set

Synopsis
	  Defined in header <unordered_set>
	  template<

	  class	Key,
	  class	Hash = std::hash<Key>,				    (1)	(since
       C++11)
	  class	KeyEqual = std::equal_to<Key>,
	  class	Allocator = std::allocator<Key>

	  > class unordered_set;
	  namespace pmr	{

	  template <class Key,
	  class	Hash = std::hash<Key>,
	  class	Pred = std::equal_to<Key>>			    (2)	(since
       C++17)
	  using	unordered_set =	std::unordered_set<Key,	Hash, Pred,
	  std::pmr::polymorphic_allocator<Key>>;

	  }

	  Unordered  set  is  an  associative container	that contains a	set of
       unique objects of
	  type Key. Search, insertion, and removal have	average	 constant-time
       complexity.

	  Internally, the elements are not sorted in any particular order, but
       organized into
	  buckets.  Which bucket an element is placed into depends entirely on
       the hash	of its
	  value. This allows fast access to individual elements, since once  a
       hash is
	  computed, it refers to the exact bucket the element is placed	into.

	  Container elements may not be	modified (even by non const iterators)
       since
	  modification	could  change  an  element's hash and corrupt the con-
       tainer.

	  std::unordered_set meets  the	 requirements  of  Container,  Alloca-
       torAwareContainer,
	  UnorderedAssociativeContainer.

	 Iterator invalidation

			 Operations			   Invalidated
	  All read only	operations, swap, std::swap Never
	  clear, rehash, reserve, operator=	    Always
	  insert, emplace, emplace_hint		    Only if causes rehash
	  erase					    Only to the	element	erased

Notes
	    * The swap functions do not	invalidate any of the iterators	inside
       the container,
	      but  they	do invalidate the iterator marking the end of the swap
       region.

	    * References and pointers to data stored in	the container are only
       invalidated by
	      erasing that element, even when the  corresponding  iterator  is
       invalidated.

	    * After container move assignment, unless elementwise move assign-
       ment is forced by
	      incompatible  allocators,	 references,  pointers,	 and iterators
       (other than the end
	      iterator)	to moved-from container	remain valid, but refer	to el-
       ements that are
	      now in *this.

Member types
	  Member type		    Definition
	  key_type		    Key
	  value_type		    Key
	  size_type		       Unsigned	   integer    type    (usually
       std::size_t)
	  difference_type		Signed	   integer    type    (usually
       std::ptrdiff_t)
	  hasher		    Hash
	  key_equal		    KeyEqual
	  allocator_type	    Allocator
	  reference		    value_type&
	  const_reference	    const value_type&
	  pointer		    std::allocator_traits<Allocator>::pointer
	  const_pointer				 std::allocator_traits<Alloca-
       tor>::const_pointer
	  iterator		       Constant	   LegacyForwardIterator    to
       value_type
	  const_iterator	    LegacyForwardIterator to const value_type
				    An iterator	type  whose  category,	value,
       difference,
				    pointer and
	  local_iterator	     reference types are the same as iterator.
       This iterator
				    can	be used	to iterate  through  a	single
       bucket but not
				    across buckets
				    An	iterator  type	whose category,	value,
       difference,
				    pointer and
	  const_local_iterator	    reference types are	the same as  const_it-
       erator. This
				    iterator
				    can	 be  used  to iterate through a	single
       bucket but not
				    across buckets
	  node_type (since C++17)   a specialization of	node handle represent-
       ing a container
				    node
				    type describing the	result of inserting  a
       node_type, a
				    specialization of

				    template <class Iter, class	NodeType>
	  insert_return_type (since struct /*unspecified*/ {
	  C++17)		    Iter position;
				    bool inserted;
				    NodeType node;
				    };
				    instantiated with template arguments iter-
       ator and
				    node_type.

Member functions
	  constructor	    constructs the unordered_set
	  (C++11)	    (public member function)
	  destructor	    destructs the unordered_set
	  (C++11)	    (public member function)
	  operator=	    assigns values to the container
	  (C++11)	    (public member function)
	  get_allocator	    returns the	associated allocator
	  (C++11)	    (public member function)

Iterators
	  begin		    returns an iterator	to the beginning
	  cbegin	    (public member function)
	  (C++11)
	  end		    returns an iterator	to the end
	  cend		    (public member function)
	  (C++11)

Capacity
	  empty		    checks whether the container is empty
	  (C++11)	    (public member function)
	  size		    returns the	number of elements
	  (C++11)	    (public member function)
	  max_size	    returns the	maximum	possible number	of elements
	  (C++11)	    (public member function)

Modifiers
	  clear		    clears the contents
	  (C++11)	    (public member function)
			    inserts elements
	  insert	    or nodes
	  (C++11)	    (since C++17)
			    (public member function)
	  emplace	    constructs element in-place
	  (C++11)	    (public member function)
	  emplace_hint	    constructs elements	in-place using a hint
	  (C++11)	    (public member function)
	  erase		    erases elements
	  (C++11)	    (public member function)
	  swap		    swaps the contents
	  (C++11)	    (public member function)
	  extract	    extracts nodes from	the container
	  (C++17)	    (public member function)
	  merge		    splices nodes from another container
	  (C++17)	    (public member function)

Lookup
	  count		     returns  the number of elements matching specific
       key
	  (C++11)	    (public member function)
	  find		    finds element with specific	key
	  (C++11)	    (public member function)
	  contains	    checks if the container contains element with spe-
       cific key
	  (C++20)	    (public member function)
	  equal_range	    returns range of elements matching a specific key
	  (C++11)	    (public member function)

Bucket interface
	  begin(size_type)  returns an iterator	to the beginning of the	speci-
       fied bucket
	  cbegin(size_type) (public member function)
	  (C++11)
	  end(size_type)    returns an iterator	to the end  of	the  specified
       bucket
	  cend(size_type)   (public member function)
	  (C++11)
	  bucket_count	    returns the	number of buckets
	  (C++11)	    (public member function)
	  max_bucket_count  returns the	maximum	number of buckets
	  (C++11)	    (public member function)
	  bucket_size	    returns the	number of elements in specific bucket
	  (C++11)	    (public member function)
	  bucket	    returns the	bucket for specific key
	  (C++11)	    (public member function)

Hash policy
	  load_factor	    returns average number of elements per bucket
	  (C++11)	    (public member function)
	  max_load_factor    manages  maximum  average	number of elements per
       bucket
	  (C++11)	    (public member function)
	  rehash	    reserves at	least the specified number of  buckets
       and regenerates
	  (C++11)	    the	hash table
			    (public member function)
	  reserve	     reserves  space for at least the specified	number
       of elements and
	  (C++11)	    regenerates	the hash table
			    (public member function)

Observers
	  hash_function	    returns function used to hash the keys
	  (C++11)	    (public member function)
	  key_eq	    returns the	function  used	to  compare  keys  for
       equality
	  (C++11)	    (public member function)

Non-member functions
	  operator==			  compares   the  values  in  the  un-
       ordered_set
	  operator!=			(function template)
	  (removed in C++20)
	  std::swap(std::unordered_set)	specializes the	std::swap algorithm
	  (C++11)			(function template)
	  erase_if(std::unordered_set)	Erases all  elements  satisfying  spe-
       cific criteria
	  (C++20)			(function template)

	 Deduction guides(since	C++17)

Notes
	  The  member  types iterator and const_iterator may be	aliases	to the
       same type. This
	  means	defining a pair	of function overloads using the	two  types  as
       parameter types
	  may  violate	the One	Definition Rule. Since iterator	is convertible
       to
	  const_iterator, a single function with a const_iterator as parameter
       type will work
	  instead.

http://cppreference.com		  2022.07.31		 std::unordered_set(3)

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

home | help