次の方法で共有

forward_list クラス

  • [アーティクル]

要素の可変長シーケンスを制御するオブジェクトを表します。 シーケンスはノードのシングル リンク リストとして格納され、各ノードには型 Type のメンバーが含まれます。

構文

template <class Type,
    class Allocator = allocator<Type>>
class forward_list

パラメーター

Type*
forward_list に格納される要素のデータ型。

Allocator
forward_list によるメモリの割り当てと解放に関する詳細をカプセル化する、格納されたアロケーター オブジェクト。 このパラメーターは省略可能です。 既定値は allocator<Type> です。

解説

forward_list オブジェクトは、allocator クラスstd::allocator) (一般的な呼び方では ) に基づくクラス Allocator の格納されているオブジェクトを通じて制御しているシーケンスに対して、ストレージの割り当てと解放を行います。 詳細については、「アロケーター」をご覧ください。 アロケーター オブジェクトは、allocator 型のオブジェクトと同じ外部インターフェイスを持っている必要があります。

Note

コンテナー オブジェクトを代入しても、格納されているアロケーター オブジェクトはコピーされません。

反復子、ポインター、および参照は、それらの被制御シーケンスの要素が forward_list を通じて消去された場合、無効になる可能性があります。 被制御シーケンスに対して forward_list 実行される挿入とスプライスは、反復子を無効にしません。

forward_list::insert_after の呼び出しによって、被制御シーケンスへの追加が発生する場合があります。この関数は、コンストラクター Type(const T&) を呼び出す唯一のメンバー関数です。 forward_list は、移動コンストラクターも呼び出す場合があります。 このような式が例外をスローした場合、コンテナー オブジェクトは新しい要素を挿入せず、例外を再スローします。 したがって、型 forward_list のオブジェクトは、このような例外が発生したときに、既知の状態のままになります。

メンバー

コンストラクター

名前 説明
forward_list forward_list 型のオブジェクトを構築します。

Typedefs

名前 説明
allocator_type 前方リスト オブジェクトのアロケーター クラスを表す型。
const_iterator 前方リストに定数反復子を提供する型。
const_pointer 前方リスト内の const 要素へのポインターを提供する型。
const_reference 前方リスト内の要素への定数参照を提供する型。
difference_type 前方リストの要素の数を、反復子が指す要素の範囲に基づいて表すために使用できる符号付き整数型。
iterator 前方リストの反復子を提供する型。
pointer 前方リスト内の要素へのポインターを提供する型。
参照先 前方リスト内の要素への参照を提供する型。
size_type 2 つの要素間の距離を表す、符号なしの型。
value_type 前方リストに格納された要素の型を表す型。

関数

名前 説明
assign 前方リストから要素を消去し、対象の前方リストに新しい要素のセットをコピーします。
before_begin 前方リスト内の先頭要素の前の位置を示す反復子を返します。
begin 前方リスト内の最初の要素を指す反復子を返します。
cbefore_begin 前方リスト内の先頭要素の前の位置を示す定数反復子を返します。
cbegin 前方リスト内の最初の要素を指す定数反復子を返します。
cend 前方リスト内の最後の要素の次の場所を指す定数反復子を返します。
clear 前方リストのすべての要素を消去します。
emplace_after 指定された位置の後に新しい要素を構築します。
emplace_front イン プレースで構築された要素をリストの先頭に追加します。
empty 前方リストが空であるかどうかをテストします。
end 前方リスト内の最後の要素の次の場所を指す反復子を返します。
erase_after 前方リストから指定された位置の後の要素を削除します。
front 前方リスト内の最初の要素への参照を返します。
get_allocator 前方リストの構築に使用されるアロケーター オブジェクトのコピーを返します。
insert_after 前方リストの指定された位置の後に要素を追加します。
max_size 前方リストの最大長を返します。
merge 引数リストから要素を削除し、それをターゲットの前方リストに挿入して、新たに組み合わされたセットの要素を昇順またはその他の指定された順序で並べ替えます。
pop_front 前方リストの先頭から要素を削除します。
push_front 前方リストの先頭に要素を追加します。
remove 指定された値と一致する前方リスト内の要素を消去します。
remove_if 指定された述語を満たす前方リスト内の要素を消去します。
resize 前方リストの新しいサイズを指定します。
reverse 前方リスト内で要素が出現する順序を反転させます。
sort 要素を昇順または述語によって指定された順序で配置します。
splice_after ノード間のリンクを再接合します。
スワップ 2 つの前方リストの要素を交換します。
unique 指定されたテストに合格した隣接する要素を削除します。

