Home / プログラミング / C++ / C++11 既存ライブラリ変更点 / コンテナ
コンテナ

C++03規格時点で存在したコンテナライブラリに対するC++11規格での変更点をまとめています。

概要

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

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

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

for (const auto& value : c)
{
    // do something...
}

共通の変更点

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

  • 各クラスにムーブコンストラクタおよびムーブ代入演算子が定義された。

  • 各クラスに std::initializer_list<value_type> を受け取るコンストラクタおよび代入演算子が定義された。
    これにより、 std::vector<int> v = { 1, 2, 3 }; といった記述によるインスタンスの初期化などが可能になった。

  • 各クラスに、第2引数で const allocator_type& を受け取るコピーコンストラクタおよびムーブコンストラクタが定義された。

  • 各クラスに下記のメンバ関数が定義された。

    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 と同じ
    
  • 各クラスの下記のメンバ関数に条件式なしの noexcept 指定が付与され、例外を投げないことが保証された。

    • begin
    • end
    • rbegin
    • rend
    • empty
    • size
    • max_size
    • clear
    • get_allocator
  • 各クラスのメンバ型 reference および const_reference の定義が下記のように変更され、アロケータ型に依存しなくなった。

    // C++03
    typedef typename allocator_type::reference       reference;
    typedef typename allocator_type::const_reference const_reference;
    // C++11
    typedef value_type&       reference;
    typedef const value_type& const_reference;
  • フリー関数 begin および end が定義された。
    コンテナクラス型のインスタンス c において、 std::begin(c), std::end(c); はそれぞれ c.begin(), c.end(); と等しい。
    多くの処理系では <iterator> そのものか、あるいはそれに相当するヘッダファイルをインクルードしていると思われる。

<deque>

deque クラステンプレート

  • 下記のメンバ関数が定義された。

    // アロケータに args を渡して直接構築したインスタンスを pos の位置に挿入し、
    // 挿入された要素を指すイテレータを返す。
    template<class ...Args>
    iterator emplace(const_iterator pos, Args&&... args);
    // アロケータに args を渡して直接構築したインスタンスを先頭に挿入する。
    template<class ...Args>
    void emplace_front(Args&&... args);
    // アロケータに args を渡して直接構築したインスタンスを末尾に挿入する。
    template<class ...Args>
    void emplace_back(Args&&... args);
    // 内部バッファサイズを現在の要素数分まで減らすことを要求する。
    void shrink_to_fit();
  • 下記のメンバ関数オーバロードが定義された。

    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);
  • メンバ関数 erase の定義が変更され、引数の iterator がすべて const_iterator になった。

  • メンバ関数 resize の定義が変更され、デフォルト引数が削除された。
    代わりに第2引数なしのオーバロードが定義された。

<list>

list クラステンプレート

  • 下記のメンバ関数が定義された。

    // アロケータに args を渡して直接構築したインスタンスを pos の位置に挿入し、
    // 挿入された要素を指すイテレータを返す。
    template<class ...Args>
    iterator emplace(const_iterator pos, Args&&... args);
    // アロケータに args を渡して直接構築したインスタンスを先頭に挿入する。
    template<class ...Args>
    void emplace_front(Args&&... args);
    // アロケータに args を渡して直接構築したインスタンスを末尾に挿入する。
    template<class ...Args>
    void emplace_back(Args&&... args);
  • 下記のメンバ関数オーバロードが定義された。

    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);
  • メンバ関数 erase および splice の定義が変更され、引数の iterator がすべて const_iterator になった。

  • メンバ関数 resize の定義が変更され、デフォルト引数が削除された。
    代わりに第2引数なしのオーバロードが定義された。

  • メンバ関数 reverse に条件式なしの noexcept 指定が付与され、例外を投げないことが保証された。

<map>

map クラステンプレート

  • 下記のメンバ関数が定義された。

    // キー値 key に対応する値を取得する。存在しない場合は out_of_range 例外を送出する。
    mapped_type& at(const key_type& key);
    const mapped_type& at(const key_type& key) const;
    // アロケータに args を渡して直接構築したインスタンスを挿入試行する。
    // 挿入に成功した場合は要素を指すイテレータと true のペアを返す。
    // 挿入に失敗した場合は既存の同一キー要素を指すイテレータと false のペアを返す。
    template<class ...Args>
    pair<iterator, bool> emplace(Args&&... args);
    // アロケータに args を渡して直接構築したインスタンスを挿入試行する。
    // その際、 pos を挿入位置のヒントとして用いる。(挿入位置が pos になるならば最速)
    // 挿入に成功した場合は要素を指すイテレータを返す。
    // 挿入に失敗した場合は既存の同一キー要素を指すイテレータを返す。
    template<class ...Args>
    iterator emplace_hint(const_iterator pos, Args&&... args);
  • 下記のメンバ関数オーバロードが定義された。

    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);
  • const allocator_type& のみを受け取るコンストラクタが定義された。

    explicit map(const allocator_type& alloc);
  • メンバ関数 erase の定義が一部変更された。

    // C++03
    void erase(iterator pos);
    void erase(iterator first, iterator last);
    // C++11
    // 引数が iterator から const_iterator に変更
    // 削除された要素の次の要素を指すイテレータを返す
    iterator erase(const_iterator pos);
    iterator erase(const_iterator first, const_iterator last);

