close
名前空間
変種

    名前付き要件: SequenceContainer

    提供: cppreference.com
     
    C++
     
    名前付き要件
    基本
    型の性質
    ライブラリ全体
    コンテナ
    コンテナの要素
    イテレータ
    ストリーム入出力
    乱数
    並行処理
    (C++11)
    (C++11)
    (C++11)

    (C++11)
    (C++11)
    (C++17)
    (C++14)
    その他
     

    SequenceContainer は線形な配置で同じ型のオブジェクトを格納する Container です。

    要件

    以下の内容を満たす場合、型 X は SequenceContainer を満たします。

    • 型 X が Container を満たさなければならず、

    さらに、

    • X 型の要素 T
    • X のアロケータ型 A (存在すれば X::allocator_type、そうでなければ std::allocator<T>)
    • X 型の右辺値式 a
    • a への有効な const イテレータ p
    • a への有効な逆参照可能な const イテレータ q
    • [q1, q2) が有効な範囲となるような a への2つの const イテレータ q1, q2
    • [i, j) が有効な範囲でありイテレータが value_type に暗黙に変換可能な要素を参照するような LegacyInputIterator i, j
    • std::initializer_list<value_type> 型のオブジェクト il
    • X::size_type 型の値 n
    • X::value_type 型の左辺値または const 右辺値 t
    • X::value_type 型の非 const 右辺値 rv
    • テンプレートパラメータパック Args
    • パターン Arg&& を持つ関数パラメータパック args

    が与えられたとき、以下の式が有効でなければならず、 std::array を除くすべてのシーケンスコンテナに対して指定された効果を持たなければなりません。

    式 戻り値の型 効果 事前条件 事後条件
    X(n, t)

    X a(n, t)

    		t のコピーを n 個保持するシーケンスコンテナを構築する。 T が X に CopyInsertable である。 std::distance(begin(),end()) == n
    X(i, j)

    X a(i, j)

    		範囲 [i,j) と要素単位で等しいシーケンスコンテナを構築する。 T が X に *i から EmplaceConstructible である。

    (std::vector に対してのみ) イテレータが LegacyForwardIterator でない場合、 T は CopyInsertable でなければならない。

    		std::distance(begin(),end()) == std::distance(i,j)
    X(il) X(il.begin(), il.end())
    a = il X& il によって表された範囲を a に代入する。[1] T が CopyInsertable かつ CopyAssignable である。 a の既存の要素が破棄されるか代入される。
    a.emplace(p,args) iterator std::forward<Args>(args) で構築された T 型のオブジェクトを p の前に挿入する。 T CopyInsertable

    (std::vector および std::deque に対してのみ) T が MoveAssignable かつ MoveInsertable である。

    		返されたイテレータが a に args から構築された要素を指す。
    a.insert(p,t) iterator t のコピーを p の前に挿入する。 T CopyInsertable

    (std::vector および std::deque に対してのみ) T が CopyAssignable または MoveAssignable である。

    		返されたイテレータが a に挿入された t のコピーを指す。
    a.insert(p,rv) iterator rv のコピーを p の前に挿入する (ムーブセマンティクスを用いても構いません)。 T MoveInsertable

    (std::vector および std::deque に対してのみ) T が MoveAssignable である。

    		返されたイテレータが a に挿入された rv のコピーを指す。
    a.insert(p,n,t) iterator t のコピー n 個を p の前に挿入する。 T が CopyInsertable かつ CopyAssignable である。 返されたイテレータが a に挿入された最初の要素のコピーを指す、または n==0 の場合は p。
    a.insert(p,i,j) iterator [i, j) 内の要素のコピーを p の前に挿入する。 T が EmplaceConstructible であり、 i および j が a 内にない。

    (std::vector に対してのみ) イテレータが LegacyForwardIterator でない場合、 T は MoveInsertable かつ MoveAssignable でなければならない。

    		[i,j) 内の各イテレータが1回逆参照される。 返されたイテレータが a に挿入された最初の要素のコピーを指す、または i==j の場合は p。
    a.insert(p, il) iterator a.insert(p,il.begin(),il.end()) 返されたイテレータが a に挿入された最初の要素のコピーを指す、または il が空の場合は p。
    a.erase(q) iterator q の指す要素を消去する。 (std::deque, std::vector) T が MoveAssignable である。 返されたイテレータが消去の前に q の直後にあった要素を指す、またはそのような要素が存在しない場合は a.end()。
    a.erase(q1,q2) iterator [q1,q2) 内の要素を消去する。 (std::deque, std::vector) T が MoveAssignable である。 返されたイテレータが消去の前に q2 が指していた要素を指す、またはそのような要素が存在しない場合は a.end()。
    a.clear() void a 内のすべての要素を破棄する。

    すべての参照、ポインタ、イテレータ (終端イテレータを含む) が無効化される。 a.empty() == true である。

    a.assign(i,j) void a 内の要素を [i, j) のコピーで置き換える。 T が EmplaceConstructible であり、 i, j が a 内にない。

    (std::vector) LegacyForwardIterator でない場合、 T が MoveInsertable である。

    		[i,j) 内の各イテレータが1回逆参照される。
    a.assign(il) void a.assign(il.begin(),il.end())
    a.assign(n,t) void a 内の要素を t のコピー n 個で置き換える。 T が CopyInsertable かつ CopyAssignable である。
    注釈
    1. ↑ std::array は波括弧初期化子リストからの代入をサポートしますが、 std::initializer_list からはしません。

    以下の式が有効でなければならず、指名されたシーケンスコンテナに対して指定された効果を持たなければなりません。

    式 戻り値の型 効果 事前条件 コンテナ
    a.front() reference

    const な a に対しては const_reference

    		*a.begin() と同等 (すべて)
    a.back() reference

    const な a に対しては const_reference

    		{ auto tmp = a.end(); --tmp; return *tmp; } と同等 std::basic_string std::array std::deque std::list std::vector
    a.emplace_front(args) void std::forward<Args>(args)... で構築された T を先頭に追加する。 T が X に args から EmplaceConstructible std::deque std::forward_list std::list
    a.emplace_back(args) void std::forward<Args>(args)... で構築された T を末尾に追加する。 T が X に args から EmplaceConstructible である。

    (std::vector のみ) T が X に MoveInsertable である。

    		std::deque std::list std::vector
    a.push_front(t) void t のコピーを先頭に追加する。 T が X に CopyInsertable である。 std::deque std::forward_list std::list
    a.push_front(rv) void rv のコピーを先頭に追加する。 ムーブセマンティクスを用いても構いません。 T が X に MoveInsertable である。 std::deque std::forward_list std::list
    a.push_back(t) void t のコピーを末尾に追加する。 T が X に CopyInsertable である。 std::basic_string std::deque std::list std::vector
    a.push_back(rv) void rv のコピーを末尾に追加する。 ムーブセマンティクスを用いても構いません。 T が X に MoveInsertable である。 std::basic_string std::deque std::list std::vector
    a.pop_front() void 最初の要素を破棄する。 a.empty() == false std::deque std::forward_list std::list
    a.pop_back() void 最後の要素を破棄する。 a.empty() == false std::basic_string std::deque std::list std::vector
    a[n] reference

    const な a に対しては const_reference。

    		*(n + a.begin()) と同等。 std::basic_string std::array std::deque std::vector
    a.at(n) reference

    const な a に対しては const_reference

    		*(n + a.begin()) と同等、ただし n>=size() の場合は out_of_range が投げられる。 std::basic_string std::array std::deque std::vector

    さらに、すべてのシーケンスコンテナについて、2つの入力イテレータを取るテンプレートコンストラクタおよび2つの入力イテレータを取る insert(), append(), assign(), replace() のメンバ関数テンプレートオーバーロードは、対応するテンプレート引数が LegacyInputIterator を満たさない場合、オーバーロード解決に参加しません。

    標準ライブラリのシーケンスコンテナ

    		 文字の並びを格納および操作します
    (クラステンプレート) [edit]
    (C++11)
    		 要素が隣接した静的な配列
    (クラステンプレート) [edit]
    		要素が隣接した動的な配列
    (クラステンプレート) [edit]
    		両端キュー
    (クラステンプレート) [edit]
    (C++11)
    		 片方向連結リスト
    (クラステンプレート) [edit]
    		双方向連結リスト
    (クラステンプレート) [edit]

    トレードオフおよび使用上の注意

    std::array 高速アクセス、ただし固定の要素数
    std::vector 高速アクセス、ただし大抵は非効率的な挿入および削除
    std::list
    std::forward_list     		シーケンスの途中への効率的な挿入および削除
    std::deque シーケンスの先頭および終端への効率的な挿入および削除