boost_mirror/unordered
1
0
Fork 0
mirror of https://github.com/boostorg/unordered.git synced 2025-05-12 05:51:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #110 from cmazakas/equal-range-reference-docs-fixes

Browse Source 
Add missing `std::` qualification to usages of `pair` in the reference
This commit is contained in:
Peter Dimov 2022-03-02 21:10:38 +02:00 committed by GitHub
commit bca33372c2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
doc/unordered/unordered_map.adoc
View File

@ -57,7 +57,7 @@ namespace boost {
explicit xref:#unordered_map_allocator_constructor[unordered_map](const Allocator& a); explicit xref:#unordered_map_allocator_constructor[unordered_map](const Allocator& a);
xref:#unordered_map_copy_constructor_with_allocator[unordered_map](const unordered_map& other, const Allocator& a); xref:#unordered_map_copy_constructor_with_allocator[unordered_map](const unordered_map& other, const Allocator& a);
xref:#unordered_map_move_constructor_with_allocator[unordered_map](unordered_map&& other, const Allocator& a); xref:#unordered_map_move_constructor_with_allocator[unordered_map](unordered_map&& other, const Allocator& a);
xref:#unordered_map_initializer_list_constructor[unordered_map](initializer_list<value_type> il, xref:#unordered_map_initializer_list_constructor[unordered_map](std::initializer_list<value_type> il,
size_type n = _implementation-defined_ size_type n = _implementation-defined_
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -75,7 +75,7 @@ namespace boost {
noexcept(boost::allocator_traits<Allocator>::is_always_equal::value && noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> && boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>); boost::is_nothrow_move_assignable_v<Pred>);
unordered_map& xref:#unordered_map_initializer_list_assignment[operator++=++](initializer_list<value_type>); unordered_map& xref:#unordered_map_initializer_list_assignment[operator++=++](std::initializer_list<value_type>);
allocator_type xref:#unordered_map_get_allocator[get_allocator]() const noexcept; allocator_type xref:#unordered_map_get_allocator[get_allocator]() const noexcept;
// iterators // iterators
@ -101,7 +101,7 @@ namespace boost {
iterator xref:#unordered_map_move_insert_with_hint[insert](const_iterator hint, value_type&& obj); iterator xref:#unordered_map_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
template<class P> iterator xref:#unordered_map_emplace_insert_with_hint[insert](const_iterator hint, P&& obj); template<class P> iterator xref:#unordered_map_emplace_insert_with_hint[insert](const_iterator hint, P&& obj);
template<class InputIterator> void xref:#unordered_map_insert_iterator_range[insert](InputIterator first, InputIterator last); template<class InputIterator> void xref:#unordered_map_insert_iterator_range[insert](InputIterator first, InputIterator last);
void xref:#unordered_map_insert_initializer_list[insert](initializer_list<value_type>); void xref:#unordered_map_insert_initializer_list[insert](std::initializer_list<value_type>);
template<class... Args> template<class... Args>
std::pair<iterator, bool> xref:#unordered_map_try_emplace[try_emplace](const key_type& k, Args&&... args); std::pair<iterator, bool> xref:#unordered_map_try_emplace[try_emplace](const key_type& k, Args&&... args);
@ -171,12 +171,12 @@ namespace boost {
bool xref:#unordered_map_contains[contains](const key_type& k) const; bool xref:#unordered_map_contains[contains](const key_type& k) const;
template<class K> template<class K>
bool xref:#unordered_map_contains[contains](const K& k) const; bool xref:#unordered_map_contains[contains](const K& k) const;
pair<iterator, iterator> xref:#unordered_map_equal_range[equal_range](const key_type& k); std::pair<iterator, iterator> xref:#unordered_map_equal_range[equal_range](const key_type& k);
pair<const_iterator, const_iterator> xref:#unordered_map_equal_range[equal_range](const key_type& k) const; std::pair<const_iterator, const_iterator> xref:#unordered_map_equal_range[equal_range](const key_type& k) const;
template<class K> template<class K>
pair<iterator, iterator> xref:#unordered_map_equal_range[equal_range](const K& k); std::pair<iterator, iterator> xref:#unordered_map_equal_range[equal_range](const K& k);
template<class K> template<class K>
pair<const_iterator, const_iterator> xref:#unordered_map_equal_range[equal_range](const K& k) const; std::pair<const_iterator, const_iterator> xref:#unordered_map_equal_range[equal_range](const K& k) const;
// element access // element access
mapped_type& xref:#unordered_map_operator[operator[+]+](const key_type& k); mapped_type& xref:#unordered_map_operator[operator[+]+](const key_type& k);
@ -481,7 +481,7 @@ Requires:;; `value_type` is move insertable.
==== Initializer List Constructor ==== Initializer List Constructor
[source,c++,subs="+quotes"] [source,c++,subs="+quotes"]
---- ----
unordered_map(initializer_list<value_type> il, unordered_map(std::initializer_list<value_type> il,
size_type n = _implementation-defined_ size_type n = _implementation-defined_
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -597,7 +597,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment ==== Initializer List Assignment
```c++ ```c++
unordered_map& operator=(initializer_list<value_type> il); unordered_map& operator=(std::initializer_list<value_type> il);
``` ```
Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed. Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed.
@ -869,7 +869,7 @@ Pointers and references to elements are never invalidated.
==== Insert Initializer List ==== Insert Initializer List
```c++ ```c++
void insert(initializer_list<value_type>); void insert(std::initializer_list<value_type>);
``` ```
Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key. Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key.
@ -1364,12 +1364,12 @@ Notes:;; The `template <typename K>` overload only participates in overload reso
==== equal_range ==== equal_range
```c++ ```c++
pair<iterator, iterator> equal_range(const key_type& k); std::pair<iterator, iterator> equal_range(const key_type& k);
pair<const_iterator, const_iterator> equal_range(const key_type& k) const; std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
template<class K> template<class K>
pair<iterator, iterator> equal_range(const K& k); std::pair<iterator, iterator> equal_range(const K& k);
template<class K> template<class K>
pair<const_iterator, const_iterator> equal_range(const K& k) const; std::pair<const_iterator, const_iterator> equal_range(const K& k) const;
``` ```
[horizontal] [horizontal]

30
doc/unordered/unordered_multimap.adoc
View File

@ -56,7 +56,7 @@ namespace boost {
explicit xref:#unordered_multimap_allocator_constructor[unordered_multimap](const Allocator& a); explicit xref:#unordered_multimap_allocator_constructor[unordered_multimap](const Allocator& a);
xref:#unordered_multimap_copy_constructor_with_allocator[unordered_multimap](const unordered_multimap& other, const Allocator& a); xref:#unordered_multimap_copy_constructor_with_allocator[unordered_multimap](const unordered_multimap& other, const Allocator& a);
xref:#unordered_multimap_move_constructor_with_allocator[unordered_multimap](unordered_multimap&& other, const Allocator& a); xref:#unordered_multimap_move_constructor_with_allocator[unordered_multimap](unordered_multimap&& other, const Allocator& a);
xref:#unordered_multimap_initializer_list_constructor[unordered_multimap](initializer_list<value_type> il, xref:#unordered_multimap_initializer_list_constructor[unordered_multimap](std::initializer_list<value_type> il,
size_type n = _implementation-defined_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -68,7 +68,7 @@ namespace boost {
template<class InputIterator> template<class InputIterator>
xref:#unordered_multimap_iterator_range_constructor_with_bucket_count_and_hasher[unordered_multimap](InputIterator f, InputIterator l, size_type n, const hasher& hf, xref:#unordered_multimap_iterator_range_constructor_with_bucket_count_and_hasher[unordered_multimap](InputIterator f, InputIterator l, size_type n, const hasher& hf,
const allocator_type& a); const allocator_type& a);
xref:#unordered_multimap_initializer_list_constructor[unordered_multimap](initializer_list<value_type> il, size_type n, const hasher& hf, xref:#unordered_multimap_initializer_list_constructor[unordered_multimap](std::initializer_list<value_type> il, size_type n, const hasher& hf,
const allocator_type& a); const allocator_type& a);
xref:#unordered_multimap_destructor[~unordered_multimap](); xref:#unordered_multimap_destructor[~unordered_multimap]();
unordered_multimap& xref:#unordered_multimap_copy_assignment[operator++=++](const unordered_multimap& other); unordered_multimap& xref:#unordered_multimap_copy_assignment[operator++=++](const unordered_multimap& other);
@ -76,7 +76,7 @@ namespace boost {
noexcept(boost::allocator_traits<Allocator>::is_always_equal::value && noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> && boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>); boost::is_nothrow_move_assignable_v<Pred>);
unordered_multimap& xref:#unordered_multimap_initializer_list_assignment[operator++=++](initializer_list<value_type> il); unordered_multimap& xref:#unordered_multimap_initializer_list_assignment[operator++=++](std::initializer_list<value_type> il);
allocator_type xref:#unordered_multimap_get_allocator[get_allocator]() const noexcept; allocator_type xref:#unordered_multimap_get_allocator[get_allocator]() const noexcept;
// iterators // iterators
@ -102,7 +102,7 @@ namespace boost {
iterator xref:#unordered_multimap_move_insert_with_hint[insert](const_iterator hint, value_type&& obj); iterator xref:#unordered_multimap_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
template<class P> iterator xref:#unordered_multimap_emplace_insert_with_hint[insert](const_iterator hint, P&& obj); template<class P> iterator xref:#unordered_multimap_emplace_insert_with_hint[insert](const_iterator hint, P&& obj);
template<class InputIterator> void xref:#unordered_multimap_insert_iterator_range[insert](InputIterator first, InputIterator last); template<class InputIterator> void xref:#unordered_multimap_insert_iterator_range[insert](InputIterator first, InputIterator last);
void xref:#unordered_multimap_insert_initializer_list[insert](initializer_list<value_type> il); void xref:#unordered_multimap_insert_initializer_list[insert](std::initializer_list<value_type> il);
node_type xref:#unordered_multimap_extract_by_iterator[extract](const_iterator position); node_type xref:#unordered_multimap_extract_by_iterator[extract](const_iterator position);
node_type xref:#unordered_multimap_extract_by_key[extract](const key_type& k); node_type xref:#unordered_multimap_extract_by_key[extract](const key_type& k);
@ -155,12 +155,12 @@ namespace boost {
bool xref:#unordered_multimap_contains[contains](const key_type& k) const; bool xref:#unordered_multimap_contains[contains](const key_type& k) const;
template<class K> template<class K>
bool xref:#unordered_multimap_contains[contains](const K& k) const; bool xref:#unordered_multimap_contains[contains](const K& k) const;
pair<iterator, iterator> xref:#unordered_multimap_equal_range[equal_range](const key_type& k); std::pair<iterator, iterator> xref:#unordered_multimap_equal_range[equal_range](const key_type& k);
pair<const_iterator, const_iterator> xref:#unordered_multimap_equal_range[equal_range](const key_type& k) const; std::pair<const_iterator, const_iterator> xref:#unordered_multimap_equal_range[equal_range](const key_type& k) const;
template<class K> template<class K>
pair<iterator, iterator> xref:#unordered_multimap_equal_range[equal_range](const K& k); std::pair<iterator, iterator> xref:#unordered_multimap_equal_range[equal_range](const K& k);
template<class K> template<class K>
pair<const_iterator, const_iterator> xref:#unordered_multimap_equal_range[equal_range](const K& k) const; std::pair<const_iterator, const_iterator> xref:#unordered_multimap_equal_range[equal_range](const K& k) const;
// bucket interface // bucket interface
size_type xref:#unordered_multimap_bucket_count[bucket_count]() const noexcept; size_type xref:#unordered_multimap_bucket_count[bucket_count]() const noexcept;
@ -449,7 +449,7 @@ Requires:;; `value_type` is move insertable.
==== Initializer List Constructor ==== Initializer List Constructor
[source,c++,subs="+quotes"] [source,c++,subs="+quotes"]
---- ----
unordered_multimap(initializer_list<value_type> il, unordered_multimap(std::initializer_list<value_type> il,
size_type n = _implementation-defined_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -564,7 +564,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment ==== Initializer List Assignment
```c++ ```c++
unordered_multimap& operator=(initializer_list<value_type> il); unordered_multimap& operator=(std::initializer_list<value_type> il);
``` ```
Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed. Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed.
@ -827,7 +827,7 @@ Pointers and references to elements are never invalidated.
==== Insert Initializer List ==== Insert Initializer List
```c++ ```c++
void insert(initializer_list<value_type> il); void insert(std::initializer_list<value_type> il);
``` ```
Inserts a range of elements into the container. Inserts a range of elements into the container.
@ -1173,12 +1173,12 @@ Notes:;; The `template <typename K>` overload only participates in overload reso
==== equal_range ==== equal_range
```c++ ```c++
pair<iterator, iterator> equal_range(const key_type& k); std::pair<iterator, iterator> equal_range(const key_type& k);
pair<const_iterator, const_iterator> equal_range(const key_type& k) const; std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
template<class K> template<class K>
pair<iterator, iterator> equal_range(const K& k); std::pair<iterator, iterator> equal_range(const K& k);
template<class K> template<class K>
pair<const_iterator, const_iterator> equal_range(const K& k) const; std::pair<const_iterator, const_iterator> equal_range(const K& k) const;
``` ```
[horizontal] [horizontal]

12
doc/unordered/unordered_multiset.adoc
View File

@ -54,7 +54,7 @@ namespace boost {
explicit xref:#unordered_multiset_allocator_constructor[unordered_multiset](const Allocator& a); explicit xref:#unordered_multiset_allocator_constructor[unordered_multiset](const Allocator& a);
xref:#unordered_multiset_copy_constructor_with_allocator[unordered_multiset](const unordered_multiset& other, const Allocator& a); xref:#unordered_multiset_copy_constructor_with_allocator[unordered_multiset](const unordered_multiset& other, const Allocator& a);
xref:#unordered_multiset_move_constructor_with_allocator[unordered_multiset](unordered_multiset&& other, const Allocator& a); xref:#unordered_multiset_move_constructor_with_allocator[unordered_multiset](unordered_multiset&& other, const Allocator& a);
xref:#unordered_multiset_initializer_list_constructor[unordered_multiset](initializer_list<value_type> il, xref:#unordered_multiset_initializer_list_constructor[unordered_multiset](std::initializer_list<value_type> il,
size_type n = _implementation-defined_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -72,7 +72,7 @@ namespace boost {
noexcept(boost::allocator_traits<Allocator>::is_always_equal::value && noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> && boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>); boost::is_nothrow_move_assignable_v<Pred>);
unordered_multiset& xref:#unordered_multiset_initializer_list_assignment[operator++=++](initializer_list<value_type> il); unordered_multiset& xref:#unordered_multiset_initializer_list_assignment[operator++=++](std::initializer_list<value_type> il);
allocator_type xref:#unordered_multiset_get_allocator[get_allocator]() const noexcept; allocator_type xref:#unordered_multiset_get_allocator[get_allocator]() const noexcept;
// iterators // iterators
@ -96,7 +96,7 @@ namespace boost {
iterator xref:#unordered_multiset_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj); iterator xref:#unordered_multiset_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj);
iterator xref:#unordered_multiset_move_insert_with_hint[insert](const_iterator hint, value_type&& obj); iterator xref:#unordered_multiset_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
template<class InputIterator> void xref:#unordered_multiset_insert_iterator_range[insert](InputIterator first, InputIterator last); template<class InputIterator> void xref:#unordered_multiset_insert_iterator_range[insert](InputIterator first, InputIterator last);
void xref:#unordered_multiset_insert_initializer_list[insert](initializer_list<value_type> il); void xref:#unordered_multiset_insert_initializer_list[insert](std::initializer_list<value_type> il);
node_type xref:#unordered_multiset_extract_by_iterator[extract](const_iterator position); node_type xref:#unordered_multiset_extract_by_iterator[extract](const_iterator position);
node_type xref:#unordered_multiset_extract_by_value[extract](const key_type& k); node_type xref:#unordered_multiset_extract_by_value[extract](const key_type& k);
@ -440,7 +440,7 @@ Requires:;; `value_type` is move insertable.
==== Initializer List Constructor ==== Initializer List Constructor
[source,c++,subs="+quotes"] [source,c++,subs="+quotes"]
---- ----
unordered_multiset(initializer_list<value_type> il, unordered_multiset(std::initializer_list<value_type> il,
size_type n = _implementation-defined_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -556,7 +556,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment ==== Initializer List Assignment
```c++ ```c++
unordered_multiset& operator=(initializer_list<value_type> il); unordered_multiset& operator=(std::initializer_list<value_type> il);
``` ```
Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed. Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed.
@ -787,7 +787,7 @@ Pointers and references to elements are never invalidated.
==== Insert Initializer List ==== Insert Initializer List
```c++ ```c++
void insert(initializer_list<value_type> il); void insert(std::initializer_list<value_type> il);
``` ```
Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key. Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key.

30
doc/unordered/unordered_set.adoc
View File

@ -55,7 +55,7 @@ namespace boost {
explicit xref:#unordered_set_allocator_constructor[unordered_set](const Allocator& a); explicit xref:#unordered_set_allocator_constructor[unordered_set](const Allocator& a);
xref:#unordered_set_copy_constructor_with_allocator[unordered_set](const unordered_set& other, const Allocator& a); xref:#unordered_set_copy_constructor_with_allocator[unordered_set](const unordered_set& other, const Allocator& a);
xref:#unordered_set_move_constructor_with_allocator[unordered_set](unordered_set&& other, const Allocator& a); xref:#unordered_set_move_constructor_with_allocator[unordered_set](unordered_set&& other, const Allocator& a);
xref:#unordered_set_initializer_list_constructor[unordered_set](initializer_list<value_type> il, xref:#unordered_set_initializer_list_constructor[unordered_set](std::initializer_list<value_type> il,
size_type n = _implementation-defined_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -73,7 +73,7 @@ namespace boost {
noexcept(boost::allocator_traits<Allocator>::is_always_equal::value && noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
boost::is_nothrow_move_assignable_v<Hash> && boost::is_nothrow_move_assignable_v<Hash> &&
boost::is_nothrow_move_assignable_v<Pred>); boost::is_nothrow_move_assignable_v<Pred>);
unordered_set& xref:#unordered_set_initializer_list_assignment[operator++=++](initializer_list<value_type> il); unordered_set& xref:#unordered_set_initializer_list_assignment[operator++=++](std::initializer_list<value_type> il);
allocator_type xref:#unordered_set_get_allocator[get_allocator]() const noexcept; allocator_type xref:#unordered_set_get_allocator[get_allocator]() const noexcept;
// iterators // iterators
@ -97,7 +97,7 @@ namespace boost {
iterator xref:#unordered_set_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj); iterator xref:#unordered_set_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj);
iterator xref:#unordered_set_move_insert_with_hint[insert](const_iterator hint, value_type&& obj); iterator xref:#unordered_set_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
template<class InputIterator> void xref:#unordered_set_insert_iterator_range[insert](InputIterator first, InputIterator last); template<class InputIterator> void xref:#unordered_set_insert_iterator_range[insert](InputIterator first, InputIterator last);
void xref:#unordered_set_insert_initializer_list[insert](initializer_list<value_type>); void xref:#unordered_set_insert_initializer_list[insert](std::initializer_list<value_type>);
node_type xref:#unordered_set_extract_by_iterator[extract](const_iterator position); node_type xref:#unordered_set_extract_by_iterator[extract](const_iterator position);
node_type xref:#unordered_set_extract_by_value[extract](const key_type& k); node_type xref:#unordered_set_extract_by_value[extract](const key_type& k);
@ -150,12 +150,12 @@ namespace boost {
bool xref:#unordered_set_contains[contains](const key_type& k) const; bool xref:#unordered_set_contains[contains](const key_type& k) const;
template<class K> template<class K>
bool xref:#unordered_set_contains[contains](const K& k) const; bool xref:#unordered_set_contains[contains](const K& k) const;
pair<iterator, iterator> xref:#unordered_set_equal_range[equal_range](const key_type& k); std::pair<iterator, iterator> xref:#unordered_set_equal_range[equal_range](const key_type& k);
pair<const_iterator, const_iterator> xref:#unordered_set_equal_range[equal_range](const key_type& k) const; std::pair<const_iterator, const_iterator> xref:#unordered_set_equal_range[equal_range](const key_type& k) const;
template<class K> template<class K>
pair<iterator, iterator> xref:#unordered_set_equal_range[equal_range](const K& k); std::pair<iterator, iterator> xref:#unordered_set_equal_range[equal_range](const K& k);
template<class K> template<class K>
pair<const_iterator, const_iterator> xref:#unordered_set_equal_range[equal_range](const K& k) const; std::pair<const_iterator, const_iterator> xref:#unordered_set_equal_range[equal_range](const K& k) const;
// bucket interface // bucket interface
size_type xref:#unordered_set_bucket_count[bucket_count]() const noexcept; size_type xref:#unordered_set_bucket_count[bucket_count]() const noexcept;
@ -451,7 +451,7 @@ Requires:;; `value_type` is move insertable.
==== Initializer List Constructor ==== Initializer List Constructor
[source,c++,subs="+quotes"] [source,c++,subs="+quotes"]
---- ----
unordered_set(initializer_list<value_type> il, unordered_set(std::initializer_list<value_type> il,
size_type n = _implementation-defined_, size_type n = _implementation-defined_,
const hasher& hf = hasher(), const hasher& hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& eql = key_equal(),
@ -567,7 +567,7 @@ Requires:;; `value_type` is move constructible.
==== Initializer List Assignment ==== Initializer List Assignment
```c++ ```c++
unordered_set& operator=(initializer_list<value_type> il); unordered_set& operator=(std::initializer_list<value_type> il);
``` ```
Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed. Assign from values in initializer list. All existing elements are either overwritten by the new elements or destroyed.
@ -660,7 +660,7 @@ Returns:;; `size()` of the largest possible container.
==== emplace ==== emplace
```c++ ```c++
template<class... Args> pair<iterator, bool> emplace(Args&&... args); template<class... Args> std::pair<iterator, bool> emplace(Args&&... args);
``` ```
Inserts an object, constructed with the arguments `args`, in the container if and only if there is no element in the container with an equivalent value. Inserts an object, constructed with the arguments `args`, in the container if and only if there is no element in the container with an equivalent value.
@ -803,7 +803,7 @@ Pointers and references to elements are never invalidated.
==== Insert Initializer List ==== Insert Initializer List
```c++ ```c++
void insert(initializer_list<value_type>); void insert(std::initializer_list<value_type>);
``` ```
Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key. Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key.
@ -1156,12 +1156,12 @@ Notes:;; The `template <typename K>` overload only participates in overload reso
==== equal_range ==== equal_range
```c++ ```c++
pair<iterator, iterator> equal_range(const key_type& k); std::pair<iterator, iterator> equal_range(const key_type& k);
pair<const_iterator, const_iterator> equal_range(const key_type& k) const; std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
template<class K> template<class K>
pair<iterator, iterator> equal_range(const K& k); std::pair<iterator, iterator> equal_range(const K& k);
template<class K> template<class K>
pair<const_iterator, const_iterator> equal_range(const K& k) const; std::pair<const_iterator, const_iterator> equal_range(const K& k) const;
``` ```
[horizontal] [horizontal]