deque (STL/CLR)

このテンプレート クラスは、ランダム アクセス権を持つ要素の可変長シーケンスを制御するオブジェクトを表します。 コンテナー deque は、要素のシーケンスを連続するストレージ ブロックとして管理するために使用されます。ただしこれは、残る要素をコピーすることなく、両端から拡張または縮小することができます。 したがって、double-ended queue を効率的に実装できます (このことから、この名前が付けられています)。

以降の説明では、GValue は Value と同じですが、後者が ref 型の場合は Value^ となります。

構文

template<typename Value>
    ref class deque
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IDeque<GValue>
    { ..... };

パラメーター

GValue
被制御シーケンス内の要素のジェネリック型。

Value
被制御シーケンス内の要素の型。

要件

ヘッダー:<cliext/deque>

名前空間: cliext

宣言

型の定義	説明
deque::const_iterator (STL/CLR)	被制御シーケンスの定数反復子の型です。
deque::const_reference (STL/CLR)	要素への定数参照の型です。
deque::const_reverse_iterator (STL/CLR)	被制御シーケンスの定数反転反復子の型です。
deque::difference_type (STL/CLR)	2 つの要素間の距離を表す、符号付きの型です。
deque::generic_container (STL/CLR)	コンテナーのジェネリック インターフェイスの型です。
deque::generic_iterator (STL/CLR)	コンテナーのジェネリック インターフェイスの反復子の型です。
deque::generic_reverse_iterator (STL/CLR)	コンテナーのジェネリック インターフェイスの反転反復子の型です。
deque::generic_value (STL/CLR)	コンテナーのジェネリック インターフェイスの要素の型です。
deque::iterator (STL/CLR)	被制御シーケンスの反復子の型です。
deque::reference (STL/CLR)	要素への参照の型です。
deque::reverse_iterator (STL/CLR)	被制御シーケンスの反転反復子の型です。
deque::size_type (STL/CLR)	2 つの要素間の距離を表す、符号付きの型です。
deque::value_type (STL/CLR)	要素の型。

メンバー関数	説明
deque::assign (STL/CLR)	すべての要素を置換します。
deque::at (STL/CLR)	指定した位置にある要素にアクセスします。
deque::back (STL/CLR)	最後の要素にアクセスします。
deque::begin (STL/CLR)	被制御シーケンスの先頭を指定します。
deque::clear (STL/CLR)	すべての要素を削除します。
deque::deque (STL/CLR)	コンテナー オブジェクトを構築します。
deque::empty (STL/CLR)	要素が存在しないかどうかをテストします。
deque::end (STL/CLR)	被制御シーケンスの末尾を指定します。
deque::erase (STL/CLR)	指定した位置にある要素を削除します。
deque::front (STL/CLR)	最初の要素にアクセスします。
deque::insert (STL/CLR)	指定した位置に要素を追加します。
deque::pop_back (STL/CLR)	最後の要素を削除します。
deque::pop_front (STL/CLR)	最初の要素を削除します。
deque::push_back (STL/CLR)	新規に末尾の要素を追加します。
deque::push_front (STL/CLR)	新しい最初の要素を追加します。
deque::rbegin (STL/CLR)	反転被制御シーケンスの先頭を指定します。
deque::rend (STL/CLR)	反転被制御シーケンスの末尾を指定します。
deque::resize (STL/CLR)	要素の数を変更します。
deque::size (STL/CLR)	要素の数をカウントします。
deque::swap (STL/CLR)	2 つのコンテナーのコンテンツを交換します。
deque::to_array (STL/CLR)	被制御シーケンスを新しい配列にコピーします。

プロパティ	説明
deque::back_item (STL/CLR)	最後の要素にアクセスします。
deque::front_item (STL/CLR)	最初の要素にアクセスします。

Operator	説明
deque::operator!= (STL/CLR)	2 つの deque オブジェクトが等しくないかどうかを判断します。
deque::operator(STL/CLR)	指定した位置にある要素にアクセスします。
operator< (deque) (STL/CLR)	deque オブジェクトが別の deque オブジェクトより小さいかどうかを確認します。
operator<= (deque) (STL/CLR)	deque オブジェクトが別の deque オブジェクト以下かどうかを判断します。
operator= (deque) (STL/CLR)	被制御シーケンスを置き換えます。
operator== (deque) (STL/CLR)	deque オブジェクトが別の deque オブジェクトと等しいかどうかを判断します。
operator> (deque) (STL/CLR)	deque オブジェクトが別の deque オブジェクトより大きいかどうかを判断します。
operator>= (deque) (STL/CLR)	deque オブジェクトが別の deque オブジェクト以上かどうかを判断します。