演算子

名前 説明
operator= 別の前方リストのコピーで前方リストの要素を置き換えます。

allocator_type

前方リスト オブジェクトのアロケーター クラスを表す型。

typedef Allocator allocator_type;

解説

allocator_type は、テンプレート パラメーター Allocator のシノニムです。

割り当て

前方リストから要素を消去し、対象の前方リストに新しい要素のセットをコピーします。

void assign(
    size_type Count,
    const Type& Val);

void assign(
    initializer_list<Type> IList);

template <class InputIterator>
void assign(InputIterator First, InputIterator Last);

パラメーター

first
置換範囲の先頭。

last
置換範囲の末尾。

count
割り当てる要素の数。

val
各要素に割り当てる値。

Type
値の種類です。

IList
コピーする initializer_list。

解説

forward_list が整数型の場合、1 つ目のメンバー関数は assign((size_type)First, (Type)Last) と同様に動作します。 それ以外の場合、1 つ目のメンバー関数は、*this によって制御されているシーケンスをシーケンス [ First, Last) に置換します。このシーケンスは、初期状態の被制御シーケンスと重なってはなりません。

2 つ目のメンバー関数は、*this によって制御されているシーケンスを、値 Count の Val 個の要素の繰り返しで置き換えます。

3 つ目のメンバー関数は、initializer_list の要素を forward_list にコピーします。

before_begin

前方リスト内の先頭要素の前の位置を示す反復子を返します。

const_iterator before_begin() const;
iterator before_begin();

戻り値

シーケンスの最初の要素の直前 (または末尾の空のシーケンスの直前) の位置を示す前方反復子。

解説

begin

前方リスト内の最初の要素を指す反復子を返します。

const_iterator begin() const;
iterator begin();

戻り値

シーケンスの最初の要素 (または空のシーケンスの末尾の次の位置) を示す前方反復子。

解説

cbefore_begin

前方リスト内の先頭要素の前の位置を示す定数反復子を返します。

const_iterator cbefore_begin() const;

戻り値

シーケンスの最初の要素の直前 (または末尾の空のシーケンスの直前) の位置を示す前方反復子。

解説

cbegin

範囲内の最初の要素を示す const 反復子を返します。

const_iterator cbegin() const;

戻り値

範囲の最初の要素、または空の範囲の末尾の次の位置 (空の範囲の場合、const) を指し示す cbegin() == cend() 前方アクセス反復子。

解説

cbegin の戻り値で範囲内の要素を変更することはできません。

begin() メンバー関数の代わりにこのメンバー関数を使用して、戻り値が const_iterator になることを保証できます。 通常は、次の例に示すように、自動型推論キーワード (keyword)で使用されます。 例では、Container が const と begin() をサポートする任意の種類の変更可能な (非 cbegin()) コンテナーであると見なします。

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator

cend

範囲内の最後の要素の次の位置を指す const 反復子を返します。

const_iterator cend() const;

戻り値

範囲の末尾の次の位置を指し示す前方アクセス反復子。

解説

cend は、反復子が範囲の末尾を超えたかどうかをテストするために使用されます。

end() メンバー関数の代わりにこのメンバー関数を使用して、戻り値が const_iterator になることを保証できます。 通常は、次の例に示すように、自動型推論キーワード (keyword)で使用されます。 例では、Container が const と end() をサポートする任意の種類の変更可能な (非 cend()) コンテナーであると見なします。

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

