プログラミング/C++/C++11 既存ライブラリ変更点/コンテナ のバックアップの現在との差分(No.1)

  • 追加された行はこの色です。
  • 削除された行はこの色です。
C++03規格時点で存在したコンテナライブラリに対するC++11規格での変更点をまとめています。

#contents

*概要 [#about]

当文書では、一般にコンテナと呼ばれる機能を提供するヘッダファイル群と、コンテナとほぼ同等の特徴を持つ [[<string>>#string]] について、C++11規格での変更点をまとめている。~
C++11規格で新規追加されたヘッダファイルについては言及しない。

コンテナクラスは一部を除いてある程度共通のインタフェースを備えており、例えばメンバ関数 @code{begin}; によって先頭要素を指すイテレータを取得できる。~
その関係上C++11規格での変更にも共通点が多いため、それらは[[共通の変更点>#common]]としてまとめている。

コンテナライブラリ自体の変更ではないが、コンテナの仕組みを用いるC++11規格の言語機能として範囲for文（Range-based for）がある。~
あるコンテナクラス型（あるいは固定長配列型）のインスタンス @code{c}; に対し、下記のようなコードで全要素を走査することができる。

#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
for (const auto& value : c)
{
    // do something...
}
}}

*共通の変更点 [#common]

[[<queue>>#queue]] と [[<stack>>#stack]] を除くコンテナライブラリ（[[<string>>#string]] 含む）に共通する変更点は次の通り。~
ここに記載した内容は個々のヘッダファイルの項には記載しない。

-~各クラスにムーブコンストラクタおよびムーブ代入演算子が定義された。
-~各クラスに @code{std::initializer_list<value_type>}; を受け取るコンストラクタおよび代入演算子が定義された。~
これにより、 @code(std::vector<int> v = { 1, 2, 3 };); といった記述によるインスタンスの初期化などが可能になった。
-~各クラスに、第2引数で @code{const allocator_type&}; を受け取るコピーコンストラクタおよびムーブコンストラクタが定義された。~
-~各クラスに下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
const_iterator cbegin() const noexcept;             // begin() const と同じ
const_iterator cend() const noexcept;               // end() const と同じ
const_reverse_iterator crbegin() const noexcept;    // rbegin() const と同じ
const_reverse_iterator crend() const noexcept;      // rend() const と同じ
}}
-~各クラスの下記のメンバ関数に条件式なしの @code{noexcept}; 指定が付与され、例外を投げないことが保証された。
--@code{begin};
--@code{end};
--@code{rbegin};
--@code{rend};
--@code{empty};
--@code{size};
--@code{max_size};
--@code{clear};
--@code{get_allocator};
-~各クラスのメンバ型 @code{reference}; および @code{const_reference}; の定義が下記のように変更され、アロケータ型に依存しなくなった。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
typedef typename allocator_type::reference       reference;
typedef typename allocator_type::const_reference const_reference;
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
typedef value_type&       reference;
typedef const value_type& const_reference;
}}
-~フリー関数 @code{begin}; および @code{end}; が定義された。~
コンテナクラス型のインスタンス @code{c}; において、 @code{std::begin(c), std::end(c);}; はそれぞれ @code{c.begin(), c.end();}; と等しい。~
多くのコンパイラでは [[&lt;iterator&gt;>../アルゴリズム#iterator]] そのものか、あるいはそれに相当するヘッダファイルをインクルードしていると思われる。
多くの処理系では [[&lt;iterator&gt;>../アルゴリズム#iterator]] そのものか、あるいはそれに相当するヘッダファイルをインクルードしていると思われる。

*<deque> [#deque]

**deque クラステンプレート [#deque-deque]

-~下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを pos の位置に挿入し、
// 挿入された要素を指すイテレータを返す。
template<class ...Args>
iterator emplace(const_iterator pos, Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを先頭に挿入する。
template<class ...Args>
void emplace_front(Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを末尾に挿入する。
template<class ...Args>
void emplace_back(Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 内部バッファサイズを現在の要素数分まで減らすことを要求する。
void shrink_to_fit();
}}
-~下記のメンバ関数オーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void assign(initializer_list<value_type> values);
void push_front(value_type&& value);
void push_back(value_type&& value);
iterator insert(const_iterator pos, value_type&& value);
iterator insert(const_iterator pos, initializer_list<value_type> values);
void resize(size_type num);
}}
-~メンバ関数 @code{erase}; の定義が変更され、引数の @code{iterator}; がすべて @code{const_iterator}; になった。
-~メンバ関数 @code{resize}; の定義が変更され、デフォルト引数が削除された。~
代わりに第2引数なしのオーバロードが定義された。

*<list> [#list]

**list クラステンプレート [#list-list]

-~下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを pos の位置に挿入し、
// 挿入された要素を指すイテレータを返す。
template<class ...Args>
iterator emplace(const_iterator pos, Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを先頭に挿入する。
template<class ...Args>
void emplace_front(Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを末尾に挿入する。
template<class ...Args>
void emplace_back(Args&&... args);
}}
-~下記のメンバ関数オーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void assign(initializer_list<value_type> values);
void push_front(value_type&& value);
void push_back(value_type&& value);
iterator insert(const_iterator pos, value_type&& value);
iterator insert(const_iterator pos, initializer_list<value_type> values);
void resize(size_type num);
void splice(const_iterator pos, list&& src);
void splice(const_iterator pos, list&& src, const_iterator spos);
void splice(const_iterator pos, list&& src, const_iterator sfirst, const_iterator slast);
void merge(list&& src);
template<class Compare> void merge(list&& src, Compare comp);
}}
-~メンバ関数 @code{erase}; および @code{splice}; の定義が変更され、引数の @code{iterator}; がすべて @code{const_iterator}; になった。
-~メンバ関数 @code{resize}; の定義が変更され、デフォルト引数が削除された。~
代わりに第2引数なしのオーバロードが定義された。
-~メンバ関数 @code{reverse}; に条件式なしの @code{noexcept}; 指定が付与され、例外を投げないことが保証された。

*<map> [#map]

**map クラステンプレート [#map-map]

-~下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// キー値 key に対応する値を取得する。存在しない場合は out_of_range 例外を送出する。
mapped_type& at(const key_type& key);
const mapped_type& at(const key_type& key) const;
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを挿入試行する。
// 挿入に成功した場合は要素を指すイテレータと true のペアを返す。
// 挿入に失敗した場合は既存の同一キー要素を指すイテレータと false のペアを返す。
template<class ...Args>
pair<iterator, bool> emplace(Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを挿入試行する。
// その際、 pos を挿入位置のヒントとして用いる。(挿入位置が pos になるならば最速)
// 挿入に成功した場合は要素を指すイテレータを返す。
// 挿入に失敗した場合は既存の同一キー要素を指すイテレータを返す。
template<class ...Args>
iterator emplace_hint(const_iterator pos, Args&&... args);
}}
-~下記のメンバ関数オーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class U> pair<iterator, bool> insert(U&& value);
template<class U> iterator insert(const_iterator pos, U&& value);
void insert(initializer_list<value_type> values);
mapped_type& operator[](key_type&& key);
}}
-~@code{const allocator_type&}; のみを受け取るコンストラクタが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
explicit map(const allocator_type& alloc);
}}
-~メンバ関数 @code{erase}; の定義が一部変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
void erase(iterator pos);
void erase(iterator first, iterator last);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
// 引数が iterator から const_iterator に変更
// 削除された要素の次の要素を指すイテレータを返す
iterator erase(const_iterator pos);
iterator erase(const_iterator first, const_iterator last);
}}

**multimap クラステンプレート [#map-multimap]

-~下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを挿入し、
// 挿入した要素を指すイテレータを返す。
template<class ...Args>
iterator emplace(Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを挿入し、
// 挿入した要素を指すイテレータを返す。
// その際、 pos を挿入位置のヒントとして用いる。(挿入位置が pos になるならば最速)
template<class ...Args>
iterator emplace_hint(const_iterator pos, Args&&... args);
}}
-~下記のメンバ関数オーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class U> iterator insert(U&& value);
template<class U> iterator insert(const_iterator pos, U&& value);
void insert(initializer_list<value_type> values);
}}
-~@code{const allocator_type&}; のみを受け取るコンストラクタが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
explicit multimap(const allocator_type& alloc);
}}
-~メンバ関数 @code{erase}; の定義が一部変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
void erase(iterator pos);
void erase(iterator first, iterator last);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
// 引数が iterator から const_iterator に変更
// 削除された要素の次の要素を指すイテレータを返す
iterator erase(const_iterator pos);
iterator erase(const_iterator first, const_iterator last);
}}

