Standard library header <map>
From cppreference.net
このヘッダは containers ライブラリの一部です。
インクルード |
||
|
(C++20)
|
三方比較演算子 サポート | |
|
(C++11)
|
std::initializer_list クラステンプレート | |
クラス |
||
|
キーと値のペアのコレクション、キーでソートされ、キーは一意
(クラステンプレート) |
||
|
キーと値のペアのコレクション、キーでソート
(クラステンプレート) |
||
関数 |
||
|
(C++20で削除)
(C++20で削除)
(C++20で削除)
(C++20で削除)
(C++20で削除)
(C++20)
|
2つの
map
の値を辞書順で比較する
(関数テンプレート) |
|
|
std::swap
アルゴリズムを特殊化
(関数テンプレート) |
||
|
(C++20)
|
特定の条件を満たすすべての要素を削除する
(関数テンプレート) |
|
|
(C++20で削除)
(C++20で削除)
(C++20で削除)
(C++20で削除)
(C++20で削除)
(C++20)
|
2つの
multimap
の値を辞書順で比較する
(関数テンプレート) |
|
|
std::swap
アルゴリズムを特殊化
(関数テンプレート) |
||
|
(C++20)
|
特定の条件を満たす全ての要素を削除する
(関数テンプレート) |
|
レンジアクセス |
||
|
(C++11)
(C++14)
|
コンテナまたは配列の先頭を指すイテレータを返す
(関数テンプレート) |
|
|
(C++11)
(C++14)
|
コンテナまたは配列の終端を指すイテレータを返す
(関数テンプレート) |
|
|
(C++14)
|
コンテナまたは配列の先頭への逆方向イテレータを返す
(関数テンプレート) |
|
|
(C++14)
|
コンテナまたは配列の逆方向終端イテレータを返す
(関数テンプレート) |
|
|
(C++17)
(C++20)
|
コンテナまたは配列のサイズを返す
(関数テンプレート) |
|
|
(C++17)
|
コンテナが空かどうかをチェックする
(関数テンプレート) |
|
|
(C++17)
|
基となる配列へのポインタを取得する
(関数テンプレート) |
|
概要
#include <compare> #include <initializer_list> namespace std { // クラステンプレート 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> /*synth-three-way-result*/<pair<const Key, T>> 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))); // map のための消去機能 template<class Key, class T, class Compare, class Allocator, class Predicate> typename map<Key, T, Compare, Allocator>::size_type erase_if( map<Key, T, Compare, Allocator>& c, Predicate pred); // クラステンプレート 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> /*synth-three-way-result*/<pair<const Key, T>> 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))); // multimap のための消去機能 template<class Key, class T, class Compare, class Allocator, class Predicate> typename multimap<Key, T, Compare, Allocator>::size_type erase_if( multimap<Key, T, Compare, Allocator>& c, Predicate pred); 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>>>; } }
クラステンプレート std::map
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>::ポインタ;
using const_pointer = typename allocator_traits<Allocator>::const_pointer;
using reference = value_type&;
using const_reference = const value_type&;
using size_type = /* 実装定義 */;
using difference_type = /* 実装定義 */;
using iterator = /* 実装定義 */;
using const_iterator = /* 実装定義 */;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using node_type = /* 未指定 */;
using insert_return_type = /*insert-return-type*/<iterator, node_type>;
class value_compare
{
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()
: map(Compare())
{
}
explicit map(const Compare& comp, const Allocator& = Allocator());
template<class InputIter>
map(InputIter first,
InputIter last,
const Compare& comp = Compare(),
const Allocator& = Allocator());
template<container-compatible-range<value_type> R>
map(from_range_t,
R&& rg,
const Compare& comp = Compare(),
const Allocator& = Allocator());
map(const map& x);
map(map&& x);
explicit map(const Allocator&);
map(const map&, const type_identity_t<Allocator>&);
map(map&&, const type_identity_t<Allocator>&);
map(initializer_list<value_type>,
const Compare& = Compare(),
const Allocator& = Allocator());
template<class InputIter>
map(InputIter first, InputIter last, const Allocator& a)
: map(first, last, Compare(), a)
{
}
template<container-compatible-range<value_type> R>
map(from_range_t, R&& rg, const Allocator& a))
: map(from_range, std::forward<R>(rg), 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;
// イテレータ
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;
// 要素アクセス
mapped_type& operator[](const key_type& x);
mapped_type& operator[](key_type&& x);
template<class K>
mapped_type& operator[](K&& x);
mapped_type& at(const key_type& x);
const mapped_type& at(const key_type& x) const;
template<class K>
mapped_type& at(const K& x);
template<class K>
const mapped_type& at(const K& x) const;
// 修飾子
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 InputIter>
void insert(InputIter first, InputIter last);
template<container-compatible-range<value_type> R>
void insert_range(R&& rg);
void insert(initializer_list<value_type>);
node_type extract(const_iterator position);
node_type extract(const key_type& x);
template<class K>
node_type extract(K&& 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 K, class... Args>
pair<iterator, bool> try_emplace(K&& 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 K, class... Args>
iterator try_emplace(const_iterator hint, K&& 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 K, class M>
pair<iterator, bool> insert_or_assign(K&& 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);
template<class K, class M>
iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
iterator erase(iterator position);
iterator erase(const_iterator position);
size_type erase(const key_type& x);
template<class K>
size_type erase(K&& 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);
// オブザーバー
key_compare key_comp() const;
value_compare value_comp() const;
// マップ操作
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;
bool contains(const key_type& x) const;
template<class K>
bool contains(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 InputIter,
class Compare = less</*iter-key-type*/<InputIter>>,
class Allocator = allocator</*iter-to-alloc-type*/<InputIter>>>
map(InputIter, InputIter, Compare = Compare(), Allocator = Allocator())
-> map</*iter-key-type*/<InputIter>,
/*iter-mapped-type*/<InputIter>,
Compare,
Allocator>;
template<
ranges::input_range
（注：指定された条件により、HTMLタグ・属性は保持され、C++固有用語は翻訳せず、タグ内のテキストも翻訳対象外のため、元のテキストをそのまま保持しています） 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</*範囲キー型*/<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 InputIter, class Allocator>
map(InputIter, InputIter, Allocator) -> map</*iter-key-type*/<InputIter>,
/*iter-mapped-type*/<InputIter>,
less</*iter-key-type*/<InputIter>>,
Allocator>;
template<ranges::input_range
（注：HTMLタグと属性、C++固有の用語は翻訳対象外のため、元のテキストを保持しています） R, class Allocator>
map(from_range_t, R&&, Allocator) -> map</*range-key-type*/<R>,
/*範囲マップ型*/<R>,
less</*範囲キー型*/<R>>,
Allocator>;
template<class Key, class T, class Allocator>
map(initializer_list<pair<Key, T>>, Allocator) -> map<Key, T, less<Key>, Allocator>;
}
クラステンプレート std::multimap
namespace std { template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key, T>>> class multimap { 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>::ポインタ; using const_pointer = typename allocator_traits<Allocator>::const_pointer; using reference = value_type&; using const_reference = const value_type&; using size_type = /* 実装定義 */; using difference_type = /* 実装定義 */; using iterator = /* 実装定義 */; using const_iterator = /* 実装定義 */; using reverse_iterator = std::reverse_iterator<iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>; using node_type = /* 未指定 */; class value_compare { 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() : multimap(Compare()) { } explicit multimap(const Compare& comp, const Allocator& = Allocator()); template<class InputIter> multimap(InputIter first, InputIter last, const Compare& comp = Compare(), const Allocator& = Allocator()); template<container-compatible-range<value_type> R> multimap(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator()); multimap(const multimap& x); multimap(multimap&& x); explicit multimap(const Allocator&); multimap(const multimap&, const type_identity_t<Allocator>&); multimap(multimap&&, const type_identity_t<Allocator>&); multimap(initializer_list<value_type>, const Compare& = Compare(), const Allocator& = Allocator()); template<class InputIter> multimap(InputIter first, InputIter last, const Allocator& a) : multimap(first, last, Compare(), a) { } template<container-compatible-range<value_type> R> multimap(from_range_t, R&& rg, const Allocator& a)) : multimap(from_range, std::forward<R>(rg), 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; // イテレータ 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; // 修飾子 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 InputIter> void insert(InputIter first, InputIter last); template<container-compatible-range<value_type> R> void insert_range(R&& rg); void insert(initializer_list<value_type>); node_type extract(const_iterator position); node_type extract(const key_type& x); template<class K> node_type extract(K&& 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); template<class K> size_type erase(K&& 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); // オブザーバー key_compare key_comp() const; value_compare value_comp() const; // マップ操作 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; bool contains(const key_type& x) const; template<class K> bool contains(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 InputIter, class Compare = less</*iter-key-type*/<InputIter>>, class Allocator = allocator</*iter-to-alloc-type*/<InputIter>>> multimap(InputIter, InputIter, Compare = Compare(), Allocator = Allocator()) -> multimap</*iter-key-type*/<InputIter>, /*iter-mapped-type*/<InputIter>, Compare, Allocator>; template<ranges::input_range （注：HTMLタグと属性、C++固有の用語は翻訳せず、指定された条件に従って原文のまま保持しています） R, class Compare = less</*範囲キー型*/<R>>, class Allocator = allocator</*range-to-alloc-type*/<R>>> multimap(from_range_t, R&&, Compare = Compare(), Allocator = Allocator()) -> multimap</*range-key-type*/<R>, /*範囲マップ型*/<R>, Compare, Allocator>; template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key, T>>> multimap(initializer_list<pair<Key, T>>, Compare = Compare(), Allocator = Allocator()) -> multimap<Key, T, Compare, Allocator>; template<class InputIter, class Allocator> multimap(InputIter, InputIter, Allocator) -> multimap</*iter-key-type*/<InputIter>, /*iter-mapped-type*/<InputIter>, less</*iter-key-type*/<InputIter>>, Allocator>; template<ranges::input_range （注：HTMLタグ・属性は翻訳せず、C++固有の用語も翻訳していません。原文のフォーマットを保持しています） R, class Allocator> multimap(from_range_t, R&&, Allocator) -> multimap</*range-key-type*/<R>, /*範囲マップ型*/<R>, less</*range-key-type*/<R>>, Allocator>; template<class Key, class T, class Allocator> multimap(initializer_list<pair<Key, T>>, Allocator) -> multimap<Key, T, less<Key>, Allocator>; }
不具合報告
以下の動作変更の欠陥報告書は、以前に公開されたC++規格に対して遡及的に適用されました。
| DR | 適用対象 | 公開時の動作 | 正しい動作 |
|---|---|---|---|
| LWG 133 | C++98 | map::get_allocator が概要説明に欠落していた | 追加された |