cend によって返された値は逆参照しないでください。

clear

前方リストのすべての要素を消去します。

void clear();

解説

このメンバー関数が呼び出します erase_after(before_begin(), end())。

const_iterator

前方リストに定数反復子を提供する型。

typedef implementation-defined const_iterator;

解説

const_iterator は、被制御シーケンスの定数前方反復子として使用できるオブジェクトを表します。 ここでは、実装定義型のシノニムとして説明します。

const_pointer

前方リスト内の const 要素へのポインターを提供する型。

typedef typename Allocator::const_pointer
    const_pointer;

解説

const_reference

前方リスト内の要素への定数参照を提供する型。

typedef typename Allocator::const_reference const_reference;

解説

difference_type

前方リストの要素の数を、反復子が指す要素の範囲に基づいて表すために使用できる符号付き整数型。

typedef typename Allocator::difference_type difference_type;

解説

difference_type は、被制御シーケンス内にある任意の 2 つの要素のアドレスの違いを表現できるオブジェクトを記述します。

emplace_after

指定された位置の後に新しい要素を構築します。

template <class T>
iterator emplace_after(const_iterator Where, Type&& val);

パラメーター

場所
新しい要素が構築された、ターゲット前方リスト内の位置。

val
コンストラクターの引数。

戻り値

新しく挿入される要素を指定する反復子。

解説

このメンバー関数は、被制御シーケンス内の、Where が指す要素の直後にコンストラクター引数 val を持つ要素を挿入します。 それ以外は、forward_list::insert_after と同じ動作をします。

emplace_front

イン プレースで構築された要素をリストの先頭に追加します。

template <class Type>
    void emplace_front(Type&& val);

パラメーター

val
前方リストの先頭に追加する要素。

解説

このメンバー関数は、被制御シーケンスの末尾に、コンストラクター引数 _ val を持つ要素を挿入します。

例外がスローされた場合、コンテナーは変更されず、例外が再度スローされます。

空

前方リストが空であるかどうかをテストします。

bool empty() const;

戻り値

前方リストが空である場合は true。それ以外の場合は false。

end

前方リスト内の最後の要素の次の場所を指す反復子を返します。

const_iterator end() const;
iterator end();

戻り値

シーケンスの末尾の次の位置を指す前方反復子。

erase_after

前方リストから指定された位置の後の要素を削除します。

iterator erase_after(const_iterator Where);
iterator erase_after(const_iterator first, const_iterator last);

パラメーター

場所
要素が削除される、ターゲット前方リスト内の位置。

first
削除する範囲の先頭。

last
削除する範囲の最後。

戻り値

削除した要素の後に残る最初の要素を指定する反復子。このような要素が存在しない場合は、forward_list::end。

解説

1 番目のメンバー関数は Where の直後の被制御シーケンスの要素を削除します。

2 番目のメンバー関数は、範囲 ( first, last) (両端は含まない) の被制御シーケンスの要素を削除します。

N 個の要素を削除すると、デストラクターが N 回呼び出されます。 再割り当てが発生するため、反復子と参照は、消去された要素に対して無効になります。

メンバー関数が例外をスローすることはありません。

forward_list

forward_list 型のオブジェクトを構築します。

forward_list();
explicit forward_list(const Allocator& Al);
explicit forward_list(size_type Count);
forward_list(size_type Count, const Type& Val);
forward_list(size_type Count, const Type& Val, const Allocator& Al);
forward_list(const forward_list& Right);
forward_list(const forward_list& Right, const Allocator& Al);
forward_list(forward_list&& Right);
forward_list(forward_list&& Right, const Allocator& Al);
forward_list(initializer_list<Type> IList, const Alloc& Al);
template <class InputIterator>
forward_list(InputIterator First, InputIterator Last);
template <class InputIterator>
forward_list(InputIterator First, InputIterator Last, const Allocator& Al);

パラメーター

Al
このオブジェクトに対して使用するアロケーター クラス。

Count
構築されたリスト内の要素の数。

ヴァル
構築されたリストの要素の値。