*<queue> [#queue]

[[コンテナ共通>#common]]の変更点は該当しない。

**queue クラステンプレート [#queue-queue]

-~下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを末尾に挿入する。
template<class ...Args>
void emplace(Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 2つの queue 間で内容を入れ替える。
// noexpept 式中の c は、 queue が持つ内部コンテナ実体(container_type 型)。
void swap(queue& other) noexcept(noexcept(std::swap(c, other.c)));
}}
-~下記のメンバ関数オーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void push(value_type&& value);
}}
-~下記のメンバ型が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
typedef container_type::reference       reference;          // value_type& 相当
typedef container_type::const_reference const_reference;    // const value_type& 相当
}}
-~コンストラクタの定義が変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
explicit queue(const container_type& src = container_type());
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
explicit queue(const container_type& src);
explicit queue(container_type&& src = container_type());
template<class Alloc> explicit queue(const Alloc& alloc);
template<class Alloc> queue(const container_type& src, const Alloc& alloc);
template<class Alloc> queue(container_type&& src, const Alloc& alloc);
template<class Alloc> queue(const queue& src, const Alloc& alloc);
template<class Alloc> queue(queue&& src, const Alloc& alloc);
}}
-~メンバ関数 @code{front}; および @code{back}; の定義が変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
value_type& front();
const value_type& front() const;
value_type& back();
const value_type& back() const;
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
// 戻り値の型が value_type&, const value_type& から reference, const_reference に変更
// 既定の container_type である deque<T> を利用している場合は実質C++03と変わらない
reference& front();
const_reference& front() const;
reference& back();
const_reference& back() const;
}}

