Ctrl+K

Construction, destruction, copying

Construction, destruction, copying#

Empty container constructors#

concurrent_unordered_map();

explicit concurrent_unordered_map( const allocator_type& alloc );

Constructs an empty concurrent_unordered_map. The initial number of buckets is unspecified.

If provided, uses the allocator alloc to allocate the memory.

explicit concurrent_unordered_map( size_type bucket_count,
                                   const hasher& hash = hasher(),
                                   const key_equal& equal = key_equal(),
                                   const allocator_type& alloc = allocator_type() );

concurrent_unordered_map( size_type bucket_count, const allocator_type& alloc );

concurrent_unordered_map( size_type bucket_count, const hasher& hash,
                          const allocator_type& alloc );

Constructs an empty concurrent_unordered_map with bucket_count buckets.

If provided, uses the hash function hasher, predicate equal to compare key_type objects for equality, and the allocator alloc to allocate the memory.

Constructors from the sequence of elements#

template <typename InputIterator>
concurrent_unordered_map( InputIterator first, InputIterator last,
                          size_type bucket_count = /*implementation-defined*/,
                          const hasher& hash = hasher(),
                          const key_equal& equal = key_equal(),
                          const allocator_type& alloc = allocator_type() );

template <typename Inputiterator>
concurrent_unordered_map( InputIterator first, InputIterator last,
                          size_type bucket_count, const allocator_type& alloc );

template <typename InputIterator>
concurrent_unordered_map( InputIterator first, InputIterator last,
                          size_type bucket_count, const hasher& hash,
                          const allocator_type& alloc );

Constructs the concurrent_unordered_map that contains the elements from the half-open interval [first, last).

If the range [first, last) contains multiple elements with equal keys, it is unspecified which element would be inserted.

If provided, uses the hash function hasher, predicate equal to compare key_type objects for equality, and the allocator alloc to allocate the memory.

Requirements: the type InputIterator must meet the requirements of InputIterator from the [input.iterators] ISO C++ Standard section.

concurrent_unordered_map( std::initializer_list<value_type> init,
                          size_type bucket_count = /*implementation-defined*/,
                          const hasher& hash = hasher(),
                          const key_equal& equal = key_equal(),
                          const allocator_type& alloc = allocator_type() );

Equivalent to concurrent_unordered_map(init.begin(), init.end(), bucket_count, hash, equal, alloc).

concurrent_unordered_map( std::initializer_list<value_type> init,
                          size_type bucket_count, const allocator_type& alloc );

Equivalent to concurrent_unordered_map(init.begin(), init.end(), bucket_count, alloc).

concurrent_unordered_map( std::initializer_list<value_type> init,
                          size_type bucket_count, const hasher& hash,
                          const allocator_type& alloc );

Equivalent to concurrent_unordered_map(init.begin(), init.end(), bucket_count, hash, alloc).

Copying constructors#

concurrent_unordered_map( const concurrent_unordered_map& other );

concurrent_unordered_map( const concurrent_unordered_map& other,
                          const allocator_type& alloc );

Constructs a copy of other.

If the allocator argument is not provided, it is obtained by calling std::allocator_traits<allocator_type>::select_on_container_copy_construction(other.get_allocator()).

The behavior is undefined in case of concurrent operations with other.

Moving constructors#

concurrent_unordered_map( concurrent_unordered_map&& other );

concurrent_unordered_map( concurrent_unordered_map&& other,
                          const allocator_type& alloc );

Constructs a concurrent_unordered_map with the contents of other using move semantics.

other is left in a valid, but unspecified state.

If the allocator argument is not provided, it is obtained by calling std::move(other.get_allocator()).

The behavior is undefined in case of concurrent operations with other.

Destructor#

~concurrent_unordered_map();

Destroys the concurrent_unordered_map. Calls destructors of the stored elements and deallocates the used storage.

The behavior is undefined in case of concurrent operations with *this.

Assignment operators#

concurrent_unordered_map& operator=( const concurrent_unordered_map& other );

Replaces all elements in *this by the copies of the elements in other.

Copy-assigns allocators if std::allocator_traits<allocator_type>::propagate_on_container_copy_assignment::value is true.

The behavior is undefined in case of concurrent operations with *this and other.

Returns: a reference to *this.

concurrent_unordered_map& operator=( concurrent_unordered_map&& other ) noexcept(/*See below*/);

Replaces all elements in *this by the elements in other using move semantics.

other is left in a valid, but unspecified state.

Move-assigns allocators if std::allocator_traits<allocator_type>::propagate_on_container_move_assignment::value is true.

The behavior is undefined in case of concurrent operations with *this and other.

Returns: a reference to *this.

Exceptions: noexcept specification:

noexcept(std::allocator_traits<allocator_type>::is_always_equal::value &&
         std::is_nothrow_move_assignable<hasher>::value &&
         std::is_nothrow_move_assignable<key_equal>::value)

concurrent_unordered_map& operator=( std::initializer_list<value_type> init );

Replaces all elements in *this by the elements in init.

If init contains multiple elements with equal keys, it is unspecified which element would be inserted.

The behavior is undefined in case of concurrent operations with *this.

Returns: a reference to *this.

Contents