Right
構築されたリストがコピーになる元のリスト。

先頭
コピーする要素範囲内の最初の要素の位置。

最新
コピーする要素範囲を超える最初の要素の位置。

IList
コピーする initializer_list。

解説

すべてのコンストラクターはアロケーターを格納し、被制御シーケンスを初期化します。 アロケーター オブジェクトは、引数 Al が指定されていれば、この引数です。 コピー コンストラクターの場合は、次の値になります right.get_allocator()。 それ以外の場合は、Allocator() となります。

最初の 2 つのコンストラクターは、空の初期被制御シーケンスを指定します。

3 番目のコンストラクターは、値 Type() の Count 要素の繰り返しを指定します。

4 番目と 5 番目のコンストラクターは、値 Val の Count 要素の繰り返しを指定します。

6 番目のコンストラクターは、Right によって制御されるシーケンスのコピーを指定します。 InputIterator が整数型の場合、次の 2 つのコンストラクターは、値 (size_type)First の (Type)Last 個の要素の繰り返しを指定します。 それ以外の場合、次の 2 つのコンストラクターは、シーケンス [First, Last) を指定します。

9 番目と 10 番目のコンストラクターは 6 番目と同じですが、rvalue 参照があります。

最後のコンストラクターは、クラス initializer_list<Type> のオブジェクトによる初期被制御シーケンスを指定します。

front

前方リスト内の最初の要素への参照を返します。

reference front();
const_reference front() const;

戻り値

被制御シーケンスの最初の要素への参照。被制御シーケンスを空にすることはできません。

get_allocator

前方リストの構築に使用されるアロケーター オブジェクトのコピーを返します。

allocator_type get_allocator() const;

戻り値

格納されているアロケーター オブジェクトを取得します。

insert_after

前方リストの指定された位置の後に要素を追加します。

iterator insert_after(const_iterator Where, const Type& Val);
void insert_after(const_iterator Where, size_type Count, const Type& Val);
void insert_after(const iterator Where, initializer_list<Type> IList);
iterator insert_after(const_iterator Where, Type&& Val);
template <class InputIterator>
    void insert_after(const_iterator Where, InputIterator First, InputIterator Last);

パラメーター

場所
最初の要素が挿入される、ターゲット前方リスト内の位置。

Count
挿入する要素の数。

先頭
挿入範囲の先頭。

最新
挿入範囲の末尾。

ヴァル
前方リストに追加する要素。

IList
挿入する initializer_list。

戻り値

新しく挿入される要素を指定する反復子 (最初と最後のメンバー関数のみ)。

解説

各メンバー関数は、被制御シーケンス内の Where によって示されている要素の直後に、残りのオペランドによって指定されたシーケンスを挿入します。

1 番目のメンバー関数は、値 Val を持つ要素を挿入し、新しく挿入された要素を指定する反復子を返します。

2 番目のメンバー関数は、値 Val の Count 要素の繰り返しを挿入します。

InputIterator が整数型である場合、3 番目のメンバー関数は insert(it, (size_type)First, (Type)Last) と同じように動作します。 それ以外の場合は、シーケンス [First, Last) を挿入します。このシーケンスは、最初の被制御シーケンスと重複しないようにする必要があります。

4 番目のメンバー関数は、クラス initializer_list<Type> のオブジェクトによって指定されたシーケンスを挿入します。

最後のメンバー関数は 1 番目の関数と同じですが、rvalue 参照を受け取ります。

N 個の要素を挿入すると、コンストラクターが N 回呼び出されます。 再割り当てが実行されますが、反復子または参照は無効になりません。

1 つまたは複数の要素の挿入時に例外がスローされた場合、コンテナーは変更されず、再度例外がスローされます。

iterator

前方リストの反復子を提供する型。

typedef implementation-defined iterator;

解説

iterator は、被制御シーケンスの前方反復子として使用できるオブジェクトを表します。 ここでは、実装定義型のシノニムとして説明します。

max_size

前方リストの最大長を返します。