**priority_queue クラステンプレート [#queue-priority_queue]

-~下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを挿入する。
template<class ...Args>
void emplace(Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 2つの priority_queue 間で内容を入れ替える。
// noexpept 式中の c は、 priority_queue が持つコンテナ実体(container_type 型)。
void swap(priority_queue& other) noexcept(noexcept(std::swap(c, other.c)));
}}
-~下記のメンバ関数オーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void push(value_type&& value);
}}
-~下記のメンバ型が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
typedef container_type::reference       reference;          // value_type& 相当
typedef container_type::const_reference const_reference;    // const value_type& 相当
}}
-~コンストラクタの定義が変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
explicit priority_queue(
    const Compare& comp = Compare(),
    const container_type& src = container_type());
template<class InputIterator> priority_queue(
    InputIterator first,
    InputIterator last,
    const Compare& comp = Compare(),
    const container_type& src = container_type());
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
priority_queue(const Compare& comp, const container_type& src);
template<class InputIterator> priority_queue(
    InputIterator first,
    InputIterator last,
    const Compare& comp,
    const container_type& src);
explicit priority_queue(
    const Compare& comp = Compare(),
    container_type&& src = container_type());
template<class InputIterator> priority_queue(
    InputIterator first,
    InputIterator last,
    const Compare& comp = Compare(),
    container_type&& src = container_type());
