[map.overview] (original) (raw)

A map is an associative container that supports unique keys (i.e., contains at most one of each key value) and provides for fast retrieval of values of another type T based on the keys.

The map class supports bidirectional iterators.

Amapalso provides most operations described in [associative.reqmts]for unique keys.

This means that amapsupports thea_uniqoperations in [associative.reqmts]but not thea_eqoperations.

For amap<Key,T>thekey_typeisKeyand thevalue_typeispair<const Key,T>.

Descriptions are provided here only for operations onmapthat are not described in one of those tables or for operations where there is additional semantic information.

namespace std { template<class Key, class T, class Compare = less<Key>,class Allocator = allocator<pair<const Key, T>>> class map { public: using key_type = Key;using mapped_type = T;using value_type = pair<const Key, T>;using key_compare = Compare;using allocator_type = Allocator;using pointer = typename allocator_traits<Allocator>::pointer;using const_pointer = typename allocator_traits<Allocator>::const_pointer;using reference = value_type&;using const_reference = const value_type&;using size_type = implementation-defined; using difference_type = implementation-defined; using iterator = implementation-defined; using const_iterator = implementation-defined; using reverse_iterator = std::reverse_iterator<iterator>;using const_reverse_iterator = std::reverse_iterator<const_iterator>;using node_type = unspecified;using insert_return_type = insert-return-type<iterator, node_type>;class value_compare { protected: Compare comp;constexpr value_compare(Compare c) : comp(c) {} public: constexpr bool operator()(const value_type& x, const value_type& y) const { return comp(x.first, y.first);} };constexpr map() : map(Compare()) { } constexpr explicit map(const Compare& comp, const Allocator& = Allocator());template<class InputIterator> constexpr map(InputIterator first, InputIterator last,const Compare& comp = Compare(), const Allocator& = Allocator());template<container-compatible-range<value_type> R> constexpr map(from_range_t, R&& rg, const Compare& comp = Compare(),const Allocator& = Allocator());constexpr map(const map& x);constexpr map(map&& x);explicit map(const Allocator&);constexpr map(const map&, const type_identity_t<Allocator>&);constexpr map(map&&, const type_identity_t<Allocator>&);constexpr map(initializer_list<value_type>, const Compare& = Compare(),const Allocator& = Allocator());template<class InputIterator> constexpr map(InputIterator first, InputIterator last, const Allocator& a) : map(first, last, Compare(), a) { } template<container-compatible-range<value_type> R> constexpr map(from_range_t, R&& rg, const Allocator& a)) : map(from_range, std::forward<R>(rg), Compare(), a) { } constexpr map(initializer_list<value_type> il, const Allocator& a) : map(il, Compare(), a) { } constexpr ~map();constexpr map& operator=(const map& x);constexpr map& operator=(map&& x) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_move_assignable_v<Compare>);constexpr map& operator=(initializer_list<value_type>);constexpr allocator_type get_allocator() const noexcept;constexpr iterator begin() noexcept;constexpr const_iterator begin() const noexcept;constexpr iterator end() noexcept;constexpr const_iterator end() const noexcept;constexpr reverse_iterator rbegin() noexcept;constexpr const_reverse_iterator rbegin() const noexcept;constexpr reverse_iterator rend() noexcept;constexpr const_reverse_iterator rend() const noexcept;constexpr const_iterator cbegin() const noexcept;constexpr const_iterator cend() const noexcept;constexpr const_reverse_iterator crbegin() const noexcept;constexpr const_reverse_iterator crend() const noexcept;constexpr bool empty() const noexcept;constexpr size_type size() const noexcept;constexpr size_type max_size() const noexcept;constexpr mapped_type& operator[](const key_type& x);constexpr mapped_type& operator[](key_type&& x);template<class K> constexpr mapped_type& operator[](K&& x);constexpr mapped_type& at(const key_type& x);constexpr const mapped_type& at(const key_type& x) const;template<class K> constexpr mapped_type& at(const K& x);template<class K> constexpr const mapped_type& at(const K& x) const;template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);template<class... Args> constexpr iterator emplace_hint(const_iterator position, Args&&... args);constexpr pair<iterator, bool> insert(const value_type& x);constexpr pair<iterator, bool> insert(value_type&& x);template<class P> constexpr pair<iterator, bool> insert(P&& x);constexpr iterator insert(const_iterator position, const value_type& x);constexpr iterator insert(const_iterator position, value_type&& x);template<class P> constexpr iterator insert(const_iterator position, P&&);template<class InputIterator> constexpr void insert(InputIterator first, InputIterator last);template<container-compatible-range<value_type> R> constexpr void insert_range(R&& rg);constexpr void insert(initializer_list<value_type>);constexpr node_type extract(const_iterator position);constexpr node_type extract(const key_type& x);template<class K> constexpr node_type extract(K&& x);constexpr insert_return_type insert(node_type&& nh);constexpr iterator insert(const_iterator hint, node_type&& nh);template<class... Args> constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);template<class... Args> constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);template<class K, class... Args> constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);template<class... Args> constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);template<class... Args> constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);template<class K, class... Args> constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);template<class M> constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);template<class M> constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);template<class K, class M> constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);template<class M> constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);template<class M> constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);template<class K, class M> constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);constexpr iterator erase(iterator position);constexpr iterator erase(const_iterator position);constexpr size_type erase(const key_type& x);template<class K> constexpr size_type erase(K&& x);constexpr iterator erase(const_iterator first, const_iterator last);constexpr void swap(map&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_swappable_v<Compare>);constexpr void clear() noexcept;template<class C2> constexpr void merge(map<Key, T, C2, Allocator>& source);template<class C2> constexpr void merge(map<Key, T, C2, Allocator>&& source);template<class C2> constexpr void merge(multimap<Key, T, C2, Allocator>& source);template<class C2> constexpr void merge(multimap<Key, T, C2, Allocator>&& source);constexpr key_compare key_comp() const;constexpr value_compare value_comp() const;constexpr iterator find(const key_type& x);constexpr const_iterator find(const key_type& x) const;template<class K> constexpr iterator find(const K& x);template<class K> constexpr const_iterator find(const K& x) const;constexpr size_type count(const key_type& x) const;template<class K> constexpr size_type count(const K& x) const;constexpr bool contains(const key_type& x) const;template<class K> constexpr bool contains(const K& x) const;constexpr iterator lower_bound(const key_type& x);constexpr const_iterator lower_bound(const key_type& x) const;template<class K> constexpr iterator lower_bound(const K& x);template<class K> constexpr const_iterator lower_bound(const K& x) const;constexpr iterator upper_bound(const key_type& x);constexpr const_iterator upper_bound(const key_type& x) const;template<class K> constexpr iterator upper_bound(const K& x);template<class K> constexpr const_iterator upper_bound(const K& x) const;constexpr pair<iterator, iterator> equal_range(const key_type& x);constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;template<class K> constexpr pair<iterator, iterator> equal_range(const K& x);template<class K> constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;};template<class InputIterator, class Compare = less<_iter-key-type_<InputIterator>>,class Allocator = allocator<_iter-to-alloc-type_<InputIterator>>> map(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator()) -> map<_iter-key-type_<InputIterator>, iter-mapped-type<InputIterator>, Compare, Allocator>;template<ranges::input_range R, class Compare = less<_range-key-type_<R>,class Allocator = allocator<_range-to-alloc-type_<R>>> map(from_range_t, R&&, Compare = Compare(), Allocator = Allocator()) -> map<_range-key-type_<R>, range-mapped-type<R>, Compare, Allocator>;template<class Key, class T, class Compare = less<Key>,class Allocator = allocator<pair<const Key, T>>> map(initializer_list<pair<Key, T>>, Compare = Compare(), Allocator = Allocator()) -> map<Key, T, Compare, Allocator>;template<class InputIterator, class Allocator> map(InputIterator, InputIterator, Allocator) -> map<_iter-key-type_<InputIterator>, iter-mapped-type<InputIterator>, less<_iter-key-type_<InputIterator>>, Allocator>;template<ranges::input_range R, class Allocator> map(from_range_t, R&&, Allocator) -> map<_range-key-type_<R>, range-mapped-type<R>, less<_range-key-type_<R>>, Allocator>;template<class Key, class T, class Allocator> map(initializer_list<pair<Key, T>>, Allocator) -> map<Key, T, less<Key>, Allocator>;}