multimap クラステンプレート

  • 下記のメンバ関数が定義された。

    // アロケータに args を渡して直接構築したインスタンスを挿入し、
    // 挿入した要素を指すイテレータを返す。
    template<class ...Args>
    iterator emplace(Args&&... args);
    // アロケータに args を渡して直接構築したインスタンスを挿入し、
    // 挿入した要素を指すイテレータを返す。
    // その際、 pos を挿入位置のヒントとして用いる。(挿入位置が pos になるならば最速)
    template<class ...Args>
    iterator emplace_hint(const_iterator pos, Args&&... args);
  • 下記のメンバ関数オーバロードが定義された。

    template<class U> iterator insert(U&& value);
    template<class U> iterator insert(const_iterator pos, U&& value);
    void insert(initializer_list<value_type> values);
  • const allocator_type& のみを受け取るコンストラクタが定義された。

    explicit multimap(const allocator_type& alloc);
  • メンバ関数 erase の定義が一部変更された。

    // C++03
    void erase(iterator pos);
    void erase(iterator first, iterator last);
    // C++11
    // 引数が iterator から const_iterator に変更
    // 削除された要素の次の要素を指すイテレータを返す
    iterator erase(const_iterator pos);
    iterator erase(const_iterator first, const_iterator last);

<queue>

コンテナ共通の変更点は該当しない。

queue クラステンプレート

  • 下記のメンバ関数が定義された。

    // アロケータに args を渡して直接構築したインスタンスを末尾に挿入する。
    template<class ...Args>
    void emplace(Args&&... args);
    // 2つの queue 間で内容を入れ替える。
    // noexpept 式中の c は、 queue が持つ内部コンテナ実体(container_type 型)。
    void swap(queue& other) noexcept(noexcept(std::swap(c, other.c)));
  • 下記のメンバ関数オーバロードが定義された。

    void push(value_type&& value);
  • 下記のメンバ型が定義された。

    typedef container_type::reference       reference;          // value_type& 相当
    typedef container_type::const_reference const_reference;    // const value_type& 相当
    
  • コンストラクタの定義が変更された。

    // C++03
    explicit queue(const container_type& src = container_type());
    // 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);
  • メンバ関数 front および back の定義が変更された。

    // C++03
    value_type& front();
    const value_type& front() const;
    value_type& back();
    const value_type& back() const;
    // 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 クラステンプレート

  • 下記のメンバ関数が定義された。

    // アロケータに args を渡して直接構築したインスタンスを挿入する。
    template<class ...Args>
    void emplace(Args&&... args);
    // 2つの priority_queue 間で内容を入れ替える。
    // noexpept 式中の c は、 priority_queue が持つコンテナ実体(container_type 型)。
    void swap(priority_queue& other) noexcept(noexcept(std::swap(c, other.c)));
  • 下記のメンバ関数オーバロードが定義された。

    void push(value_type&& value);
  • 下記のメンバ型が定義された。

    typedef container_type::reference       reference;          // value_type& 相当
    typedef container_type::const_reference const_reference;    // const value_type& 相当
    
  • コンストラクタの定義が変更された。

    // 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());
    // 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);
  • メンバ関数 top の定義が変更された。

    // C++03
    const value_type& top() const;
    // C++11
    // 戻り値の型が const value_type& から const_reference に変更
    // 既定の container_type である vector<T> を利用している場合は実質C++03と変わらない
    const_reference top() const;

<queue> その他

  • フリー関数 swap<utility>)のオーバロードが定義された。

    template<class T, class Container>
    void swap(queue<T, Container>& a, queue<T, Container>& b) noexcept(noexcept(a.swap(b)));
    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)));
  • クラステンプレート uses_allocator<memory>)の部分特殊化バージョンが定義された。

    template<class T, class Container, class Alloc>
    struct uses_allocator<queue<T, Container>, Alloc>;
    template<class T, class Container, class Compare, class Alloc>
    struct uses_allocator<priority_queue<T, Container, Compare>, Alloc>;

<set>