template<class Alloc> explicit priority_queue(const Alloc& alloc);
template<class Alloc> priority_queue(const Compare& comp, const Alloc& alloc);
template<class Alloc> priority_queue(
    const Compare& comp,
    const container_type& src,
    const Alloc& alloc);
template<class Alloc> priority_queue(
    const Compare& comp,
    container_type&& src,
    const Alloc& alloc);
template<class Alloc> priority_queue(const priority_queue& src, const Alloc& alloc);
template<class Alloc> priority_queue(priority_queue&& src, const Alloc& alloc);
}}
-~メンバ関数 @code{top}; の定義が変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
const value_type& top() const;
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
// 戻り値の型が const value_type& から const_reference に変更
// 既定の container_type である vector<T> を利用している場合は実質C++03と変わらない
const_reference top() const;
}}

**<queue> その他 [#queue-others]

-~フリー関数 @code{swap}; （[[&lt;utility&gt;>../ユーティリティ#utility]]）のオーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class T, class Container>
void swap(queue<T, Container>& a, queue<T, Container>& b) noexcept(noexcept(a.swap(b)));
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class T, class Container, class Compare>
void swap(
    priority_queue<T, Container, Compare>& a,
    priority_queue<T, Container, Compare>& b) noexcept(noexcept(a.swap(b)));
}}
-~クラステンプレート @code{uses_allocator}; （[[&lt;memory&gt;>../ユーティリティ#memory]]）の部分特殊化バージョンが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class T, class Container, class Alloc>
struct uses_allocator<queue<T, Container>, Alloc>;
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class T, class Container, class Compare, class Alloc>
struct uses_allocator<priority_queue<T, Container, Compare>, Alloc>;
}}

*<set> [#set]

**set クラステンプレート [#set-set]

-~@code{const allocator_type&}; のみを受け取るコンストラクタが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
explicit set(const allocator_type& alloc);
}}
-~下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを挿入試行する。
// 挿入に成功した場合は要素を指すイテレータと true のペアを返す。
// 挿入に失敗した場合は既存の同一キー要素を指すイテレータと false のペアを返す。
template<class ...Args>
pair<iterator, bool> emplace(Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを挿入試行する。
// その際、 pos を挿入位置のヒントとして用いる。(挿入位置が pos になるならば最速)
// 挿入に成功した場合は要素を指すイテレータを返す。
// 挿入に失敗した場合は既存の同一キー要素を指すイテレータを返す。
template<class ...Args>
iterator emplace_hint(const_iterator pos, Args&&... args);
}}
-~下記のメンバ関数オーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
pair<iterator, bool> insert(value_type&& value);
iterator insert(const_iterator pos, value_type&& value);
void insert(initializer_list<value_type> values);
}}
-~メンバ関数 @code{erase}; の定義が一部変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
void erase(iterator pos);
void erase(iterator first, iterator last);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
// 引数が iterator から const_iterator に変更
// 削除された要素の次の要素を指すイテレータを返す
iterator erase(const_iterator pos);
iterator erase(const_iterator first, const_iterator last);
}}

**multiset クラステンプレート [#set-multiset]

-~@code{const allocator_type&}; のみを受け取るコンストラクタが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
explicit multiset(const allocator_type& alloc);
}}
-~下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを挿入し、
// 挿入した要素を指すイテレータを返す。
template<class ...Args>
iterator emplace(Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを挿入し、
// 挿入した要素を指すイテレータを返す。
// その際、 pos を挿入位置のヒントとして用いる。(挿入位置が pos になるならば最速)
template<class ...Args>
iterator emplace_hint(const_iterator pos, Args&&... args);
}}
-~下記のメンバ関数オーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
iterator insert(value_type&& value);
iterator insert(const_iterator pos, value_type&& value);
void insert(initializer_list<value_type> values);
}}
-~メンバ関数 @code{erase}; の定義が一部変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
void erase(iterator pos);
void erase(iterator first, iterator last);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
// 引数が iterator から const_iterator に変更
// 削除された要素の次の要素を指すイテレータを返す
iterator erase(const_iterator pos);
iterator erase(const_iterator first, const_iterator last);
}}