size_type max_size() const;

戻り値

オブジェクトが制御できる最も長いシーケンスの長さ。

解説

merge

2 つの並べ替えシーケンスを結合し、線形時間で 1 つの並べ替えシーケンスとします。 引数リストから要素を削除し、それをこの forward_list に挿入します。 merge を呼び出す前に、2 つのリストを同じ比較関数オブジェクトによって並べ替える必要があります。 結合されたリストは、その比較関数オブジェクトによって並び替えられます。

void merge(forward_list& right);
template <class Predicate>
    void merge(forward_list& right, Predicate comp);

パラメーター

right
マージする前方リスト。

comp
要素を並べ替えるために使用される比較関数オブジェクト。

解説

forward_list::merge は、forward_listright から要素を削除し、それをこの forward_list に挿入します。 以下に示すように、両方のシーケンスを同じ述語に基づいて順序付けする必要があります。 結合されたシーケンスも、その比較関数オブジェクトに基づいて順序付けされます。

i および j の位置にある要素を指定する反復子 Pi および Pj がある場合、最初のメンバー関数は、i < j のたびに、順序 !(*Pj < *Pi) を設定します。 (要素は順番にascending並べ替えられます)。2 番目のメンバー関数は、常i < jに順序! comp(*Pj, *Pi)を強制します。

元の被制御シーケンス内の要素ペアは、結果として得られた被制御シーケンス内で順序が反転されることはありません。 結果として得られた被制御シーケンス内の要素ペアが等価である場合 (!(*Pi < *Pj) && !(*Pj < *Pi))、元の被制御シーケンスからの要素は、right によって制御されるシーケンスからの要素の前に置かれます。

例外は、comp が例外をスローした場合にのみ発生します。 その場合、被制御シーケンスは順序が指定されないままとされ、例外が再スローされます。

operator=

別の前方リストのコピーで前方リストの要素を置き換えます。

forward_list& operator=(const forward_list& right);
forward_list& operator=(initializer_list<Type> IList);
forward_list& operator=(forward_list&& right);

パラメーター

right
前方リストにコピーする前方リスト。

IList
型 Type の要素のシーケンスと同じように動作する中かっこで囲まれた初期化子リスト。

解説

最初のメンバー演算子は、被制御シーケンスを right によって制御されるシーケンスのコピーに置き換えます。

2 番目のメンバー演算子は、クラス initializer_list<Type> オブジェクトからの被制御シーケンスを置き換えます。

3 番目のメンバー演算子は最初のものと同じですが、rvalue を使用します。

pointer

前方リスト内の要素へのポインターを提供する型。

typedef typename Allocator::pointer pointer;

pop_front

前方リストの先頭から要素を削除します。

void pop_front();

解説

前方リストの最初の要素は、空にすることができません。

メンバー関数が例外をスローすることはありません。

push_front

前方リストの先頭に要素を追加します。

void push_front(const Type& val);
void push_front(Type&& val);

パラメーター

val
前方リストの先頭に追加する要素。

解説

例外がスローされた場合、コンテナーは変更されず、例外が再度スローされます。

reference

前方リスト内の要素への参照を提供する型。

typedef typename Allocator::reference reference;

remove

指定された値と一致する前方リスト内の要素を消去します。

void remove(const Type& val);

パラメーター

val
要素によって保持されている場合、リストからその要素が削除される原因となる値。

解説

メンバー関数は、反復子 P で指定されたすべての要素を被制御シーケンスから削除します (*P == val)。

メンバー関数が例外をスローすることはありません。

remove_if

指定された述語を満たす前方リスト内の要素を消去します。

template <class Predicate>
    void remove_if(Predicate pred);

パラメーター

pred
要素によって満たされる場合、単項述語は結果的にリストからその要素を削除します。

解説

メンバー関数は、反復子 P で指定されたすべての要素を被制御シーケンスから削除します (pred(*P) は true)。

例外は、pred が例外をスローした場合にのみ発生します。 その場合、被制御シーケンスは状態が未指定のままとなり、例外が再スローされます。