set クラステンプレート

  • const allocator_type& のみを受け取るコンストラクタが定義された。

    explicit set(const allocator_type& alloc);
  • 下記のメンバ関数が定義された。

    // アロケータに args を渡して直接構築したインスタンスを挿入試行する。
    // 挿入に成功した場合は要素を指すイテレータと true のペアを返す。
    // 挿入に失敗した場合は既存の同一キー要素を指すイテレータと false のペアを返す。
    template<class ...Args>
    pair<iterator, bool> emplace(Args&&... args);
    // アロケータに args を渡して直接構築したインスタンスを挿入試行する。
    // その際、 pos を挿入位置のヒントとして用いる。(挿入位置が pos になるならば最速)
    // 挿入に成功した場合は要素を指すイテレータを返す。
    // 挿入に失敗した場合は既存の同一キー要素を指すイテレータを返す。
    template<class ...Args>
    iterator emplace_hint(const_iterator pos, Args&&... args);
  • 下記のメンバ関数オーバロードが定義された。

    pair<iterator, bool> insert(value_type&& value);
    iterator insert(const_iterator pos, value_type&& value);
    void insert(initializer_list<value_type> values);
  • メンバ関数 erase の定義が一部変更された。

    // C++03
    void erase(iterator pos);
    void erase(iterator first, iterator last);
    // C++11
    // 引数が iterator から const_iterator に変更
    // 削除された要素の次の要素を指すイテレータを返す
    iterator erase(const_iterator pos);
    iterator erase(const_iterator first, const_iterator last);

multiset クラステンプレート

  • const allocator_type& のみを受け取るコンストラクタが定義された。

    explicit multiset(const allocator_type& alloc);
  • 下記のメンバ関数が定義された。

    // アロケータに args を渡して直接構築したインスタンスを挿入し、
    // 挿入した要素を指すイテレータを返す。
    template<class ...Args>
    iterator emplace(Args&&... args);
    // アロケータに args を渡して直接構築したインスタンスを挿入し、
    // 挿入した要素を指すイテレータを返す。
    // その際、 pos を挿入位置のヒントとして用いる。(挿入位置が pos になるならば最速)
    template<class ...Args>
    iterator emplace_hint(const_iterator pos, Args&&... args);
  • 下記のメンバ関数オーバロードが定義された。

    iterator insert(value_type&& value);
    iterator insert(const_iterator pos, value_type&& value);
    void insert(initializer_list<value_type> values);
  • メンバ関数 erase の定義が一部変更された。

    // C++03
    void erase(iterator pos);
    void erase(iterator first, iterator last);
    // C++11
    // 引数が iterator から const_iterator に変更
    // 削除された要素の次の要素を指すイテレータを返す
    iterator erase(const_iterator pos);
    iterator erase(const_iterator first, const_iterator last);

<stack>

コンテナ共通の変更点は該当しない。

stack クラステンプレート

  • 下記のメンバ関数が定義された。

    // アロケータに args を渡して直接構築したインスタンスを挿入する。
    template<class ...Args>
    void emplace(Args&&... args);
    // 2つの stack 間で内容を入れ替える。
    // noexpept 式中の c は、 stack が持つ内部コンテナ実体(container_type 型)。
    void swap(stack& other) noexcept(noexcept(std::swap(c, other.c)));
  • 下記のメンバ関数オーバロードが定義された。

    void push(value_type&& value);
  • 下記のメンバ型が定義された。

    typedef container_type::reference       reference;          // value_type& 相当
    typedef container_type::const_reference const_reference;    // const value_type& 相当
    
  • コンストラクタの定義が変更された。

    // C++03
    explicit stack(const container_type& src = container_type());
    // 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);
  • メンバ関数 top の定義が変更された。

    // C++03
    value_type& top();
    const value_type& top() const;
    // C++11
    // 戻り値の型が value_type&, const value_type& から reference, const_reference に変更
    // 既定の container_type である deque<T> を利用している場合は実質C++03と変わらない
    reference top();
    const_reference top() const;

<stack> その他

  • フリー関数 swap<utility>)のオーバロードが定義された。

    template<class T, class Container>
    void swap(stack<T, Container>& a, stack<T, Container>& b) noexcept(noexcept(a.swap(b)));
  • クラステンプレート uses_allocator<memory>)の部分特殊化バージョンが定義された。

    template<class T, class Container, class Alloc>
    struct uses_allocator<stack<T, Container>, Alloc>;

<string>