*<stack> [#stack]

[[コンテナ共通>#common]]の変更点は該当しない。

**stack クラステンプレート [#stack-stack]

-~下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを挿入する。
template<class ...Args>
void emplace(Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 2つの stack 間で内容を入れ替える。
// noexpept 式中の c は、 stack が持つ内部コンテナ実体(container_type 型)。
void swap(stack& other) noexcept(noexcept(std::swap(c, other.c)));
}}
-~下記のメンバ関数オーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void push(value_type&& value);
}}
-~下記のメンバ型が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
typedef container_type::reference       reference;          // value_type& 相当
typedef container_type::const_reference const_reference;    // const value_type& 相当
}}
-~コンストラクタの定義が変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
explicit stack(const container_type& src = container_type());
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
explicit stack(const container_type& src);
explicit stack(container_type&& src = container_type());
template<class Alloc> explicit stack(const Alloc& alloc);
template<class Alloc> stack(const container_type& src, const Alloc& alloc);
template<class Alloc> stack(container_type&& src, const Alloc& alloc);
template<class Alloc> stack(const stack& src, const Alloc& alloc);
template<class Alloc> stack(stack&& src, const Alloc& alloc);
}}
-~メンバ関数 @code{top}; の定義が変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
value_type& top();
const value_type& top() const;
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
// 戻り値の型が value_type&, const value_type& から reference, const_reference に変更
// 既定の container_type である deque<T> を利用している場合は実質C++03と変わらない
reference top();
const_reference top() const;
}}

**<stack> その他 [#stack-others]

-~フリー関数 @code{swap}; （[[&lt;utility&gt;>../ユーティリティ#utility]]）のオーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class T, class Container>
void swap(stack<T, Container>& a, stack<T, Container>& b) noexcept(noexcept(a.swap(b)));
}}
-~クラステンプレート @code{uses_allocator}; （[[&lt;memory&gt;>../ユーティリティ#memory]]）の部分特殊化バージョンが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class T, class Container, class Alloc>
struct uses_allocator<stack<T, Container>, Alloc>;
}}

*<string> [#string]

**basic_string クラステンプレート [#string-basic_string]

-~下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 先頭文字への参照を取得する。
value_type& front();
const value_type& front() const;
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 末尾文字への参照を取得する。
value_type& back();
const value_type& back() const;
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 末尾の文字を削除する。
void pop_back();
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 内部バッファサイズを現在の要素数分まで減らすことを要求する。
void shrink_to_fit();
}}
-~下記のメンバ関数オーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
basic_string& append(initializer_list<value_type> values);
basic_string& assign(basic_string&& src);
basic_string& assign(initializer_list<value_type> values);
basic_string& insert(const_iterator pos, initializer_list<value_type> values);
basic_string& replace(
    const_iterator first,
    const_iterator last,
    initializer_list<value_type> values);
basic_string& operator+=(initializer_list<value_type> values);
}}
-~下記のメンバ型の定義が変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
typedef allocator_type::pointer         pointer;
typedef allocator_type::const_pointer   const_pointer;
typedef allocator_type::difference_type difference_type;
typedef allocator_type::size_type       size_type;
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
// allocator_traits 経由で型情報を得る
typedef allocator_traits<allocator_type>::pointer         pointer;
typedef allocator_traits<allocator_type>::const_pointer   const_pointer;
typedef allocator_traits<allocator_type>::difference_type difference_type;
typedef allocator_traits<allocator_type>::size_type       size_type;
}}
-~メンバ関数 @code{insert}; の定義が一部変更された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++03
void insert(iterator pos, size_type num, value_type value);
iterator insert(iterator pos, value_type value);
template<class InputIterator> void insert(
    iterator pos,
    InputIterator first,
    InputIterator last);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// C++11