インターフェイス

インターフェイス	説明
ICloneable	オブジェクトを複製します。
IEnumerable	要素をシーケンス処理します。
ICollection	要素のグループを維持します。
IEnumerable<T>	型指定された要素をシーケンス処理します。
ICollection<T>	型指定された要素のグループを維持します。
IList<T>	型指定された要素の順序付けされたグループを維持します。
IDeque<Value>	ジェネリック コンテナーを維持します。

解説

このオブジェクトでは、制御対象のシーケンスに対するストレージの割り当てと解放が、Value 要素のブロックを指定するハンドルの格納済み配列を通じて行われます。 この配列は必要に応じて拡大されます。 拡大が生じた場合、新しい要素を付加または追加するコストは定数時間であり、残りの要素に支障が及ぶことはありません。 また、どちらかの末尾にある要素を定数時間で削除することもできます。その際、残りの要素に支障が及ぶことはありません。 したがって、deque は、テンプレート クラス queue (STL/CLR) またはテンプレート クラス stack (STL/CLR) の基になるコンテナーに適しています。

deque オブジェクトでは、ランダムアクセス反復子がサポートされているため、要素を数値位置で直接参照できます。最初の (front) 要素である 0 から、最後の (back) 要素である deque::size (STL/CLR)() - 1 までカウントします。 これは、deque がテンプレート クラス priority_queue (STL/CLR) の基になるコンテナーに適していることも意味します。

deque 反復子は、関連付けられた deque オブジェクトへのハンドルを、指定した要素の偏りと共に格納します。 反復子は、関連付けられているコンテナー オブジェクトでのみ使用できます。 deque 要素の偏りは、必ずしもその位置と同じではありません。 挿入された最初の要素は偏りゼロで、次に追加された要素は偏り 1 になりますが、次に付加された要素は偏り -1 になります。

いずれかの末尾で要素を挿入または消去しても、有効な偏りで格納されている要素の値は変更されません。 ただし、内部要素を挿入または消去すると、指定した偏りで格納されている要素の値が変更されることがあるため、反復子によって指定された値も変更される可能性があります (挿入前に穴を作成したり、消去後に穴を埋めたりするには、要素を上下にコピーする必要がある場合があります)。ただし、deque 反復子は、バイアスによって有効な要素が指定されている限り有効なままです。 さらに、有効な反復子は逆参照でき、これを使用すると、指定した要素の値にアクセスしたり、値を変更したりできます (その偏りが end() によって返された反復子の偏りと等しくない場合のみ)。

要素を消去または削除すると、格納されている値のデストラクターが呼び出されます。 コンテナーを破棄すると、すべての要素が消去されます。 したがって、要素型が ref クラスのコンテナーでは、コンテナーよりも有効期間が長い要素はありません。 ただし、ハンドルのコンテナーはその要素を破棄 "しない" ことに注意してください。

メンバー

deque::assign (STL/CLR)

すべての要素を置換します。

構文

void assign(size_type count, value_type val);
template<typename InIt>
    void assign(InIt first, InIt last);
void assign(System::Collections::Generic::IEnumerable<Value>^ right);

パラメーター

count
挿入する要素の数。

first
挿入する範囲の先頭。

last
挿入する範囲の末尾。

right
挿入する列挙型。

val
挿入する要素の値。

解説

最初のメンバー関数は、被制御シーケンスを、値 val の count 個の要素の繰り返しで置き換えます。 これを使って、すべて同じ値を持つ要素をコンテナーに格納します。

InIt が整数型である場合、2 番目のメンバー関数は assign((size_type)first, (value_type)last) と同じように動作します。 それ以外の場合は、被制御シーケンスをシーケンス [first, last) で置き換えます。 これを使用して、被制御シーケンスを別のシーケンスにコピーします。

