Заголовок <map> определяет шаблоны классов map и multimap; заголовок <set> определяет шаблоны классов set и multiset.
Следующие шаблоны псевдонимов только для представления могут появляться в руководствах по выводам для ассоциативных контейнеров:
template<class InputIterator> using iter_key_t = remove_const_t< typename iterator_traits<InputIterator>::value_type::first_type>; // exposition only template<class InputIterator> using iter_val_t = typename iterator_traits<InputIterator>::value_type::second_type; // exposition only template<class InputIterator> using iter_to_alloc_t = pair<add_const_t<typename iterator_traits<InputIterator>::value_type::first_type>, typename iterator_traits<InputIterator>::value_type::second_type>; // exposition only
#include <initializer_list> namespace std { // [map], class template map template <class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key, T>>> class map; template <class Key, class T, class Compare, class Allocator> bool operator==(const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator< (const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator!=(const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator> (const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator>=(const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator<=(const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> void swap(map<Key, T, Compare, Allocator>& x, map<Key, T, Compare, Allocator>& y) noexcept(noexcept(x.swap(y))); // [multimap], class template multimap template <class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key, T>>> class multimap; template <class Key, class T, class Compare, class Allocator> bool operator==(const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator< (const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator!=(const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator> (const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator>=(const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator<=(const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> void swap(multimap<Key, T, Compare, Allocator>& x, multimap<Key, T, Compare, Allocator>& y) noexcept(noexcept(x.swap(y))); namespace pmr { template <class Key, class T, class Compare = less<Key>> using map = std::map<Key, T, Compare, polymorphic_allocator<pair<const Key, T>>>; template <class Key, class T, class Compare = less<Key>> using multimap = std::multimap<Key, T, Compare, polymorphic_allocator<pair<const Key, T>>>; } }
#include <initializer_list> namespace std { // [set], class template set template <class Key, class Compare = less<Key>, class Allocator = allocator<Key>> class set; template <class Key, class Compare, class Allocator> bool operator==(const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator< (const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator!=(const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator> (const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator>=(const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator<=(const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> void swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y) noexcept(noexcept(x.swap(y))); // [multiset], class template multiset template <class Key, class Compare = less<Key>, class Allocator = allocator<Key>> class multiset; template <class Key, class Compare, class Allocator> bool operator==(const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator< (const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator!=(const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator> (const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator>=(const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator<=(const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> void swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y) noexcept(noexcept(x.swap(y))); namespace pmr { template <class Key, class Compare = less<Key>> using set = std::set<Key, Compare, polymorphic_allocator<Key>>; template <class Key, class Compare = less<Key>> using multiset = std::multiset<Key, Compare, polymorphic_allocator<Key>>; } }
A map - это ассоциативный контейнер, который поддерживает уникальные ключи (содержит не более одного значения каждого ключа) и обеспечивает быстрое извлечение значений другого типа T на основе ключей. map Класс поддерживает двунаправленные итераторы.
A map удовлетворяет всем требованиям контейнера, reversible контейнера, файла associative containerи файла allocator-aware container. A map также предоставляет большинство операций, описанных [associative.reqmts] для уникальных ключей. Это означает, что a map поддерживает a_uniq операции, [associative.reqmts] но не a_eq операции. Для это и есть . Здесь приведены описания только для операций , не описанных в одной из этих таблиц, или для операций, для которых имеется дополнительная семантическая информация.map<Key,T>key_typeKeyvalue_typepair<const Key,T>map
namespace std { template <class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key, T>>> class map { public: // types: 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; // see [container.requirements] using difference_type = implementation-defined; // see [container.requirements] using iterator = implementation-defined; // see [container.requirements] using const_iterator = implementation-defined; // see [container.requirements] 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 { friend class map; protected: Compare comp; value_compare(Compare c) : comp(c) {} public: bool operator()(const value_type& x, const value_type& y) const { return comp(x.first, y.first); } }; // [map.cons], construct/copy/destroy map() : map(Compare()) { } explicit map(const Compare& comp, const Allocator& = Allocator()); template <class InputIterator> map(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); map(const map& x); map(map&& x); explicit map(const Allocator&); map(const map&, const Allocator&); map(map&&, const Allocator&); map(initializer_list<value_type>, const Compare& = Compare(), const Allocator& = Allocator()); template <class InputIterator> map(InputIterator first, InputIterator last, const Allocator& a) : map(first, last, Compare(), a) { } map(initializer_list<value_type> il, const Allocator& a) : map(il, Compare(), a) { } ~map(); map& operator=(const map& x); map& operator=(map&& x) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_move_assignable_v<Compare>); map& operator=(initializer_list<value_type>); allocator_type get_allocator() const noexcept; // iterators: iterator begin() noexcept; const_iterator begin() const noexcept; iterator end() noexcept; const_iterator end() const noexcept; reverse_iterator rbegin() noexcept; const_reverse_iterator rbegin() const noexcept; reverse_iterator rend() noexcept; const_reverse_iterator rend() const noexcept; const_iterator cbegin() const noexcept; const_iterator cend() const noexcept; const_reverse_iterator crbegin() const noexcept; const_reverse_iterator crend() const noexcept; // capacity: bool empty() const noexcept; size_type size() const noexcept; size_type max_size() const noexcept; // [map.access], element access T& operator[](const key_type& x); T& operator[](key_type&& x); T& at(const key_type& x); const T& at(const key_type& x) const; // [map.modifiers], modifiers template <class... Args> pair<iterator, bool> emplace(Args&&... args); template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& x); pair<iterator, bool> insert(value_type&& x); template <class P> pair<iterator, bool> insert(P&& x); iterator insert(const_iterator position, const value_type& x); iterator insert(const_iterator position, value_type&& x); template <class P> iterator insert(const_iterator position, P&&); template <class InputIterator> void insert(InputIterator first, InputIterator last); void insert(initializer_list<value_type>); node_type extract(const_iterator position); node_type extract(const key_type& x); insert_return_type insert(node_type&& nh); iterator insert(const_iterator hint, node_type&& nh); template <class... Args> pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); template <class... Args> pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); template <class... Args> iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); template <class... Args> iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); template <class M> pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); template <class M> pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); template <class M> iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); template <class M> iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); iterator erase(iterator position); iterator erase(const_iterator position); size_type erase(const key_type& x); iterator erase(const_iterator first, const_iterator last); void swap(map&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_swappable_v<Compare>); void clear() noexcept; template<class C2> void merge(map<Key, T, C2, Allocator>& source); template<class C2> void merge(map<Key, T, C2, Allocator>&& source); template<class C2> void merge(multimap<Key, T, C2, Allocator>& source); template<class C2> void merge(multimap<Key, T, C2, Allocator>&& source); // observers: key_compare key_comp() const; value_compare value_comp() const; // map operations: iterator find(const key_type& x); const_iterator find(const key_type& x) const; template <class K> iterator find(const K& x); template <class K> const_iterator find(const K& x) const; size_type count(const key_type& x) const; template <class K> size_type count(const K& x) const; iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x) const; template <class K> iterator lower_bound(const K& x); template <class K> const_iterator lower_bound(const K& x) const; iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x) const; template <class K> iterator upper_bound(const K& x); template <class K> const_iterator upper_bound(const K& x) const; pair<iterator, iterator> equal_range(const key_type& x); pair<const_iterator, const_iterator> equal_range(const key_type& x) const; template <class K> pair<iterator, iterator> equal_range(const K& x); template <class K> pair<const_iterator, const_iterator> equal_range(const K& x) const; }; template<class InputIterator, class Compare = less<iter_key_t<InputIterator>>, class Allocator = allocator<iter_to_alloc_t<InputIterator>>> map(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator()) -> map<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Compare, Allocator>; template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key, T>>> map(initializer_list<pair<const Key, T>>, Compare = Compare(), Allocator = Allocator()) -> map<Key, T, Compare, Allocator>; template <class InputIterator, class Allocator> map(InputIterator, InputIterator, Allocator) -> map<iter_key_t<InputIterator>, iter_val_t<InputIterator>, less<iter_key_t<InputIterator>>, Allocator>; template<class Key, class T, class Allocator> map(initializer_list<pair<const Key, T>>, Allocator) -> map<Key, T, less<Key>, Allocator>; template <class Key, class T, class Compare, class Allocator> bool operator==(const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator< (const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator!=(const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator> (const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator>=(const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator<=(const map<Key, T, Compare, Allocator>& x, const map<Key, T, Compare, Allocator>& y); // [map.special], specialized algorithms template <class Key, class T, class Compare, class Allocator> void swap(map<Key, T, Compare, Allocator>& x, map<Key, T, Compare, Allocator>& y) noexcept(noexcept(x.swap(y))); }
explicit map(const Compare& comp, const Allocator& = Allocator());
template <class InputIterator>
map(InputIterator first, InputIterator last,
const Compare& comp = Compare(), const Allocator& = Allocator());
Effects: Создает пустой, map используя указанный объект сравнения и распределитель, и вставляет элементы из диапазона [first, last).
T& operator[](const key_type& x);
T& operator[](key_type&& x);
T& at(const key_type& x);
const T& at(const key_type& x) const;
template <class P>
pair<iterator, bool> insert(P&& x);
template <class P>
iterator insert(const_iterator position, P&& x);
Effects: Первая форма эквивалентна return emplace(std::forward<P>(x)). Вторая форма эквивалентна return emplace_hint(position, std::forward<P>(x)).
Remarks: Эти подписи не должны участвовать в разрешении перегрузки , если is_constructible_v<value_type, P&&> не true.
template <class... Args>
pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
template <class... Args>
iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
Requires: value_type должны быть EmplaceConstructible в map с piecewise_construct, forward_as_tuple(k), forward_as_tuple(std::forward<Args>(args)...).
Effects: Если карта уже содержит элемент, ключ которого эквивалентен k, эффекта не будет. В противном случае вставляет объект типа , value_type построенный с piecewise_construct, forward_as_tuple(k), forward_as_tuple(std::forward<Args>(args)...).
Returns: В первой перегрузке bool компонент возвращенной пары есть true тогда и только тогда, когда вставка имела место. Возвращенный итератор указывает на элемент карты, ключ которого эквивалентен k.
template <class... Args>
pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
template <class... Args>
iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
Requires: value_type должны быть EmplaceConstructible в map с piecewise_construct, forward_as_tuple(std::move(k)), forward_as_tuple(std::forward<Args>(args)...).
Effects: Если карта уже содержит элемент, ключ которого эквивалентен k, эффекта не будет. В противном случае вставляет объект типа , value_type построенный с piecewise_construct, forward_as_tuple(std::move(k)), forward_as_tuple(std::forward<Args>(args)...).
Returns: В первой перегрузке bool компонент возвращенной пары есть true тогда и только тогда, когда вставка имела место. Возвращенный итератор указывает на элемент карты, ключ которого эквивалентен k.
template <class M>
pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
template <class M>
iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
Requires: is_assignable_v<mapped_type&, M&&> будет true. value_type должны быть EmplaceConstructible в map с k, forward<M>(obj).
Effects: Если карта уже содержит элемент e , ключ эквивалентен k, правопреемник std::forward<M>(obj) в e.second. В противном случае вставляет объект типа , value_type построенный с k, std::forward<M>(obj).
Returns: В первой перегрузке bool компонент возвращенной пары есть true тогда и только тогда, когда вставка имела место. Возвращенный итератор указывает на элемент карты, ключ которого эквивалентен k.
template <class M>
pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
template <class M>
iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
Requires: is_assignable_v<mapped_type&, M&&> будет true. value_type должны быть EmplaceConstructible в map с move(k), forward<M>(obj).
Effects: Если карта уже содержит элемент e , ключ эквивалентен k, правопреемник std::forward<M>(obj) в e.second. В противном случае вставляет объект типа , value_type построенный с std::move(k), std::forward<M>(obj).
Returns: В первой перегрузке bool компонент возвращенной пары есть true тогда и только тогда, когда вставка имела место. Возвращенный итератор указывает на элемент карты, ключ которого эквивалентен k.
template <class Key, class T, class Compare, class Allocator>
void swap(map<Key, T, Compare, Allocator>& x,
map<Key, T, Compare, Allocator>& y)
noexcept(noexcept(x.swap(y)));
A multimap - это ассоциативный контейнер, который поддерживает эквивалентные ключи (возможно, содержащий несколько копий одного и того же значения ключа) и обеспечивает быстрое извлечение значений другого типа T на основе ключей. multimap Класс поддерживает двунаправленные итераторы.
A multimap удовлетворяет всем требованиям контейнера и reversible контейнера, файла associative containerи файла allocator-aware container. A multimap также предоставляет большинство операций, описанных [associative.reqmts] для одинаковых ключей. Это означает, что a multimap поддерживает a_eq операции, [associative.reqmts] но не a_uniq операции. Для это и есть . Здесь приведены описания только для операций , не описанных в одной из этих таблиц, или для операций, для которых имеется дополнительная семантическая информация.multimap<Key,T>key_typeKeyvalue_typepair<const Key,T>multimap
namespace std { template <class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key, T>>> class multimap { public: // types: 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; // see [container.requirements] using difference_type = implementation-defined; // see [container.requirements] using iterator = implementation-defined; // see [container.requirements] using const_iterator = implementation-defined; // see [container.requirements] using reverse_iterator = std::reverse_iterator<iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>; using node_type = unspecified; class value_compare { friend class multimap; protected: Compare comp; value_compare(Compare c) : comp(c) { } public: bool operator()(const value_type& x, const value_type& y) const { return comp(x.first, y.first); } }; // [multimap.cons], construct/copy/destroy multimap() : multimap(Compare()) { } explicit multimap(const Compare& comp, const Allocator& = Allocator()); template <class InputIterator> multimap(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); multimap(const multimap& x); multimap(multimap&& x); explicit multimap(const Allocator&); multimap(const multimap&, const Allocator&); multimap(multimap&&, const Allocator&); multimap(initializer_list<value_type>, const Compare& = Compare(), const Allocator& = Allocator()); template <class InputIterator> multimap(InputIterator first, InputIterator last, const Allocator& a) : multimap(first, last, Compare(), a) { } multimap(initializer_list<value_type> il, const Allocator& a) : multimap(il, Compare(), a) { } ~multimap(); multimap& operator=(const multimap& x); multimap& operator=(multimap&& x) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_move_assignable_v<Compare>); multimap& operator=(initializer_list<value_type>); allocator_type get_allocator() const noexcept; // iterators: iterator begin() noexcept; const_iterator begin() const noexcept; iterator end() noexcept; const_iterator end() const noexcept; reverse_iterator rbegin() noexcept; const_reverse_iterator rbegin() const noexcept; reverse_iterator rend() noexcept; const_reverse_iterator rend() const noexcept; const_iterator cbegin() const noexcept; const_iterator cend() const noexcept; const_reverse_iterator crbegin() const noexcept; const_reverse_iterator crend() const noexcept; // capacity: bool empty() const noexcept; size_type size() const noexcept; size_type max_size() const noexcept; // [multimap.modifiers], modifiers template <class... Args> iterator emplace(Args&&... args); template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& x); iterator insert(value_type&& x); template <class P> iterator insert(P&& x); iterator insert(const_iterator position, const value_type& x); iterator insert(const_iterator position, value_type&& x); template <class P> iterator insert(const_iterator position, P&& x); template <class InputIterator> void insert(InputIterator first, InputIterator last); void insert(initializer_list<value_type>); node_type extract(const_iterator position); node_type extract(const key_type& x); iterator insert(node_type&& nh); iterator insert(const_iterator hint, node_type&& nh); iterator erase(iterator position); iterator erase(const_iterator position); size_type erase(const key_type& x); iterator erase(const_iterator first, const_iterator last); void swap(multimap&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_swappable_v<Compare>); void clear() noexcept; template<class C2> void merge(multimap<Key, T, C2, Allocator>& source); template<class C2> void merge(multimap<Key, T, C2, Allocator>&& source); template<class C2> void merge(map<Key, T, C2, Allocator>& source); template<class C2> void merge(map<Key, T, C2, Allocator>&& source); // observers: key_compare key_comp() const; value_compare value_comp() const; // map operations: iterator find(const key_type& x); const_iterator find(const key_type& x) const; template <class K> iterator find(const K& x); template <class K> const_iterator find(const K& x) const; size_type count(const key_type& x) const; template <class K> size_type count(const K& x) const; iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x) const; template <class K> iterator lower_bound(const K& x); template <class K> const_iterator lower_bound(const K& x) const; iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x) const; template <class K> iterator upper_bound(const K& x); template <class K> const_iterator upper_bound(const K& x) const; pair<iterator, iterator> equal_range(const key_type& x); pair<const_iterator, const_iterator> equal_range(const key_type& x) const; template <class K> pair<iterator, iterator> equal_range(const K& x); template <class K> pair<const_iterator, const_iterator> equal_range(const K& x) const; }; template<class InputIterator, class Compare = less<iter_key_t<InputIterator>>, class Allocator = allocator<iter_to_alloc_t<InputIterator>>> multimap(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator()) -> multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Compare, Allocator>; template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key, T>>> multimap(initializer_list<pair<const Key, T>>, Compare = Compare(), Allocator = Allocator()) -> multimap<Key, T, Compare, Allocator>; template<class InputIterator, class Allocator> multimap(InputIterator, InputIterator, Allocator) -> multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>, less<iter_key_t<InputIterator>>, Allocator>; template<class Key, class T, class Allocator> multimap(initializer_list<pair<const Key, T>>, Allocator) -> multimap<Key, T, less<Key>, Allocator>; template <class Key, class T, class Compare, class Allocator> bool operator==(const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator< (const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator!=(const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator> (const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator>=(const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); template <class Key, class T, class Compare, class Allocator> bool operator<=(const multimap<Key, T, Compare, Allocator>& x, const multimap<Key, T, Compare, Allocator>& y); // [multimap.special], specialized algorithms template <class Key, class T, class Compare, class Allocator> void swap(multimap<Key, T, Compare, Allocator>& x, multimap<Key, T, Compare, Allocator>& y) noexcept(noexcept(x.swap(y))); }
explicit multimap(const Compare& comp, const Allocator& = Allocator());
template <class InputIterator>
multimap(InputIterator first, InputIterator last,
const Compare& comp = Compare(),
const Allocator& = Allocator());
Effects: Создает пустой, multimap используя указанный объект сравнения и распределитель, и вставляет элементы из диапазона [first, last).
template <class P> iterator insert(P&& x);
template <class P> iterator insert(const_iterator position, P&& x);
Effects: Первая форма эквивалентна return emplace(std::forward<P>(x)). Вторая форма эквивалентна return emplace_hint(position, std::forward<P>(x)).
template <class Key, class T, class Compare, class Allocator>
void swap(multimap<Key, T, Compare, Allocator>& x,
multimap<Key, T, Compare, Allocator>& y)
noexcept(noexcept(x.swap(y)));
A set - это ассоциативный контейнер, который поддерживает уникальные ключи (содержит не более одного значения каждого ключа) и обеспечивает быстрое извлечение самих ключей. set Класс поддерживает двунаправленные итераторы.
A set удовлетворяет всем требованиям контейнера, reversible контейнера, файла associative containerи файла allocator-aware container. A set также предоставляет большинство операций, описанных [associative.reqmts] для уникальных ключей. Это означает, что a set поддерживает a_uniq операции, [associative.reqmts] но не a_eq операции. Для set<Key> как key_type и value_type есть Key. Здесь описаны только операции set , не описанные в одной из этих таблиц, а также операции, для которых имеется дополнительная семантическая информация.
namespace std { template <class Key, class Compare = less<Key>, class Allocator = allocator<Key>> class set { public: // types: using key_type = Key; using key_compare = Compare; using value_type = Key; using value_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; // see [container.requirements] using difference_type = implementation-defined; // see [container.requirements] using iterator = implementation-defined; // see [container.requirements] using const_iterator = implementation-defined; // see [container.requirements] 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>; // [set.cons], construct/copy/destroy set() : set(Compare()) { } explicit set(const Compare& comp, const Allocator& = Allocator()); template <class InputIterator> set(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); set(const set& x); set(set&& x); explicit set(const Allocator&); set(const set&, const Allocator&); set(set&&, const Allocator&); set(initializer_list<value_type>, const Compare& = Compare(), const Allocator& = Allocator()); template <class InputIterator> set(InputIterator first, InputIterator last, const Allocator& a) : set(first, last, Compare(), a) { } set(initializer_list<value_type> il, const Allocator& a) : set(il, Compare(), a) { } ~set(); set& operator=(const set& x); set& operator=(set&& x) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_move_assignable_v<Compare>); set& operator=(initializer_list<value_type>); allocator_type get_allocator() const noexcept; // iterators: iterator begin() noexcept; const_iterator begin() const noexcept; iterator end() noexcept; const_iterator end() const noexcept; reverse_iterator rbegin() noexcept; const_reverse_iterator rbegin() const noexcept; reverse_iterator rend() noexcept; const_reverse_iterator rend() const noexcept; const_iterator cbegin() const noexcept; const_iterator cend() const noexcept; const_reverse_iterator crbegin() const noexcept; const_reverse_iterator crend() const noexcept; // capacity: bool empty() const noexcept; size_type size() const noexcept; size_type max_size() const noexcept; // modifiers: template <class... Args> pair<iterator, bool> emplace(Args&&... args); template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator,bool> insert(const value_type& x); pair<iterator,bool> insert(value_type&& x); iterator insert(const_iterator position, const value_type& x); iterator insert(const_iterator position, value_type&& x); template <class InputIterator> void insert(InputIterator first, InputIterator last); void insert(initializer_list<value_type>); node_type extract(const_iterator position); node_type extract(const key_type& x); insert_return_type insert(node_type&& nh); iterator insert(const_iterator hint, node_type&& nh); iterator erase(iterator position); iterator erase(const_iterator position); size_type erase(const key_type& x); iterator erase(const_iterator first, const_iterator last); void swap(set&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_swappable_v<Compare>); void clear() noexcept; template<class C2> void merge(set<Key, C2, Allocator>& source); template<class C2> void merge(set<Key, C2, Allocator>&& source); template<class C2> void merge(multiset<Key, C2, Allocator>& source); template<class C2> void merge(multiset<Key, C2, Allocator>&& source); // observers: key_compare key_comp() const; value_compare value_comp() const; // set operations: iterator find(const key_type& x); const_iterator find(const key_type& x) const; template <class K> iterator find(const K& x); template <class K> const_iterator find(const K& x) const; size_type count(const key_type& x) const; template <class K> size_type count(const K& x) const; iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x) const; template <class K> iterator lower_bound(const K& x); template <class K> const_iterator lower_bound(const K& x) const; iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x) const; template <class K> iterator upper_bound(const K& x); template <class K> const_iterator upper_bound(const K& x) const; pair<iterator, iterator> equal_range(const key_type& x); pair<const_iterator, const_iterator> equal_range(const key_type& x) const; template <class K> pair<iterator, iterator> equal_range(const K& x); template <class K> pair<const_iterator, const_iterator> equal_range(const K& x) const; }; template<class InputIterator, class Compare = less<typename iterator_traits<InputIterator>::value_type>, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> set(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator()) -> set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>> set(initializer_list<Key>, Compare = Compare(), Allocator = Allocator()) -> set<Key, Compare, Allocator>; template<class InputIterator, class Allocator> set(InputIterator, InputIterator, Allocator) -> set<typename iterator_traits<InputIterator>::value_type, less<typename iterator_traits<InputIterator>::value_type>, Allocator>; template<class Key, class Allocator> set(initializer_list<Key>, Allocator) -> set<Key, less<Key>, Allocator>; template <class Key, class Compare, class Allocator> bool operator==(const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator< (const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator!=(const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator> (const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator>=(const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator<=(const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y); // [set.special], specialized algorithms template <class Key, class Compare, class Allocator> void swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y) noexcept(noexcept(x.swap(y))); }
explicit set(const Compare& comp, const Allocator& = Allocator());
template <class InputIterator>
set(InputIterator first, InputIterator last,
const Compare& comp = Compare(), const Allocator& = Allocator());
Effects: Создает пустой, set используя указанный объект сравнения и распределитель, и вставляет элементы из диапазона [first, last).
template <class Key, class Compare, class Allocator>
void swap(set<Key, Compare, Allocator>& x,
set<Key, Compare, Allocator>& y)
noexcept(noexcept(x.swap(y)));
A multiset - это ассоциативный контейнер, который поддерживает эквивалентные ключи (возможно, содержит несколько копий одного и того же значения ключа) и обеспечивает быстрое извлечение самих ключей. multiset Класс поддерживает двунаправленные итераторы.
A multiset удовлетворяет всем требованиям контейнера, reversible контейнера, файла associative containerи файла allocator-aware container. multiset также предоставляет большинство операций, описанных [associative.reqmts] для повторяющихся ключей. Это означает, что a multiset поддерживает a_eq операции, [associative.reqmts] но не a_uniq операции. Для multiset<Key> как key_type и value_type есть Key. Здесь описаны только операции multiset , не описанные в одной из этих таблиц, а также операции, для которых имеется дополнительная семантическая информация.
namespace std { template <class Key, class Compare = less<Key>, class Allocator = allocator<Key>> class multiset { public: // types: using key_type = Key; using key_compare = Compare; using value_type = Key; using value_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; // see [container.requirements] using difference_type = implementation-defined; // see [container.requirements] using iterator = implementation-defined; // see [container.requirements] using const_iterator = implementation-defined; // see [container.requirements] using reverse_iterator = std::reverse_iterator<iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>; using node_type = unspecified; // [multiset.cons], construct/copy/destroy multiset() : multiset(Compare()) { } explicit multiset(const Compare& comp, const Allocator& = Allocator()); template <class InputIterator> multiset(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); multiset(const multiset& x); multiset(multiset&& x); explicit multiset(const Allocator&); multiset(const multiset&, const Allocator&); multiset(multiset&&, const Allocator&); multiset(initializer_list<value_type>, const Compare& = Compare(), const Allocator& = Allocator()); template <class InputIterator> multiset(InputIterator first, InputIterator last, const Allocator& a) : multiset(first, last, Compare(), a) { } multiset(initializer_list<value_type> il, const Allocator& a) : multiset(il, Compare(), a) { } ~multiset(); multiset& operator=(const multiset& x); multiset& operator=(multiset&& x) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_move_assignable_v<Compare>); multiset& operator=(initializer_list<value_type>); allocator_type get_allocator() const noexcept; // iterators: iterator begin() noexcept; const_iterator begin() const noexcept; iterator end() noexcept; const_iterator end() const noexcept; reverse_iterator rbegin() noexcept; const_reverse_iterator rbegin() const noexcept; reverse_iterator rend() noexcept; const_reverse_iterator rend() const noexcept; const_iterator cbegin() const noexcept; const_iterator cend() const noexcept; const_reverse_iterator crbegin() const noexcept; const_reverse_iterator crend() const noexcept; // capacity: bool empty() const noexcept; size_type size() const noexcept; size_type max_size() const noexcept; // modifiers: template <class... Args> iterator emplace(Args&&... args); template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& x); iterator insert(value_type&& x); iterator insert(const_iterator position, const value_type& x); iterator insert(const_iterator position, value_type&& x); template <class InputIterator> void insert(InputIterator first, InputIterator last); void insert(initializer_list<value_type>); node_type extract(const_iterator position); node_type extract(const key_type& x); iterator insert(node_type&& nh); iterator insert(const_iterator hint, node_type&& nh); iterator erase(iterator position); iterator erase(const_iterator position); size_type erase(const key_type& x); iterator erase(const_iterator first, const_iterator last); void swap(multiset&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_swappable_v<Compare>); void clear() noexcept; template<class C2> void merge(multiset<Key, C2, Allocator>& source); template<class C2> void merge(multiset<Key, C2, Allocator>&& source); template<class C2> void merge(set<Key, C2, Allocator>& source); template<class C2> void merge(set<Key, C2, Allocator>&& source); // observers: key_compare key_comp() const; value_compare value_comp() const; // set operations: iterator find(const key_type& x); const_iterator find(const key_type& x) const; template <class K> iterator find(const K& x); template <class K> const_iterator find(const K& x) const; size_type count(const key_type& x) const; template <class K> size_type count(const K& x) const; iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x) const; template <class K> iterator lower_bound(const K& x); template <class K> const_iterator lower_bound(const K& x) const; iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x) const; template <class K> iterator upper_bound(const K& x); template <class K> const_iterator upper_bound(const K& x) const; pair<iterator, iterator> equal_range(const key_type& x); pair<const_iterator, const_iterator> equal_range(const key_type& x) const; template <class K> pair<iterator, iterator> equal_range(const K& x); template <class K> pair<const_iterator, const_iterator> equal_range(const K& x) const; }; template<class InputIterator, class Compare = less<typename iterator_traits<InputIterator>::value_type>, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> multiset(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator()) -> multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>> multiset(initializer_list<Key>, Compare = Compare(), Allocator = Allocator()) -> multiset<Key, Compare, Allocator>; template<class InputIterator, class Allocator> multiset(InputIterator, InputIterator, Allocator) -> multiset<typename iterator_traits<InputIterator>::value_type, less<typename iterator_traits<InputIterator>::value_type>, Allocator>; template<class Key, class Allocator> multiset(initializer_list<Key>, Allocator) -> multiset<Key, less<Key>, Allocator>; template <class Key, class Compare, class Allocator> bool operator==(const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator< (const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator!=(const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator> (const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator>=(const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); template <class Key, class Compare, class Allocator> bool operator<=(const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y); // [multiset.special], specialized algorithms template <class Key, class Compare, class Allocator> void swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y) noexcept(noexcept(x.swap(y))); }
explicit multiset(const Compare& comp, const Allocator& = Allocator());
template <class InputIterator>
multiset(InputIterator first, InputIterator last,
const Compare& comp = Compare(), const Allocator& = Allocator());
Effects: Создает пустой, multiset используя указанный объект сравнения и распределитель, и вставляет элементы из диапазона [first, last).
template <class Key, class Compare, class Allocator>
void swap(multiset<Key, Compare, Allocator>& x,
multiset<Key, Compare, Allocator>& y)
noexcept(noexcept(x.swap(y)));