// 引数が iterator から const_iterator に変更
// 挿入された要素の先頭を指すイテレータを返す
iterator insert(const_iterator pos, size_type num, value_type value);
iterator insert(const_iterator pos, value_type value);
template<class InputIterator> iterator insert(
    const_iterator pos,
    InputIterator first,
    InputIterator last);
}}
-~メンバ関数 @code{erase}; および @code{replace}; の定義が一部変更され、引数の @code{iterator}; がすべて @code{const_iterator}; になった。
-~下記のメンバ関数に条件式なしの noexcept 指定が付与され、例外を投げないことが保証された。
--@code{c_str};
--@code{data};
--@code{capacity};
--@code{length};
--@code{compare}; （@code{const basic_string&}; を第1引数にとるオーバロードのみ）
--@code{find}; （@code{const value_type*}; を引数にとるオーバロードを除く）
--@code{rfind}; （@code{const value_type*}; を引数にとるオーバロードを除く）
--@code{find_first_of}; （@code{const value_type*}; を引数にとるオーバロードを除く）
--@code{find_last_of}; （@code{const value_type*}; を引数にとるオーバロードを除く）
--@code{find_first_not_of}; （@code{const value_type*}; を引数にとるオーバロードを除く）
--@code{find_last_not_of}; （@code{const value_type*}; を引数にとるオーバロードを除く）

**char_traits クラステンプレート [#string-char_traits]

-~下記の特殊化バージョンが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<> struct char_traits<char16_t>;
template<> struct char_traits<char32_t>;
}}
-~下記の静的メンバ関数が @code{constexpr}; 関数に変更され、戻り値をコンパイル時定数として利用可能になった。
--@code{eq};
--@code{lt};
--@code{eof};
--@code{not_eof};
--@code{to_char_type};
--@code{to_int_type};
--@code{eq_int_type};
-~下記の静的メンバ関数に条件式なしの noexcept 指定が付与され、例外を投げないことが保証された。
--@code{eq};
--@code{lt};
--@code{eof};
--@code{not_eof};
--@code{to_char_type};
--@code{to_int_type};
--@code{eq_int_type};
--@code{assign}; （@code{char_type&}; を第1引数にとるオーバロードのみ）