サイズ変更

前方リストの新しいサイズを指定します。

void resize(size_type _Newsize);
void resize(size_type _Newsize, const Type& val);

パラメーター

_Newsize
サイズ指定された前方リストの要素の数。

val
埋め込みで使用する値。

解説

メンバー関数は両方とも、リスト内の要素の数がその後 _Newsize であることを確認します。 被制御シーケンスを長くする必要がある場合、最初のメンバー関数では値 Type() で要素を追加し、2 番目のメンバー関数では値 val で要素を追加します。 被制御シーケンスを短くするには、両方のメンバー関数とも erase_after(begin() + _Newsize - 1, end()) を効果的に呼び出します。

リバース

前方リスト内で要素が出現する順序を反転させます。

void reverse();

size_type

2 つの要素間の距離を表す、符号なしの型。

typedef typename Allocator::size_type size_type;

解説

符号なし整数型は、被制御シーケンスの長さを表すことができるオブジェクトを表します。

並べ替え

要素を昇順または述語によって指定された順序で配置します。

void sort();
template <class Predicate>
void sort(Predicate pred);

パラメーター

pred
順序付け述語。

解説

両方のメンバー関数は、次に説明するように、述語に基づいて被制御シーケンス内の要素を順序付けします。

i および j の位置にある要素を指定する反復子 Pi および Pj がある場合、最初のメンバー関数は、i < j のたびに、順序 !(*Pj < *Pi) を設定します。 (要素は順番にascending並べ替えられます)。メンバー テンプレート関数は、常i < jに順序! pred(*Pj, *Pi)を強制します。 元の被制御シーケンス内の順序付けされた要素ペアは、結果として得られた被制御シーケンス内で順序が反転されることはありません。 (並べ替えは安定しています)。

例外は、pred が例外をスローした場合にのみ発生します。 その場合、被制御シーケンスは順序が指定されないままとされ、例外が再スローされます。

splice_after

ソースの forward_list から要素を削除して、ターゲットの forward_list に挿入します。

// insert the entire source forward_list
void splice_after(const_iterator Where, forward_list& Source);
void splice_after(const_iterator Where, forward_list&& Source);

// insert one element of the source forward_list
void splice_after(const_iterator Where, forward_list& Source, const_iterator Iter);
void splice_after(const_iterator Where, forward_list&& Source, const_iterator Iter);

// insert a range of elements from the source forward_list
void splice_after(
    const_iterator Where,
    forward_list& Source,
    const_iterator First,
    const_iterator Last);

void splice_after(
    const_iterator Where,
    forward_list&& Source,
    const_iterator First,
    const_iterator Last);

パラメーター

場所
ターゲットの forward_list 内の挿入位置の直前の位置。

ソース
ターゲットの forward_list に挿入されるソースの forward_list。

Iter
ソースの forward_list リストから挿入される要素。

先頭
ソースの forward_list リストから挿入される範囲内の最初の要素。

最新
ソースの forward_list リストから挿入される範囲を超える最初の位置。

解説

メンバー関数の最初のペアは、Source によって制御されるシーケンスを、Where によって指し示される制御シーケンス内の要素の直後に挿入します。 また、Source からすべての要素を削除します (&Source を this と同じにすることはできません)。

メンバー関数の 2 つ目のペアは、Source によって制御されるシーケンス内の Iter の直後の要素を削除し、それを Where で指し示される制御シーケンス内の要素の直後に挿入します (Where == Iter || Where == ++Iter の場合は、何も変わりません。)

メンバー関数の 3 つ目のペア (範囲指定されたスプライス) は、Source で制御されるシーケンスの (First, Last) で指定されたサブ範囲を、Where で指し示される制御シーケンス内の要素の直後に挿入します。 これはまた、Source で制御されるシーケンスから元のサブ範囲を削除します (&Source == this の場合、範囲 (First, Last) に Where によって指し示される要素を含めることはできません)。