3 番目のメンバー関数は、被制御シーケンスを列挙子 right によって指定されたシーケンスに置き換えます。 これを使用して、被制御シーケンスを列挙子によって記述されたシーケンスのコピーにします。

例

// cliext_deque_assign.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // assign a repetition of values
    cliext::deque<wchar_t> c2;
    c2.assign(6, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign an iterator range
    c2.assign(c1.begin(), c1.end() - 1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign an enumeration
    c2.assign(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

x x x x x x
a b
a b c

deque::at (STL/CLR)

指定した位置にある要素にアクセスします。

構文

reference at(size_type pos);

パラメーター

pos
アクセスする要素の位置。

解説

このメンバー関数は、位置 pos にある被制御シーケンスの要素への参照を返します。これを使用して、既知の位置を持つ要素の読み取りまたは書き込みを行います。

例

// cliext_deque_at.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using at
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1.at(i));
    System::Console::WriteLine();

    // change an entry and redisplay
    c1.at(1) = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

deque::back (STL/CLR)

最後の要素にアクセスします。

構文

reference back();

解説

このメンバー関数は、被制御シーケンスの最後の要素への参照を返します。これを空にすることはできません。 最後の要素が存在することがわかっている場合は、それにアクセスするために使用します。

例

// cliext_deque_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last item
    System::Console::WriteLine("back() = {0}", c1.back());

    // alter last item and reinspect
    c1.back() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back() = c
a b x

deque::back_item (STL/CLR)

最後の要素にアクセスします。

構文

property value_type back_item;

解説

このプロパティは、被制御シーケンスの最後の要素 (これを空にすることはできません) にアクセスします。 これは、最後の要素が存在することがわかっている場合に、その読み取りまたは書き込みを行うために使用します。

例

// cliext_deque_back_item.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last item
    System::Console::WriteLine("back_item = {0}", c1.back_item);

    // alter last item and reinspect
    c1.back_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back_item = c
a b x

deque::begin (STL/CLR)

被制御シーケンスの先頭を指定します。

構文

iterator begin();

解説

このメンバー関数は、被制御シーケンスの最初の要素 (または空のシーケンスの末尾の次の位置) を指定するランダムアクセス反復子を返します。 これを使用して、被制御シーケンスの current の先頭を指定する反復子を取得しますが、被制御シーケンスの長さが変わると状態が変化する可能性があります。

例

// cliext_deque_begin.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    cliext::deque<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);

    // alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*begin() = a
*++begin() = b
x y c

deque::clear (STL/CLR)

すべての要素を削除します。

構文

void clear();

解説

メンバー関数は、実質的に deque::erase (STL/CLR)( deque::begin (STL/CLR)(), deque::end (STL/CLR)())を呼び出します。 被制御シーケンスが空であることを確実にするために使います。

例

// cliext_deque_clear.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    // add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

deque::const_iterator (STL/CLR)

被制御シーケンスの定数反復子の型です。

構文

typedef T2 const_iterator;

解説

この型は、被制御シーケンスの定数ランダムアクセス反復子として使用できる未指定の T2 型のオブジェクトを表します。

例

// cliext_deque_const_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::deque<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::const_reference (STL/CLR)

要素への定数参照の型です。

構文

typedef value_type% const_reference;

解説

この型は、要素への定数参照を表します。

例

// cliext_deque_const_reference.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    cliext::deque<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        cliext::deque<wchar_t>::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::const_reverse_iterator (STL/CLR)

被制御シーケンスの定数反転反復子の型です。

構文

typedef T4 const_reverse_iterator;

解説

この型は、被制御シーケンスの定数反転反復子として使用できる未指定の T4 型のオブジェクトを表します。

例

// cliext_deque_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" reversed
    cliext::deque<wchar_t>::const_reverse_iterator crit = c1.rbegin();
    cliext::deque<wchar_t>::const_reverse_iterator crend = c1.rend();
    for (; crit != crend; ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

deque::deque (STL/CLR)

コンテナー オブジェクトを構築します。

構文

deque();
deque(deque<Value>% right);
deque(deque<Value>^ right);
explicit deque(size_type count);
deque(size_type count, value_type val);
template<typename InIt>
    deque(InIt first, InIt last);
deque(System::Collections::Generic::IEnumerable<Value>^ right);

パラメーター

count
挿入する要素の数。

first
挿入する範囲の先頭。

last
挿入する範囲の末尾。

right
挿入するオブジェクトまたは範囲。

val
挿入する要素の値。

解説

コンストラクター:

deque();

は、要素なしで被制御シーケンスを初期化します。 これを使用して、空の初期被制御シーケンスを指定します。

コンストラクター:

deque(deque<Value>% right);

は、被制御シーケンスをシーケンス [right.begin(), right.end()) で初期化します。 これを使用して、deque オブジェクト right によって制御されるシーケンスのコピーである最初の被制御シーケンスを指定します。 反復子について詳しくは、「deque::begin (STL/CLR)」および「deque::end (STL/CLR)」をご覧ください。

コンストラクター:

deque(deque<Value>^ right);

は、被制御シーケンスをシーケンス [right->begin(), right->end()) で初期化します。 これを使用して、ハンドルが right の deque オブジェクトによって制御されるシーケンスのコピーである最初の被制御シーケンスを指定します。

コンストラクター:

explicit deque(size_type count);

は、それぞれ値が value_type() の count 個の要素で被制御シーケンスを初期化します。 これを使って、すべて既定値を持つ要素をコンテナーに格納します。

コンストラクター:

deque(size_type count, value_type val);

は、それぞれ値が val の count 個の要素で被制御シーケンスを初期化します。 これを使って、すべて同じ値を持つ要素をコンテナーに格納します。

コンストラクター:

template<typename InIt>

deque(InIt first, InIt last);

は、被制御シーケンスをシーケンス [first, last) で初期化します。 これを使用して、被制御シーケンスを別のシーケンスのコピーにします。

コンストラクター:

deque(System::Collections::Generic::IEnumerable<Value>^ right);

は、列挙子 right によって指定されたシーケンスで被制御シーケンスを初期化します。 これを使用して、被制御シーケンスを列挙子によって記述された別のシーケンスのコピーにします。

例

// cliext_deque_construct.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
// construct an empty container
    cliext::deque<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    // construct with a repetition of default values
    cliext::deque<wchar_t> c2(3);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

    // construct with a repetition of values
    cliext::deque<wchar_t> c3(6, L'x');
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range
    cliext::deque<wchar_t>::iterator it = c3.end();
    cliext::deque<wchar_t> c4(c3.begin(), --it);
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration
    cliext::deque<wchar_t> c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    cliext::deque<wchar_t> c7(c3);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying a container handle
    cliext::deque<wchar_t> c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
    }

size() = 0
0 0 0
x x x x x x
x x x x x
x x x x x x
x x x x x x
x x x x x x

deque::difference_type (STL/CLR)

2 つの要素間の符号付きの距離を表す型です。

構文

typedef int difference_type;

解説

この型は、署名された要素の数を表します。

例

// cliext_deque_difference_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    cliext::deque<wchar_t>::difference_type diff = 0;
    for (cliext::deque<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it) ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (cliext::deque<wchar_t>::iterator it = c1.end();
        it != c1.begin(); --it) --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3
begin()-end() = -3

deque::empty (STL/CLR)

要素が存在しないかどうかをテストします。

構文

bool empty();

解説

このメンバー関数は、被制御シーケンスが空の場合に true を返します。 これは deque::size (STL/CLR)() == 0 と同じです。 deque が空かどうかをテストする場合に使います。

例

// cliext_deque_empty.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

a b c
size() = 3
empty() = False
size() = 0
empty() = True

deque::end (STL/CLR)

被制御シーケンスの末尾を指定します。

構文

iterator end();

解説

このメンバー関数は、被制御シーケンスの末尾を越えたところを示すランダムアクセス反復子を返します。 これを使用して、被制御シーケンスの current の末尾を指定する反復子を取得しますが、被制御シーケンスの長さが変わると状態が変わる可能性があります。

例

// cliext_deque_end.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last two items
    cliext::deque<wchar_t>::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);

    // alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --end() = b
*--end() = c
a x y

deque::erase (STL/CLR)

指定した位置にある要素を削除します。

構文

iterator erase(iterator where);
iterator erase(iterator first, iterator last);

パラメーター

first
消去する範囲の先頭。

last
消去する範囲の末尾。

where
消去する要素。

解説

1 番目のメンバー関数は、where によってポイントされている被制御シーケンスの要素を削除します。 1 つの要素を削除する場合に使います。

2 番目のメンバー関数は、範囲 [first, last) の被制御シーケンスの要素を削除します。 0 個以上の連続する要素を削除する場合に、これを使用します。

両方のメンバー関数が、削除された要素の後の最初の残存要素を指定する反復子を返します。このような要素が存在しない場合は、deque::end (STL/CLR)() が返されます。

要素を消去する場合、要素のコピー数は、消去の終わりとシーケンスの近端の間にある要素の数に比例します。 (シーケンスの両端で 1 つ以上の要素を消去すると、要素のコピーは行われません。)

例

// cliext_deque_erase.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

    // add elements and display " b c d e"
    c1.push_back(L'd');
    c1.push_back(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase all but end
    cliext::deque<wchar_t>::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

deque::front (STL/CLR)

最初の要素にアクセスします。

構文

reference front();

解説

このメンバー関数は、被制御シーケンスの最初の要素への参照を返します。被制御シーケンスを空にすることはできません。 これは、最初の要素が存在することがわかっている場合に、その読み取りまたは書き込みを行うために使用します。

例

// cliext_deque_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first item
    System::Console::WriteLine("front() = {0}", c1.front());

    // alter first item and reinspect
    c1.front() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front() = a
x b c

deque::front_item (STL/CLR)

最初の要素にアクセスします。

構文

property value_type front_item;

解説

このプロパティは、被制御シーケンスの最初の要素 (これを空にすることはできません) にアクセスします。 これは、最初の要素が存在することがわかっている場合に、その読み取りまたは書き込みを行うために使用します。

例

// cliext_deque_front_item.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first item
    System::Console::WriteLine("front_item = {0}", c1.front_item);

    // alter first item and reinspect
    c1.front_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front_item = a
x b c

deque::generic_container (STL/CLR)

コンテナーのジェネリック インターフェイスの型です。

構文

typedef Microsoft::VisualC::StlClr::
    IDeque<generic_value>
    generic_container;

解説

この型は、このテンプレート コンテナー クラスのジェネリック インターフェイスを表します。

例

// cliext_deque_generic_container.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(gc1->end(), L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify original and display generic
    c1.push_back(L'e');

    System::Collections::IEnumerator^ enum1 =
        gc1->GetEnumerator();
    while (enum1->MoveNext())
        System::Console::Write("{0} ", enum1->Current);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

deque::generic_iterator (STL/CLR)

コンテナーのジェネリック インターフェイスで使用する反復子の型です。

構文

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerRandomAccessIterator<generic_value> generic_iterator;

解説

この型は、このテンプレート コンテナー クラスのジェネリック インターフェイスで使用できるジェネリック反復子を表します。

例

// cliext_deque_generic_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::deque<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

deque::generic_reverse_iterator (STL/CLR)

コンテナーのジェネリック インターフェイスで使用する反転反復子の型です。

構文

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value> generic_reverse_iterator;

解説

この型は、このテンプレート コンテナー クラスのジェネリック インターフェイスで使用できるジェネリック反転反復子を表します。

例

// cliext_deque_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::deque<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a c c

deque::generic_value (STL/CLR)

コンテナーのジェネリック インターフェイスで使用する要素の型です。

構文

typedef GValue generic_value;

解説

この型は、このテンプレート コンテナー クラスのジェネリック インターフェイスで使用する、格納されている要素の値を記述する GValue 型のオブジェクトを表します。

例

// cliext_deque_generic_value.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::deque<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

deque::insert (STL/CLR)

指定した位置に要素を追加します。

構文

iterator insert(iterator where, value_type val);
void insert(iterator where, size_type count, value_type val);
template<typename InIt>
    void insert(iterator where, InIt first, InIt last);
void insert(iterator where,
    System::Collections::Generic::IEnumerable<Value>^ right);

パラメーター

count
挿入する要素の数。

first
挿入する範囲の先頭。

last
挿入する範囲の末尾。

right
挿入する列挙型。

val
挿入する要素の値。

where
コンテナー内の挿入位置 (この前)。

解説

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

最初のメンバー関数は、値 val を持つ要素を挿入し、新しく挿入された要素を指定する反復子を返します。 反復子によって指定された場所の前に 1 つの要素を挿入するために使用します。

2 番目のメンバー関数は、値 val の要素を count 個挿入します。 すべてが同じ値のコピーである 0 個以上の連続する要素を挿入するために使用します。

InIt が整数型である場合、3 番目のメンバー関数は insert(where, (size_type)first, (value_type)last) と同じように動作します。 それ以外の場合は、シーケンス [first, last) が挿入されます。 別のシーケンスからコピーした 0 個以上の連続する要素を挿入する場合に、これを使用します。

4 つ目のメンバー関数は、right によって指定されたシーケンスを挿入します。 列挙子によって記述されたシーケンスを挿入する場合に、これを使用します。

1 つの要素を挿入する場合、要素のコピー数は、挿入ポイントとシーケンスの近端の間にある要素の数に比例します。 (シーケンスのいずれかの末尾に 1 つ以上の要素を挿入する場合、要素のコピーは発生しません)。 InIt が入力反復子の場合、3 番目のメンバー関数は、シーケンス内の各要素に対して 1 つの挿入を効果的に実行します。 それ以外で、N 要素を挿入する場合、要素のコピー数は、挿入ポイントとシーケンスの近端の間にある要素の数に N を加えた数に比例します。

例

// cliext_deque_insert.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value using iterator
    cliext::deque<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("insert(begin()+1, L'x') = {0}",
        *c1.insert(++it, L'x'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a repetition of values
    cliext::deque<wchar_t> c2;
    c2.insert(c2.begin(), 2, L'y');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an iterator range
    it = c1.end();
    c2.insert(c2.end(), c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an enumeration
    c2.insert(c2.begin(),   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(begin()+1, L'x') = x
a x b c
y y
y y a x b
a x b c y y a x b

deque::iterator (STL/CLR)

被制御シーケンスの反復子の型です。

構文

typedef T1 iterator;

解説

この型は、被制御シーケンスのランダムアクセス反復子として使用できる未指定の T1 型のオブジェクトを表します。

例

// cliext_deque_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::deque<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();

    // alter first element and redisplay
    it = c1.begin();
    *it = L'x';
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c
x b c

deque::operator!= (STL/CLR)

deque が等しくないかどうかの比較です。

構文

template<typename Value>
    bool operator!=(deque<Value>% left,
        deque<Value>% right);

パラメーター

left
比較する左のコンテナー。

right
比較する右のコンテナー。

解説

この演算子関数は、!(left == right) を返します。 2 つの deque を要素ごとに比較する際、left が right と同じ順序付けでないかどうかをテストする場合に使います。

例

// cliext_deque_operator_ne.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True

deque::operator(STL/CLR)

指定した位置にある要素にアクセスします。

構文

reference operator[](size_type pos);

パラメーター

pos
アクセスする要素の位置。

解説

メンバー演算子は、位置 pos にある要素への参照を返します。これは、位置がわかっている要素にアクセスするために使用します。

例

// cliext_deque_operator_sub.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using subscripting
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();

    // change an entry and redisplay
    c1[1] = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

deque::pop_back (STL/CLR)

最後の要素を削除します。

構文

void pop_back();

解説

このメンバー関数は、被制御シーケンス (これは空でない必要があります) の最後の要素を削除します。 後ろの 1 つの要素分 deque を短くする場合に使います。

例

// cliext_deque_pop_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // pop an element and redisplay
    c1.pop_back();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b

deque::pop_front (STL/CLR)

最初の要素を削除します。

構文

void pop_front();

解説

このメンバー関数は、被制御シーケンスの最初の要素を削除します。これを空にすることはできません。 これは、deque を前の 1 つの要素分短くするために使用します。

例

// cliext_deque_pop_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // pop an element and redisplay
    c1.pop_front();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
b c

deque::push_back (STL/CLR)

新規に末尾の要素を追加します。

構文

void push_back(value_type val);

解説

このメンバー関数は、被制御シーケンスの末尾に値 val を持つ要素を挿入します。 これは、deque に別の要素を追加するために使用します。

例

// cliext_deque_push_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::push_front (STL/CLR)

新しい最初の要素を追加します。

構文

void push_front(value_type val);

解説

このメンバー関数は、被制御シーケンスの先頭に値 val を持つ要素を挿入します。 これは、deque の前に別の要素を追加するために使用します。

例

// cliext_deque_push_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_front(L'a');
    c1.push_front(L'b');
    c1.push_front(L'c');

    // display contents " c b a"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c b a

deque::rbegin (STL/CLR)

反転被制御シーケンスの先頭を指定します。

構文

reverse_iterator rbegin();

解説

このメンバー関数は、被制御シーケンスの最後の要素 (または空のシーケンスの先頭の次の位置) を指定する反転反復子を返します。 したがって、逆シーケンスの beginning を指定します。 これを使用して、被制御シーケンスの current の先頭を逆の順序で指定する反復子を取得しますが、被制御シーケンスの長さが変わると状態が変わる可能性があります。

例

// cliext_deque_rbegin.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);

    // alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b
a y x

deque::reference (STL/CLR)

要素への参照の型です。

構文

typedef value_type% reference;

解説

この型は、要素への参照を表します。

例

// cliext_deque_reference.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    cliext::deque<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::deque<wchar_t>::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();

    // modify contents " a b c"
    for (it = c1.begin(); it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::deque<wchar_t>::reference ref = *it;

        ref += (wchar_t)(L'A' - L'a');
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c
A B C

deque::rend (STL/CLR)

反転被制御シーケンスの末尾を指定します。

構文

reverse_iterator rend();

解説

このメンバー関数は、被制御シーケンスの先頭を超えた位置を示す反転反復子を返します。 したがって、逆シーケンスの end を指定します。 これを使用して、被制御シーケンスの current の末尾を逆順に指定する反復子を取得しますが、被制御シーケンスの長さが変化すると、その状態が変化する可能性があります。

例

// cliext_deque_rend.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);

    // alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a
y x c

deque::resize (STL/CLR)

要素の数を変更します。

構文

void resize(size_type new_size);
void resize(size_type new_size, value_type val);

パラメーター

new_size
被制御シーケンスの新しいサイズ。

val
埋め込み要素の値。

解説

メンバー関数は両方とも、deque::size (STL/CLR)() がそれ以降 new_size を確実に返すようにします。 被制御シーケンスを長くする必要がある場合、最初のメンバー関数では値 value_type() で要素を追加し、2 番目のメンバー関数では値 val で要素を追加します。 制御シーケンスを短くするために、両方のメンバー関数は、最後の要素 deque::size (STL/CLR)() - new_size 時間を効果的に消去します。 これを使用して、現在の被制御シーケンスをトリミングまたはパディングすることでシーケンスのサイズを確実に new_size にします。

例

// cliext_deque_resize.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
// construct an empty container and pad with default values
    cliext::deque<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());
    c1.resize(4);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

    // resize to empty
    c1.resize(0);
    System::Console::WriteLine("size() = {0}", c1.size());

    // resize and pad
    c1.resize(5, L'x');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
0 0 0 0
size() = 0
x x x x x

deque::reverse_iterator (STL/CLR)

被制御シーケンスの反転反復子の型です。

構文

typedef T3 reverse_iterator;

解説

この型は、被制御シーケンスの反転反復子として使用できる未指定の T3 型のオブジェクトを表します。

例

// cliext_deque_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" reversed
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();

    // alter first element and redisplay
    rit = c1.rbegin();
    *rit = L'x';
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a
x b a

deque::size (STL/CLR)

要素の数をカウントします。

構文

size_type size();

解説

このメンバー関数は、被制御シーケンスの長さを返します。 被制御シーケンス内の現在の要素の数を特定する場合に使います。 シーケンスのサイズが 0 以外かどうかだけを確認する場合は、「deque::empty (STL/CLR)()」を参照してください。

例

// cliext_deque_size.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

deque::size_type (STL/CLR)

2 つの要素間の距離を表す符号付きの型です。

構文

typedef int size_type;

解説

この型は、負でない要素数を表します。

例

// cliext_deque_size_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    cliext::deque<wchar_t>::size_type diff = c1.end() - c1.begin();
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3

deque::swap (STL/CLR)

2 つのコンテナーのコンテンツを交換します。

構文

void swap(deque<Value>% right);

パラメーター

right
コンテンツを交換するコンテナー。

解説

このメンバー関数は、*this と right の間で被制御シーケンスを交換します。 一定時間に実行し、例外をスローしません。 2 つのコンテナーのコンテンツを簡単に交換する方法として、これを使用します。

例

// cliext_deque_swap.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct another container with repetition of values
    cliext::deque<wchar_t> c2(5, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
x x x x x
x x x x x
a b c

deque::to_array (STL/CLR)

被制御シーケンスを新しい配列にコピーします。

構文

cli::array<Value>^ to_array();

解説

このメンバー関数は、被制御シーケンスを含む配列を返します。 配列形式の被制御シーケンスのコピーを取得する場合に、これを使用します。

例

// cliext_deque_to_array.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.push_back(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

deque::value_type (STL/CLR)

要素の型。

構文

typedef Value value_type;

解説

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

例

// cliext_deque_value_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using value_type
    for (cliext::deque<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        {   // store element in value_type object
        cliext::deque<wchar_t>::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

operator< (deque) (STL/CLR)

deque がより小さいかどうかの比較です。

構文

template<typename Value>
    bool operator<(deque<Value>% left,
        deque<Value>% right);

パラメーター

left
比較する左のコンテナー。

right
比較する右のコンテナー。

解説

この演算子関数は、!(right[i] < left[i]) の最小の位置である i について、left[i] < right[i] も true である場合に true を返します。 それ以外の場合は、left->size() < right->size() を返します。2 つの deque を要素ごとに比較する際、left が right より前に順序づけされているかどうかをテストする場合に使います。

例

// cliext_deque_operator_lt.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True

operator<= (deque) (STL/CLR)

deque が以下であるかどうかの比較です。

構文

template<typename Value>
    bool operator<=(deque<Value>% left,
        deque<Value>% right);

パラメーター

left
比較する左のコンテナー。

right
比較する右のコンテナー。

解説

この演算子関数は、!(right < left) を返します。 2 つの deque を要素ごとに比較する際、left が right より後に順序づけされていないかどうかをテストする場合に使います。

例

// cliext_deque_operator_le.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

operator= (deque) (STL/CLR)

被制御シーケンスを置き換えます。

構文

deque<Value>% operator=(deque<Value>% right);

パラメーター

right
コピーするコンテナー。

解説

このメンバー演算子を使用すると、right がオブジェクトにコピーされ、*this が返されます。 これを使用して、被制御シーケンスを right の被制御シーケンスのコピーと置き換えます。

例

// cliext_deque_operator_as.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2 = c1;
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

operator== (deque) (STL/CLR)

deque が等しいかどうかの比較です。

構文

template<typename Value>
    bool operator==(deque<Value>% left,
        deque<Value>% right);

パラメーター

left
比較する左のコンテナー。

right
比較する右のコンテナー。

解説

演算子関数は、left および right によって制御されるシーケンスの長さが同じで、各位置ileft[i] == right[i]場合にのみ true を返します。 2 つの deque を要素ごとに比較する際、left が right と同じ順序付けかどうかをテストする場合に使います。

例

// cliext_deque_operator_eq.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False

operator> (deque) (STL/CLR)

deque がより大きいかどうかの比較です。

構文

template<typename Value>
    bool operator>(deque<Value>% left,
        deque<Value>% right);

パラメーター

left
比較する左のコンテナー。

right
比較する右のコンテナー。

解説

演算子関数は right < leftを返します。 2 つの deque を要素ごとに比較する際、left が right より後に順序づけされているかどうかをテストする場合に使います。

例

// cliext_deque_operator_gt.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True

operator>= (deque) (STL/CLR)

deque が以上であるかどうかの比較です。

構文

template<typename Value>
    bool operator>=(deque<Value>% left,
        deque<Value>% right);

パラメーター

left
比較する左のコンテナー。

right
比較する右のコンテナー。

解説

演算子関数は !(left < right)を返します。 2 つの deque を要素ごとに比較する際、left が right より前に順序づけされていないかどうかをテストする場合に使います。

例

// cliext_deque_operator_ge.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False