**<string> その他 [#string-others]

-~下記の型が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
}}
-~下記のフリー関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 文字列の先頭にある base 基数の整数値文字列を整数値に変換する。
// 変換ルーチンは標準関数 strtol または strtoul に準じる。
// index が非NULLの場合、変換対象外となった最初の文字の位置が設定される。
int stoi(const string&  src, size_t* index = 0, int base = 10);
int stoi(const wstring& src, size_t* index = 0, int base = 10);
long stol(const string&  src, size_t* index = 0, int base = 10);
long stol(const wstring& src, size_t* index = 0, int base = 10);
long long stoll(const string&  src, size_t* index = 0, int base = 10);
long long stoll(const wstring& src, size_t* index = 0, int base = 10);
unsigned long stoul(const string&  src, size_t* index = 0, int base = 10);
unsigned long stoul(const wstring& src, size_t* index = 0, int base = 10);
unsigned long long stoull(const string&  src, size_t* index = 0, int base = 10);
unsigned long long stoull(const wstring& src, size_t* index = 0, int base = 10);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 文字列の先頭にある実数値文字列を実数値に変換する。
// 変換ルーチンは標準関数 strtof に準じる。
// index が非NULLの場合、変換対象外となった最初の文字の位置が設定される。
float stof(const string&  src, size_t* index = 0);
float stof(const wstring& src, size_t* index = 0);
double stod(const string&  src, size_t* index = 0);
double stod(const wstring& src, size_t* index = 0);
long double stold(const string&  src, size_t* index = 0);
long double stold(const wstring& src, size_t* index = 0);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 数値を10進数文字列に変換する。
string to_string(int value);
string to_string(long value);
string to_string(long long value);
string to_string(unsigned int value);
string to_string(unsigned long value);
string to_string(unsigned long long value);
string to_string(float value);
string to_string(double value);
string to_string(long double value);
wstring to_wstring(int value);
wstring to_wstring(long value);
wstring to_wstring(long long value);
wstring to_wstring(unsigned int value);
wstring to_wstring(unsigned long value);
wstring to_wstring(unsigned long long value);
wstring to_wstring(float value);
wstring to_wstring(double value);
wstring to_wstring(long double value);
}}
-~フリー関数 @code{getline}; の @code{basic_istream&&}; を引数にとるオーバロードが定義された。~
@code{basic_istream&}; を引数にとるオーバロードに対応する形で定義されている。
-~フリー関数 @code{operator+}; の @code{basic_string&&}; を引数にとるオーバロードが定義された。~
@code{const basic_string&}; を引数にとるオーバロードに対応する形で定義されている。
-~クラステンプレート @code{hash}; （[[&lt;functional&gt;>../アルゴリズム#functional]]）の特殊化バージョンが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<> struct hash<string>;
template<> struct hash<wstring>;
template<> struct hash<u16string>;
template<> struct hash<u32string>;
}}
-~下記のフリー関数に条件式なしの noexcept 指定が付与され、例外を投げないことが保証された。
--@code{operator==}; （@code{const basic_string&}; を第1および第2引数にとるオーバロードのみ）
--@code{operator!=}; （@code{const basic_string&}; を第1および第2引数にとるオーバロードのみ）
--@code{operator<}; （@code{const basic_string&}; を第1および第2引数にとるオーバロードのみ）
--@code{operator<=}; （@code{const basic_string&}; を第1および第2引数にとるオーバロードのみ）
--@code{operator>}; （@code{const basic_string&}; を第1および第2引数にとるオーバロードのみ）
--@code{operator>=}; （@code{const basic_string&}; を第1および第2引数にとるオーバロードのみ）

*<vector> [#vector]

**vector クラステンプレート [#vector-vector]

-~下記のメンバ関数が定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 内部バッファへのポインタを取得する。 &vec[0] と等しい。
value_type* data() noexcept;
const value_type* data() const noexcept;
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを pos の位置に挿入し、
// 挿入された要素を指すイテレータを返す。
template<class ...Args>
iterator emplace(const_iterator pos, Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// アロケータに args を渡して直接構築したインスタンスを末尾に挿入する。
template<class ...Args>
void emplace_back(Args&&... args);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
// 内部バッファサイズを現在の要素数分まで減らすことを要求する。
void shrink_to_fit();
}}
-~下記のメンバ関数オーバロードが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void assign(initializer_list<value_type> values);
void push_back(value_type&& value);
iterator insert(const_iterator pos, value_type&& value);
iterator insert(const_iterator pos, initializer_list<value_type> values);
void resize(size_type num);
}}
-~メンバ関数 @code{erase}; の定義が変更され、引数の @code{iterator}; がすべて @code{const_iterator}; になった。
-~メンバ関数 @code{resize}; の定義が変更され、デフォルト引数が削除された。~
代わりに第2引数なしのオーバロードが定義された。
-~下記のメンバ関数に条件式なしの noexcept 指定が付与され、例外を投げないことが保証された。
--@code{capacity};
--@code{vector<bool>::flip};
--@code{vector<bool>::swap}; （静的メンバ関数版のみ）

**<vector> その他 [#vector-others]

-~クラステンプレート @code{hash}; （[[&lt;functional&gt;>../アルゴリズム#functional]]）の部分特殊化バージョンが定義された。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class Alloc> struct hash<vector<bool, Alloc>>;
}}