範囲指定されたスプライスで N 個の要素が挿入され、さらに &Source != this の場合、クラス iterator のオブジェクトは N 回インクリメントされます。

スプライスされた要素を指定している反復子、ポインター、参照は、いずれも無効になりません。

例

// forward_list_splice_after.cpp
// compile with: /EHsc /W4
#include <forward_list>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    forward_list<int> c1{ 10, 11 };
    forward_list<int> c2{ 20, 21, 22 };
    forward_list<int> c3{ 30, 31 };
    forward_list<int> c4{ 40, 41, 42, 43 };

    forward_list<int>::iterator where_iter;
    forward_list<int>::iterator first_iter;
    forward_list<int>::iterator last_iter;

    cout << "Beginning state of lists:" << endl;
    cout << "c1 = ";
    print(c1);
    cout << "c2 = ";
    print(c2);
    cout << "c3 = ";
    print(c3);
    cout << "c4 = ";
    print(c4);

    where_iter = c2.begin();
    ++where_iter; // start at second element
    c2.splice_after(where_iter, c1);
    cout << "After splicing c1 into c2:" << endl;
    cout << "c1 = ";
    print(c1);
    cout << "c2 = ";
    print(c2);

    first_iter = c3.begin();
    c2.splice_after(where_iter, c3, first_iter);
    cout << "After splicing the first element of c3 into c2:" << endl;
    cout << "c3 = ";
    print(c3);
    cout << "c2 = ";
    print(c2);

    first_iter = c4.begin();
    last_iter = c4.end();
    // set up to get the middle elements
    ++first_iter;
    c2.splice_after(where_iter, c4, first_iter, last_iter);
    cout << "After splicing a range of c4 into c2:" << endl;
    cout << "c4 = ";
    print(c4);
    cout << "c2 = ";
    print(c2);
}

Beginning state of lists:c1 = (10) (11)c2 = (20) (21) (22)c3 = (30) (31)c4 = (40) (41) (42) (43)After splicing c1 into c2:c1 =c2 = (20) (21) (10) (11) (22)After splicing the first element of c3 into c2:c3 = (30)c2 = (20) (21) (31) (10) (11) (22)After splicing a range of c4 into c2:c4 = (40) (41)c2 = (20) (21) (42) (43) (31) (10) (11) (22)

スワップ

2 つの前方リストの要素を交換します。

void swap(forward_list& right);

パラメーター

right
交換する要素を指定する前方リスト。

解説

このメンバー関数は、*this と right の間で被制御シーケンスを交換します。 get_allocator() == right.get_allocator() の場合、この処理は一定時間に実行されます。例外がスローされることはなく、参照や、ポインター、2 つの被制御シーケンス内の要素を指定する反復子が無効にされることもありません。 それ以外の場合は、2 つの制御されたシーケンス内の要素の数に比例して、要素の割り当てとコンストラクターの呼び出しが実行されます。

unique

等値要素内の連続するグループのそれぞれから、最初の要素を除くすべてを削除します。

void unique();
template <class BinaryPredicate>
void unique(BinaryPredicate comp);

パラメーター

comp
一連の要素の比較に使用する二項述語。

解説

各一意の要素の最初のオブジェクトを保持し、残りは削除します。 値の等しい要素がリスト内で隣接するように、要素を並べ替える必要があります。

最初のメンバー関数は、直前の要素に一致するすべての要素を被制御シーケンスから削除します。 i および j の位置にある要素を指定する反復子 Pi および Pj がある場合、2 番目のメンバー関数は、i + 1 == j && comp(*Pi, *Pj) の条件を満たすすべての要素を削除します。

被制御シーケンスの長さが N (> 0) である場合、述語 comp(*Pi, *Pj) は N - 1 回評価されます。

例外は、comp が例外をスローした場合にのみ発生します。 その場合、被制御シーケンスは状態が未指定のままとなり、例外が再スローされます。

value_type

前方リストに格納された要素の型を表す型。

typedef typename Allocator::value_type value_type;

解説

この型は、テンプレート パラメーター Typeのシノニムです。