|
| | map ()=default |
| template<typename _InputIterator> |
| | map (_InputIterator __first, _InputIterator __last) |
| template<typename _InputIterator> |
| | map (_InputIterator __first, _InputIterator __last, const _Compare &__comp, const allocator_type &__a=allocator_type()) |
| template<typename _InputIterator> |
| | map (_InputIterator __first, _InputIterator __last, const allocator_type &__a) |
| | map (const _Compare &__comp, const allocator_type &__a=allocator_type()) |
| | map (const allocator_type &__a) |
| | map (const map &)=default |
| | map (const map &__m, const __type_identity_t< allocator_type > &__a) |
| | map (initializer_list< value_type > __l, const _Compare &__comp=_Compare(), const allocator_type &__a=allocator_type()) |
| | map (initializer_list< value_type > __l, const allocator_type &__a) |
| | map (map &&)=default |
| | map (map &&__m, const __type_identity_t< allocator_type > &__a) noexcept(is_nothrow_copy_constructible< _Compare >::value &&_Alloc_traits::_S_always_equal()) |
| | ~map ()=default |
| template<__heterogeneous_tree_key< map > _Kt> |
| mapped_type & | at (const _Kt &__k) |
| template<__heterogeneous_tree_key< map > _Kt> |
| const mapped_type & | at (const _Kt &__k) const |
| mapped_type & | at (const key_type &__k) |
| const mapped_type & | at (const key_type &__k) const |
| const_iterator | begin () const noexcept |
| iterator | begin () noexcept |
| const_iterator | cbegin () const noexcept |
| const_iterator | cend () const noexcept |
| void | clear () noexcept |
| const_reverse_iterator | crbegin () const noexcept |
| const_reverse_iterator | crend () const noexcept |
| template<typename... _Args> |
| std::pair< iterator, bool > | emplace (_Args &&... __args) |
| template<typename... _Args> |
| iterator | emplace_hint (const_iterator __pos, _Args &&... __args) |
| bool | empty () const noexcept |
| const_iterator | end () const noexcept |
| iterator | end () noexcept |
| iterator | erase (const_iterator __first, const_iterator __last) |
| allocator_type | get_allocator () const noexcept |
| template<typename _InputIterator> |
| void | insert (_InputIterator __first, _InputIterator __last) |
| void | insert (std::initializer_list< value_type > __list) |
| key_compare | key_comp () const |
| size_type | max_size () const noexcept |
| map & | operator= (const map &)=default |
| map & | operator= (initializer_list< value_type > __l) |
| map & | operator= (map &&)=default |
| template<__heterogeneous_tree_key< map > _Kt> |
| mapped_type & | operator[] (_Kt &&__k) |
| mapped_type & | operator[] (const key_type &__k) |
| mapped_type & | operator[] (key_type &&__k) |
| const_reverse_iterator | rbegin () const noexcept |
| reverse_iterator | rbegin () noexcept |
| const_reverse_iterator | rend () const noexcept |
| reverse_iterator | rend () noexcept |
| size_type | size () const noexcept |
| void | swap (map &__x) noexcept(/*conditional */) |
| value_compare | value_comp () const |
| std::pair< iterator, bool > | insert (const value_type &__x) |
| std::pair< iterator, bool > | insert (value_type &&__x) |
| template<typename _Pair> |
| __enable_if_t< is_constructible< value_type, _Pair >::value, pair< iterator, bool > > | insert (_Pair &&__x) |
| iterator | insert (const_iterator __position, const value_type &__x) |
| iterator | insert (const_iterator __position, value_type &&__x) |
| template<typename _Pair> |
| __enable_if_t< is_constructible< value_type, _Pair >::value, iterator > | insert (const_iterator __position, _Pair &&__x) |
| iterator | erase (const_iterator __position) |
| iterator | erase (iterator __position) |
| size_type | erase (const key_type &__x) |
| template<__heterogeneous_tree_key< map > _Kt> |
| size_type | erase (_Kt &&__x) |
| iterator | find (const key_type &__x) |
| const_iterator | find (const key_type &__x) const |
| size_type | count (const key_type &__x) const |
| bool | contains (const key_type &__x) const |
| template<typename _Kt> |
| auto | contains (const _Kt &__x) const -> decltype(_M_t._M_find_tr(__x), void(), true) |
| iterator | lower_bound (const key_type &__x) |
| const_iterator | lower_bound (const key_type &__x) const |
| iterator | upper_bound (const key_type &__x) |
| const_iterator | upper_bound (const key_type &__x) const |
| std::pair< iterator, iterator > | equal_range (const key_type &__x) |
| std::pair< const_iterator, const_iterator > | equal_range (const key_type &__x) const |
|
|
template<typename _K1, typename _T1, typename _C1, typename _A1> |
| __detail::__synth3way_t< pair< const _K1, _T1 > > | operator<=> (const map< _K1, _T1, _C1, _A1 > &, const map< _K1, _T1, _C1, _A1 > &) |
|
template<typename _K1, typename _T1, typename _C1, typename _A1> |
| bool | operator== (const map< _K1, _T1, _C1, _A1 > &, const map< _K1, _T1, _C1, _A1 > &) |
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>, typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >>
class std::map< _Key, _Tp, _Compare, _Alloc >
A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time.
- Since
- C++98
- Template Parameters
-
| _Key | Type of key objects. |
| _Tp | Type of mapped objects. |
| _Compare | Comparison function object type, defaults to less<_Key>. |
| _Alloc | Allocator type, defaults to allocator<pair<const _Key, _Tp>. |
Meets the requirements of a container, a reversible container, and an associative container (using unique keys). For a map<Key,T> the key_type is Key, the mapped_type is T, and the value_type is std::pair<const Key,T>.
Maps support bidirectional iterators.
The private tree data is declared exactly the same way for map and multimap; the distinction is made entirely in how the tree functions are called (*_unique versus *_equal, same as the standard).
Definition at line 106 of file stl_map.h.
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>, typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >>
template<typename... _Args>
| std::pair< iterator, bool > std::map< _Key, _Tp, _Compare, _Alloc >::emplace |
( |
_Args &&... | __args | ) |
|
|
inline |
Attempts to build and insert a std::pair into the map.
- Parameters
-
| __args | Arguments used to generate a new pair instance (see std::piecewise_contruct for passing arguments to each part of the pair constructor). |
- Returns
- A pair, of which the first element is an iterator that points to the possibly inserted pair, and the second is a bool that is true if the pair was actually inserted.
This function attempts to build and insert a (key, value) pair into the map. A map relies on unique keys and thus a pair is only inserted if its first element (the key) is not already present in the map.
Insertion requires logarithmic time.
Definition at line 649 of file stl_map.h.
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>, typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >>
template<typename... _Args>
| iterator std::map< _Key, _Tp, _Compare, _Alloc >::emplace_hint |
( |
const_iterator | __pos, |
|
|
_Args &&... | __args ) |
|
inline |
Attempts to build and insert a std::pair into the map.
- Parameters
-
| __pos | An iterator that serves as a hint as to where the pair should be inserted. |
| __args | Arguments used to generate a new pair instance (see std::piecewise_contruct for passing arguments to each part of the pair constructor). |
- Returns
- An iterator that points to the element with key of the std::pair built from __args (may or may not be that std::pair).
This function is not concerned about whether the insertion took place, and thus does not return a boolean like the single-argument emplace() does. Note that the first parameter is only a hint and can potentially improve the performance of the insertion process. A bad hint would cause no gains in efficiency.
See https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints for more on hinting.
Insertion requires logarithmic time (if the hint is not taken).
Definition at line 699 of file stl_map.h.
Referenced by std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::emplace(), and std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert().
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>, typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >>
| std::pair< iterator, bool > std::map< _Key, _Tp, _Compare, _Alloc >::insert |
( |
const value_type & | __x | ) |
|
|
inline |
Attempts to insert a std::pair into the map.
- Parameters
-
| __x | Pair to be inserted (see std::make_pair for easy creation of pairs). |
- Returns
- A pair, of which the first element is an iterator that points to the possibly inserted pair, and the second is a bool that is true if the pair was actually inserted.
This function attempts to insert a (key, value) pair into the map. A map relies on unique keys and thus a pair is only inserted if its first element (the key) is not already present in the map.
Insertion requires logarithmic time.
Definition at line 951 of file stl_map.h.
Referenced by std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), and std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::operator[]().
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>, typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >>
| iterator std::map< _Key, _Tp, _Compare, _Alloc >::lower_bound |
( |
const key_type & | __x | ) |
|
|
inline |
Finds the beginning of a subsequence matching given key.
- Parameters
-
| __x | Key of (key, value) pair to be located. |
- Returns
- Iterator pointing to first element equal to or greater than key, or end().
This function returns the first element of a subsequence of elements that matches the given key. If unsuccessful it returns an iterator pointing to the first element that has a greater value than given key or end() if no such element exists.
Definition at line 1503 of file stl_map.h.
Referenced by std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::at(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::emplace(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), and std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::operator[]().
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>, typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >>
| mapped_type & std::map< _Key, _Tp, _Compare, _Alloc >::operator[] |
( |
const key_type & | __k | ) |
|
|
inline |
Subscript (
- Parameters
-
| __k | The key for which data should be retrieved. |
- Returns
- A reference to the data of the (key,data) pair.
Allows for easy lookup with the subscript (
If a heterogeneous key matches a range of elements, the first is chosen.
Lookup requires logarithmic time.
Definition at line 531 of file stl_map.h.
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>, typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >>
| void std::map< _Key, _Tp, _Compare, _Alloc >::swap |
( |
map< _Key, _Tp, _Compare, _Alloc > & | __x | ) |
|
|
inlinenoexcept |
Swaps data with another map.
- Parameters
-
| __x | A map of the same element and allocator types. |
This exchanges the elements between two maps in constant time. (It is only swapping a pointer, an integer, and an instance of the Compare type (which itself is often stateless and empty), so it should be quite fast.) Note that the global std::swap() function is specialized such that std::swap(m1,m2) will feed to this function.
Whether the allocators are swapped depends on the allocator traits.
Definition at line 1367 of file stl_map.h.
1.15.0