basic_string クラステンプレート

  • 下記のメンバ関数が定義された。

    // 先頭文字への参照を取得する。
    value_type& front();
    const value_type& front() const;
    // 末尾文字への参照を取得する。
    value_type& back();
    const value_type& back() const;
    // 末尾の文字を削除する。
    void pop_back();
    // 内部バッファサイズを現在の要素数分まで減らすことを要求する。
    void shrink_to_fit();
  • 下記のメンバ関数オーバロードが定義された。

    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);
  • 下記のメンバ型の定義が変更された。

    // 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;
    // 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;
  • メンバ関数 insert の定義が一部変更された。

    // 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);
    // 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);
  • メンバ関数 erase および replace の定義が一部変更され、引数の iterator がすべて const_iterator になった。

  • 下記のメンバ関数に条件式なしの noexcept 指定が付与され、例外を投げないことが保証された。

    • c_str
    • data
    • capacity
    • length
    • compareconst basic_string& を第1引数にとるオーバロードのみ)
    • findconst value_type* を引数にとるオーバロードを除く)
    • rfindconst value_type* を引数にとるオーバロードを除く)
    • find_first_ofconst value_type* を引数にとるオーバロードを除く)
    • find_last_ofconst value_type* を引数にとるオーバロードを除く)
    • find_first_not_ofconst value_type* を引数にとるオーバロードを除く)
    • find_last_not_ofconst value_type* を引数にとるオーバロードを除く)

char_traits クラステンプレート

  • 下記の特殊化バージョンが定義された。

    template<> struct char_traits<char16_t>;
    template<> struct char_traits<char32_t>;
  • 下記の静的メンバ関数が constexpr 関数に変更され、戻り値をコンパイル時定数として利用可能になった。

    • eq
    • lt
    • eof
    • not_eof
    • to_char_type
    • to_int_type
    • eq_int_type
  • 下記の静的メンバ関数に条件式なしの noexcept 指定が付与され、例外を投げないことが保証された。

    • eq
    • lt
    • eof
    • not_eof
    • to_char_type
    • to_int_type
    • eq_int_type
    • assignchar_type& を第1引数にとるオーバロードのみ)

<string> その他

  • 下記の型が定義された。

    typedef basic_string<char16_t> u16string;
    typedef basic_string<char32_t> u32string;
  • 下記のフリー関数が定義された。

    // 文字列の先頭にある 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);
    // 文字列の先頭にある実数値文字列を実数値に変換する。
    // 変換ルーチンは標準関数 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);
    // 数値を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);
  • フリー関数 getlinebasic_istream&& を引数にとるオーバロードが定義された。
    basic_istream& を引数にとるオーバロードに対応する形で定義されている。

  • フリー関数 operator+basic_string&& を引数にとるオーバロードが定義された。
    const basic_string& を引数にとるオーバロードに対応する形で定義されている。

  • クラステンプレート hash<functional>)の特殊化バージョンが定義された。

    template<> struct hash<string>;
    template<> struct hash<wstring>;
    template<> struct hash<u16string>;
    template<> struct hash<u32string>;
  • 下記のフリー関数に条件式なしの noexcept 指定が付与され、例外を投げないことが保証された。

    • operator==const basic_string& を第1および第2引数にとるオーバロードのみ)
    • operator!=const basic_string& を第1および第2引数にとるオーバロードのみ)
    • operator<const basic_string& を第1および第2引数にとるオーバロードのみ)
    • operator<=const basic_string& を第1および第2引数にとるオーバロードのみ)
    • operator>const basic_string& を第1および第2引数にとるオーバロードのみ)
    • operator>=const basic_string& を第1および第2引数にとるオーバロードのみ)

<vector>

vector クラステンプレート

  • 下記のメンバ関数が定義された。

    // 内部バッファへのポインタを取得する。 &vec[0] と等しい。
    value_type* data() noexcept;
    const value_type* data() const noexcept;
    // アロケータに args を渡して直接構築したインスタンスを pos の位置に挿入し、
    // 挿入された要素を指すイテレータを返す。
    template<class ...Args>
    iterator emplace(const_iterator pos, Args&&... args);
    // アロケータに args を渡して直接構築したインスタンスを末尾に挿入する。
    template<class ...Args>
    void emplace_back(Args&&... args);
    // 内部バッファサイズを現在の要素数分まで減らすことを要求する。
    void shrink_to_fit();
  • 下記のメンバ関数オーバロードが定義された。

    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);
  • メンバ関数 erase の定義が変更され、引数の iterator がすべて const_iterator になった。

  • メンバ関数 resize の定義が変更され、デフォルト引数が削除された。
    代わりに第2引数なしのオーバロードが定義された。

  • 下記のメンバ関数に条件式なしの noexcept 指定が付与され、例外を投げないことが保証された。

    • capacity
    • vector<bool>::flip
    • vector<bool>::swap (静的メンバ関数版のみ)

<vector> その他

  • クラステンプレート hash<functional>)の部分特殊化バージョンが定義された。

    template<class Alloc> struct hash<vector<bool, Alloc>>;