Construction, destruction, copying#

Empty container constructors#

concurrent_unordered_multiset();

explicit concurrent_unordered_multiset( const allocator_type& alloc );
Constructs an empty concurrent_unordered_multiset. The initial number of buckets is unspecified.

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

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

concurrent_unordered_multiset( size_type bucket_count, const allocator_type& alloc );

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

Constructs an empty concurrent_unordered_multiset 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_multiset( 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_multiset( InputIterator first, InputIterator last,
                               size_type bucket_count, const allocator_type& alloc );

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

Constructs the concurrent_unordered_multiset, which contains the elements from the half-open interval [first, last)`.

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_multiset( 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_multiset(init.begin(), init.end(), bucket_count, hash, equal, alloc).

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

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

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

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

Copying constructors#

concurrent_unordered_multiset( const concurrent_unordered_multiset& other );

concurrent_unordered_multiset( const concurrent_unordered_multiset& 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_multiset( concurrent_unordered_multiset&& other );

concurrent_unordered_multiset( concurrent_unordered_multiset&& other,
                               const allocator_type& alloc );
Constructs a concurrent_unordered_multiset 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_multiset();
Destroys the concurrent_unordered_multiset. 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_multiset& operator=( const concurrent_unordered_multiset& 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_multiset& operator=( concurrent_unordered_multiset&& 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_multiset& operator=( std::initializer_list<value_type> init );
Replaces all elements in *this by the elements in init.

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

Returns: a reference to *this.

Construction, destruction, copying

Contents