`vector` クラス

[アーティクル]
10/12/2023

C++ 標準ライブラリの vector クラスは、シーケンスコンテナーのクラステンプレートです。 vector は、指定された型の要素を線形の配置に格納し、任意の要素に対する高速なランダムアクセスを可能にします。 vector は、ランダムアクセスのパフォーマンスを重視するシーケンスに適したコンテナーです。

構文

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

パラメーター

Type
ベクターに格納される要素のデータ型。

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

解説

ベクターでは、シーケンスの末尾での挿入および削除に要する時間が一定です。ベクターの途中での要素の挿入または削除には、線形時間を要します。 deque クラスコンテナーは、シーケンスの先頭と末尾での挿入および削除が高速になります。 list クラスコンテナーは、シーケンス内の任意の位置での挿入および削除が高速になります。

ベクターの再割り当てが発生するのは、メンバー関数がベクターオブジェクトに含まれるシーケンスを現在の記憶域容量を超えて増やす必要がある場合です。その他の挿入や消去により、シーケンス内のさまざまな記憶域のアドレスが変わることがあります。そのような場合は常に、シーケンスのうち変更された部分を指す反復子または参照が無効になります。再割り当てが発生しない場合は、挿入/削除が行われた地点より前の反復子および参照のみ有効のままになります。

vector<bool> クラスは、bool 型の要素のためにクラステンプレート vector を完全に特殊化したものです。これは、特殊化で使用される基礎となる型のアロケーターを持ちます。

vector<bool> 参照クラスは、入れ子になったクラスで、このクラスのオブジェクトは vector<bool> オブジェクト内の要素 (単一ビット) への参照を提供できます。

メンバー

コンストラクター

名前	説明
`vector`	特定のサイズのベクター、特定の値の要素を持つベクター、特定の `allocator` を持つベクター、または他のベクターのコピーとして、ベクターを構築します。

Typedefs

名前	説明
`[allocator_type]`(#allocator_type)	vector オブジェクトの `allocator` クラスを表す型。
`const_iterator`	ベクター内の `const` 要素を読み取ることができるランダムアクセス反復子を提供する型。
`const_pointer`	ベクター内の `const` 要素へのポインターを提供する型。
`const_reference`	ベクターに格納されている `const` 要素への参照を提供する型。これは読み取りと `const` 操作の実行に使用されます。
`const_reverse_iterator`	ベクター内の任意の `const` 要素を読み取ることができるランダムアクセス反復子を提供する型。
`difference_type`	ベクターに含まれる 2 つの要素のアドレスの差を提供する型。
`iterator`	ベクター内の任意の要素を読み取り、または変更できるランダムアクセス反復子を提供する型。
`pointer`	ベクター内の要素へのポインターを提供する型。
`reference`	ベクターに格納されている要素への参照を提供する型。
`reverse_iterator`	反転ベクター内の要素を読み取り、または変更できるランダムアクセス反復子を提供する型。
`size_type`	ベクター内の要素の数をカウントする型。
`value_type`	ベクター内に格納されているデータ型を表す型。

関数

名前	説明
`assign`	ベクターを消去し、空のベクターに指定された要素をコピーします。
`at`	ベクター内の指定位置にある要素への参照を返します。
`back`	ベクターの最後の要素への参照を返します。
`begin`	ベクター内の最初の要素を示すランダムアクセス反復子を返します。
`capacity`	追加の記憶域を割り当てずにベクターに収容できる要素の数を返します。
`cbegin`	ベクター内の最初の要素を示すランダムアクセスの定数反復子を返します。
`cend`	ベクターの末尾の次の位置を指し示すランダムアクセス定数反復子を返します。
`crbegin`	反転ベクター内の最初の要素への定数反復子を返します。
`crend`	反転ベクター内の末尾の要素への定数反復子を返します。
`clear`	ベクターの要素を消去します。
`data`	ベクター内の最初の要素へのポインターを返します。
`emplace`	その場で構築した要素をベクター内の指定位置に挿入します。
`emplace_back`	その場で構築した要素をベクターの末尾に追加します。
`empty`	ベクターコンテナーが空かどうかをテストします。
`end`	ベクターの末尾を指し示すランダムアクセス反復子を返します。
`erase`	指定した位置からベクター内の要素または要素範囲を削除します。
`front`	ベクター内の最初の要素への参照を返します。
`get_allocator`	ベクターが使用する `allocator` クラスにオブジェクトを返します。
`insert`	ベクター内の指定位置に 1 つまたは複数の要素を挿入します。
`max_size`	ベクターの最大長を返します。
`pop_back`	ベクトルの末尾の要素を削除します。
`push_back`	ベクターの末尾に要素を追加します。
`rbegin`	逆順のベクターの最初の要素への反復子を返します。
`rend`	反転ベクター内の末尾に反復子を返します。
`reserve`	ベクターオブジェクトに最小の長さの記憶域を予約します。
`resize`	ベクターの新しいサイズを指定します。
`shrink_to_fit`	余分なキャパシティを破棄します。
`size`	ベクター内の要素の数を返します。
`swap`	2 つのベクターの要素を交換します。

演算子

名前	説明
`operator[]`	指定した位置における vector 要素への参照を返します。
`operator=`	ベクターの要素を、別のベクターのコピーで置き換えます。

`allocator_type`

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

typedef Allocator allocator_type;

解説

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

例

allocator_type の使用例については、get_allocator の例をご覧ください。

`assign`

ベクターを消去し、空のベクターに指定された要素をコピーします。

void assign(size_type count, const Type& value);
void assign(initializer_list<Type> init_list);

template <class InputIterator>
void assign(InputIterator first, InputIterator last);

パラメーター

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

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

count
ベクターに挿入される要素のコピーの数。

value
ベクターに挿入される要素の値。

init_list
挿入する要素を含む initializer_list。

解説

最初に、assign はベクター内の既存の要素を消去します。次に、assign は元のベクター内の指定された範囲の要素をベクターに挿入するか、指定された値の新しい要素のコピーをベクターに挿入します。

例

/ vector_assign.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> v1, v2, v3;

    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);
    v1.push_back(50);

    cout << "v1 = ";
    for (auto& v : v1){
        cout << v << " ";
    }
    cout << endl;

    v2.assign(v1.begin(), v1.end());
    cout << "v2 = ";
    for (auto& v : v2){
        cout << v << " ";
    }
    cout << endl;

    v3.assign(7, 4);
    cout << "v3 = ";
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;

    v3.assign({ 5, 6, 7 });
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;
}

`at`

ベクター内の指定位置にある要素への参照を返します。

reference at(size_type position);

const_reference at(size_type position) const;

パラメーター

position
ベクター内で参照する要素を示す添字または位置の番号。

戻り値

引数に記述された要素への参照。 position がベクターのサイズより大きい場合、at は例外をスローします。

解説

at の戻り値が const_reference に割り当てられている場合、vector オブジェクトを変更することはできません。 at の戻り値が reference に割り当てられている場合、vector オブジェクトを変更できます。

例

// vector_at.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const int &i = v1.at( 0 );
   int &j = v1.at( 1 );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`back`

ベクターの最後の要素への参照を返します。

reference back();

const_reference back() const;

戻り値

ベクターの最後の要素。ベクターが空の場合、戻り値は未定義になります。

解説

back の戻り値が const_reference に割り当てられている場合、vector オブジェクトを変更することはできません。 back の戻り値が reference に割り当てられている場合、vector オブジェクトを変更できます。

_ITERATOR_DEBUG_LEVEL を 1 または 2 に定義して使用してコンパイルすると、空の vector 内の要素にアクセスしようとした場合に実行時エラーが発生します。詳細については、「Checked Iterators」を参照してください。

例

// vector_back.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main() {
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.back( );
   const int& ii = v1.front( );

   cout << "The last integer of v1 is " << i << endl;
   i--;
   cout << "The next-to-last integer of v1 is "<< ii << endl;
}

`begin`

ベクター内の最初の要素を示すランダムアクセス反復子を返します。

const_iterator begin() const;

iterator begin();

戻り値

vector 内の最初の要素、または空の vector の次の位置を指すランダムアクセス反復子。返される値は、常に vector::end と比較して有効なことを確認してください。

解説

begin の戻り値が vector::const_iterator に割り当てられる場合、vector オブジェクトを変更できません。 begin の戻り値が vector::iterator に割り当てられる場合、vector オブジェクトを変更できます。

例

// vector_begin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::iterator c1_Iter;
    vector<int>::const_iterator c1_cIter;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_Iter = c1.begin();
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_Iter = c1.begin();
    *c1_Iter = 20;
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    // The following line would be an error because iterator is const
    // *c1_cIter = 200;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`capacity`

追加の記憶域を割り当てずにベクターに収容できる要素の数を返します。

size_type capacity() const;

戻り値

ベクターに割り当てられている記憶域の現在の長さ。

解説

増加分を収容できる十分なメモリが割り当てられている場合は、メンバー関数 resize のほうが効率的に動作します。割り当てられるメモリの量を指定するには、メンバー関数 reserve を使用します。

例

// vector_capacity.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 1 );
   cout << "The length of storage allocated is "
        << v1.capacity( ) << "." << endl;

   v1.push_back( 2 );
   cout << "The length of storage allocated is now "
        << v1.capacity( ) << "." << endl;
}

The length of storage allocated is 1.
The length of storage allocated is now 2.

`cbegin`

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

const_iterator cbegin() const;

戻り値

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

解説

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

begin() メンバー関数の代わりにこのメンバー関数を使用して、戻り値が const_iterator になることを保証できます。通常は、次の例に示すように auto 型推論キーワードと一緒に使用します。例では、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;

戻り値

ベクターの const 末尾超え反復子。ベクターの最後の要素の次の要素を指します。この要素はプレースホルダーであるため、逆参照しないでください。比較にのみ使用してください。ベクターが空の場合は、vector::cend() == vector::cbegin() です。

解説

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

end() メンバー関数の代わりにこのメンバー関数を使用して、戻り値が const_iterator になることを保証できます。通常は、次の例に示すように auto 型推論キーワードと一緒に使用します。例では、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();

例

// vector_clear.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "The size of v1 is " << v1.size( ) << endl;
   v1.clear( );
   cout << "The size of v1 after clearing is " << v1.size( ) << endl;
}

The size of v1 is 3
The size of v1 after clearing is 0

`const_iterator`

ベクター内の const 要素を読み取ることができるランダムアクセス反復子を提供する型。

typedef implementation-defined const_iterator;

解説

const_iterator 型で要素の値を変更することはできません。

例

const_iterator の使用例については、back の例をご覧ください。

`const_pointer`

ベクター内の const 要素へのポインターを提供する型。

typedef typename Allocator::const_pointer const_pointer;

解説

const_pointer 型で要素の値を変更することはできません。

ベクター要素にアクセスするために、より一般的に使用されるのは反復子です。

`const_reference`

ベクターに格納されている const 要素への参照を提供する型。これは読み取りと const 操作の実行に使用されます。

typedef typename Allocator::const_reference const_reference;

解説

const_reference 型で要素の値を変更することはできません。

例

// vector_const_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const vector <int> v2 = v1;
   const int &i = v2.front( );
   const int &j = v2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

   // The following line would cause an error as v2 is const
   // v2.push_back( 30 );
}

The first element is 10
The second element is 20

`const_reverse_iterator`

ベクター内の任意の const 要素を読み取ることができるランダムアクセス反復子を提供する型。

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

解説

const_reverse_iterator 型は要素の値を変更できず、逆の順序でベクターを反復処理するために使用します。

例

反復子を宣言して使用する方法の例については、rbegin をご覧ください。

`crbegin`

反転ベクター内の最初の要素への定数反復子を返します。

const_reverse_iterator crbegin() const;

戻り値

反転された vector の最初の要素を指すか、反転されていない vector の最後の要素だったものを指す、定数逆順ランダムアクセス反復子。

解説

戻り値が crbegin の場合、vector オブジェクトは変更できません。

例

// vector_crbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`crend`

反転されたベクターの最後の要素の次の要素を指す、const 逆順の末尾超え反復子を返します。

const_reverse_iterator crend() const;

戻り値

反転されたベクターの const 逆順の末尾超え反復子。反転されたベクターの最後の要素の次の要素を指します。これは、反転されていないベクターの最初の要素の前の要素と同じです。この要素はプレースホルダーであるため、逆参照しないでください。比較にのみ使用してください。

解説

crend は、vector::cend が vector で使用されるのと同様に、反転された vector で使用されます。

戻り値が (適切にデクリメントされた) crend の場合、vector オブジェクトは変更できません。

crend を使用して、逆順反復子が vector の末尾に達したかどうかをテストできます。

crend によって返された値は逆参照しないでください。比較にのみ使用してください。

例

// vector_crend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`data`

ベクター内の最初の要素へのポインターを返します。

const_pointer data() const;

pointer data();

戻り値

vector 内の最初の要素へのポインター、または空の vector の次の位置を指すポインター。

例

// vector_data.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::pointer c1_ptr;
    vector<int>::const_pointer c1_cPtr;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_cPtr = c1.data();
    for (size_t n = c1.size(); 0 < n; --n, c1_cPtr++)
    {
        cout << " " << *c1_cPtr;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_ptr = c1.data();
    *c1_ptr = 20;
    for (size_t n = c1.size(); 0 < n; --n, c1_ptr++)
    {
        cout << " " << *c1_ptr;
    }
    cout << endl;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`difference_type`

同じベクター内の要素を参照する 2 つの反復子の違いを提供する型。

typedef typename Allocator::difference_type difference_type;

解説

要素へのポインターにはそのアドレスが含まれるため、difference_type は 2 つのポインター間の要素の数と言うこともできます。

ベクター要素にアクセスするために、より一般的に使用されるのは反復子です。

例

// vector_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <vector>
#include <algorithm>

int main( )
{
   using namespace std;

   vector <int> c1;
   vector <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 30 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 10 );
   c1.push_back( 30 );
   c1.push_back( 20 );

   c1_Iter = c1.begin( );
   c2_Iter = c1.end( );

   vector <int>::difference_type   df_typ1, df_typ2, df_typ3;

   df_typ1 = count( c1_Iter, c2_Iter, 10 );
   df_typ2 = count( c1_Iter, c2_Iter, 20 );
   df_typ3 = count( c1_Iter, c2_Iter, 30 );
   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";
   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";
   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";
}

The number '10' is in c1 collection 1 times.
The number '20' is in c1 collection 2 times.
The number '30' is in c1 collection 3 times.

`emplace`

その場で構築した要素をベクター内の指定位置に挿入します。

template <class... Types>
iterator emplace(
    const_iterator position,
    Types&&... args);

パラメーター

position
最初の要素を挿入する vector 内の位置。

args
コンストラクター引数。この関数は、提供された引数に基づいてコンストラクターのどのオーバーロードを呼び出すかを推測します。

戻り値

この関数は、新しい要素が vector 内に挿入された位置を指す反復子を返します。

解説

挿入操作は負荷が高くなることがあります。vector のパフォーマンスに関する説明は vector クラスを参照してください。

例

// vector_emplace.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.emplace( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
vv1[0] = 10 20 30

`emplace_back`

その場で構築した要素をベクターの末尾に追加します。

template <class... Types>
void emplace_back(Types&&... args);

パラメーター

args
コンストラクター引数。この関数は、提供された引数に基づいてコンストラクターのどのオーバーロードを呼び出すかを推測します。

例

#include <vector>
struct obj
{
   obj(int, double) {}
};

int main()
{
   std::vector<obj> v;
   v.emplace_back(1, 3.14); // obj in created in place in the vector
}

`empty`

ベクターが空かどうかをテストします。

bool empty() const;

戻り値

ベクターが空の場合は true。ベクターが空でない場合は false。

例

// vector_empty.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );

   if ( v1.empty( ) )
      cout << "The vector is empty." << endl;
   else
      cout << "The vector is not empty." << endl;
}

The vector is not empty.

`end`

ベクターの最後の要素の次の要素を指す、末尾超え反復子を返します。

iterator end();

const_iterator end() const;

戻り値

ベクターの末尾超え反復子。ベクターの最後の要素の次の要素を指します。この要素はプレースホルダーであるため、逆参照しないでください。比較にのみ使用してください。ベクターが空の場合は、vector::end() == vector::begin() です。

解説

end の戻り値が const_iterator 型の変数に割り当てられている場合、vector オブジェクトを変更することはできません。 end の戻り値が iterator 型の変数に割り当てられている場合、vector オブジェクトを変更できます。

例

// vector_end.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>
int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_Iter = v1.begin( ) ; v1_Iter != v1.end( ) ; v1_Iter++ )
      cout << *v1_Iter << endl;
}

1
2

`erase`

指定した位置からベクター内の要素または要素範囲を削除します。

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

パラメーター

position
ベクターから削除する要素の位置。

first
ベクターから削除する最初の要素の位置。

last
ベクターから削除する最後の要素の次の位置。

戻り値

削除した要素の後に残る最初の要素を指定する反復子。このような要素が存在しない場合は、ベクターの末尾へのポインター。

例

// vector_erase.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );
   v1.push_back( 40 );
   v1.push_back( 50 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) + 1, v1.begin( ) + 3 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
}

v1 = 10 20 30 40 50
v1 = 20 30 40 50
v1 = 20 50

`front`

ベクター内の最初の要素への参照を返します。

reference front();

const_reference front() const;

戻り値

ベクターオブジェクト内の最初の要素への参照。ベクターが空の場合、戻り値は未定義になります。

解説

front の戻り値が const_reference に割り当てられている場合、vector オブジェクトを変更することはできません。 front の戻り値が reference に割り当てられている場合、vector オブジェクトを変更できます。

例

// vector_front.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.front( );
   const int& ii = v1.front( );

   cout << "The first integer of v1 is "<< i << endl;
   // by incrementing i, we move the front reference to the second element
   i++;
   cout << "Now, the first integer of v1 is "<< i << endl;
}

`get_allocator`

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

Allocator get_allocator() const;

戻り値

ベクターで使用されるアロケーター。

解説

vector クラスのアロケーターは、クラスがどのようにストレージを管理するかを指定します。 C++ 標準ライブラリコンテナークラスで提供される既定のアロケーターは、ほとんどのプログラミング要件に対応しています。独自のアロケータークラスを作成して使用することは、C++ における高度な機能の 1 つです。

例

// vector_get_allocator.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects that use the default allocator.
   vector<int> v1;
   vector<int, allocator<int> > v2 = vector<int, allocator<int> >(allocator<int>( )) ;

   // v3 will use the same allocator class as v1
   vector <int> v3( v1.get_allocator( ) );

   vector<int>::allocator_type xvec = v3.get_allocator( );
   // You can now call functions on the allocator class used by vec
}

`insert`

ベクター内の指定位置に、要素、複数の要素、または要素の範囲を挿入します。

iterator insert(
    const_iterator position,
    const Type& value);

iterator insert(
    const_iterator position,
    Type&& value);

void insert(
    const_iterator position,
    size_type count,
    const Type& value);

template <class InputIterator>
void insert(
    const_iterator position,
    InputIterator first,
    InputIterator last);

パラメーター

position
最初の要素を挿入するベクター内の位置。

value
ベクターに挿入される要素の値。

count
ベクターに挿入する要素の数。

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

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

戻り値

最初の 2 つの insert 関数は、新しい要素がベクターに挿入された位置を指す反復子を返します。

解説

前提条件として、first と last はベクター内の反復子である必要があります。それ以外の場合、動作は定義されません。挿入操作は負荷が高くなることがあります。vector のパフォーマンスに関する説明は vector クラスを参照してください。

例

// vector_insert.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.insert( v1.begin( ) + 1, 40 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
   v1.insert( v1.begin( ) + 2, 4, 50 );

   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   const auto v2 = v1;
   v1.insert( v1.begin( )+1, v2.begin( )+2, v2.begin( )+4 );
   cout << "v1 =";
   for (Iter = v1.begin( ); Iter != v1.end( ); Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.insert( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
v1 = 10 40 20 30
v1 = 10 40 50 50 50 50 20 30
v1 = 10 50 50 40 50 50 50 50 20 30
vv1[0] = 10 50 50 40 50 50 50 50 20 30

`iterator`

ベクター内の任意の要素を読み取り、または変更できるランダムアクセス反復子を提供する型。

typedef implementation-defined iterator;

解説

型 iterator は要素の値の変更に使用できます。

例

begin の例を参照してください。

`max_size`

ベクターの最大長を返します。

size_type max_size() const;

戻り値

ベクターの可能な最大長。

例

// vector_max_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   i = v1.max_size( );
   cout << "The maximum possible length of the vector is " << i << "." << endl;
}

`operator[]`

指定した位置における vector 要素への参照を返します。

reference operator[](size_type position);

const_reference operator[](size_type position) const;

パラメーター

position
vector 要素の位置。

戻り値

指定された位置がコンテナーのサイズ以上の場合、結果は未定義になります。

解説

operator[] の戻り値が const_reference に割り当てられている場合、vector オブジェクトを変更することはできません。 operator[] の戻り値が参照に割り当てられている場合、vector オブジェクトを変更できます。

_ITERATOR_DEBUG_LEVEL を 1 または 2 に定義して使用してコンパイルすると、ベクターの境界外の要素にアクセスしようとした場合に実行時エラーが発生します。詳細については、「Checked Iterators」を参照してください。

例

// vector_op_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   int& i = v1[1];
   cout << "The second integer of v1 is " << i << endl;
}

`operator=`

ベクターの要素を、別のベクターのコピーで置き換えます。

vector& operator=(const vector& right);

vector& operator=(vector&& right);

パラメーター

right
vector 内にコピーされる vector。

解説

vector では、operator= 内の既存の要素を消去した後、right の内容を vector 内にコピーまたは移動します。

例

// vector_operator_as.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int> v1, v2, v3;
   vector<int>::iterator iter;

   v1.push_back(10);
   v1.push_back(20);
   v1.push_back(30);
   v1.push_back(40);
   v1.push_back(50);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << *iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;
}

`pointer`

ベクター内の要素へのポインターを提供する型。

typedef typename Allocator::pointer pointer;

解説

型 pointer は要素の値の変更に使用できます。

例

// vector_pointer.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
    using namespace std;
    vector<int> v;
    v.push_back( 11 );
    v.push_back( 22 );

    vector<int>::pointer ptr = &v[0];
    cout << *ptr << endl;
    ptr++;
    cout << *ptr << endl;
    *ptr = 44;
    cout << *ptr << endl;
}

11
22
44

`pop_back`

ベクトルの末尾の要素を削除します。

void pop_back();

解説

コード例については、「vector::push_back()」をご覧ください。

`push_back`

ベクトルの末尾に要素を追加します。

void push_back(const T& value);

void push_back(T&& value);

パラメーター

value
ベクトルの末尾に追加する要素に割り当てる値。

例

// compile with: /EHsc /W4
#include <vector>
#include <iostream>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << "  " << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

int main()
{
    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(10 + i);
    }

    cout << "vector data: " << endl;
    print_collection(v);

    // pop_back() until it's empty, printing the last element as we go
    while (v.begin() != v.end()) {
        cout << "v.back(): "; print_elem(v.back()); cout << endl;
        v.pop_back();
    }
}

`rbegin`

逆順のベクターの最初の要素への反復子を返します。

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

戻り値

反転されたベクターの最初の要素を指すか、反転されていないベクターの最後の要素だったものを指す、逆順ランダムアクセス反復子。

解説

rbegin の戻り値が const_reverse_iterator に割り当てられている場合、vector オブジェクトを変更することはできません。 rbegin の戻り値が reverse_iterator に割り当てられている場合、vector オブジェクトを変更できます。

例

// vector_rbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.rbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`reference`

ベクターに格納されている要素への参照を提供する型。

typedef typename Allocator::reference reference;

例

vector クラスで reference を使用する方法の例については、at をご覧ください。

`rend`

反転されたベクターの最後の要素の次の要素を指す、逆順の末尾超え反復子を返します。

const_reverse_iterator rend() const;
reverse_iterator rend();

戻り値

反転されたベクターの逆順の末尾超え反復子。反転されたベクターの最後の要素の次の要素を指します。これは、反転されていないベクターの最初の要素の前の要素と同じです。この要素はプレースホルダーであるため、逆参照しないでください。比較にのみ使用してください。

解説

rend は、ベクターで end を使用するのと同様に、逆順のベクターで使用します。

rend の戻り値が const_reverse_iterator に割り当てられている場合、vector オブジェクトを変更することはできません。 rend の戻り値が reverse_iterator に割り当てられている場合、vector オブジェクトを変更できます。

rend を使用して、逆順反復子がベクターの末尾に達したかどうかをテストできます。

rend によって返された値は逆参照しないでください。比較にのみ使用してください。

例

// vector_rend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`reserve`

ベクターオブジェクトの記憶域の最小長を予約します。必要であれば、領域を割り当てます。

void reserve(size_type count);

パラメーター

count
ベクターに割り当てる記憶域の最小長。

例

// vector_reserve.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20

`resize`

ベクターの新しいサイズを指定します。

void resize(size_type new_size);
void resize(size_type new_size, Type value);

パラメーター

new_size
ベクターの新しいサイズ。

value
新しいサイズが元のサイズよりも大きい場合に、ベクターに追加される新しい要素の初期化値。この値を省略した場合、新しいオブジェクトは既定のコンストラクターを使用します。

解説

コンテナーのサイズが要求されたサイズ (new_size) よりも小さい場合、resize では要求されたサイズになるまで、ベクターに要素が追加されます。コンテナーのサイズが要求されたサイズよりも大きい場合、resize ではコンテナーのサイズが new_size になるまで、コンテナーの末尾に近い要素から順に削除されます。コンテナーの現在のサイズが要求されたサイズと同じ場合は、何も実行されません。

size はベクターの現在のサイズを反映します。

例

// vectorsizing.cpp
// compile with: /EHsc /W4
// Illustrates vector::reserve, vector::max_size,
// vector::resize, vector::resize, and vector::capacity.
//
// Functions:
//
//    vector::max_size - Returns maximum number of elements vector could
//                       hold.
//
//    vector::capacity - Returns number of elements for which memory has
//                       been allocated.
//
//    vector::size - Returns number of elements in the vector.
//
//    vector::resize - Reallocates memory for vector, preserves its
//                     contents if new size is larger than existing size.
//
//    vector::reserve - Allocates elements for vector to ensure a minimum
//                      size, preserving its contents if the new size is
//                      larger than existing size.
//
//    vector::push_back - Appends (inserts) an element to the end of a
//                        vector, allocating memory for it if necessary.
//
//////////////////////////////////////////////////////////////////////

// The debugger cannot handle symbols more than 255 characters long.
// The C++ Standard Library often creates symbols longer than that.
// The warning can be disabled:
//#pragma warning(disable:4786)

#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename C> void print(const string& s, const C& c) {
    cout << s;

    for (const auto& e : c) {
        cout << e << " ";
    }
    cout << endl;
}

void printvstats(const vector<int>& v) {
    cout << "   the vector's size is: " << v.size() << endl;
    cout << "   the vector's capacity is: " << v.capacity() << endl;
    cout << "   the vector's maximum size is: " << v.max_size() << endl;
}

int main()
{
    // declare a vector that begins with 0 elements.
    vector<int> v;

    // Show statistics about vector.
    cout << endl << "After declaring an empty vector:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Add one element to the end of the vector.
    v.push_back(-1);
    cout << endl << "After adding an element:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    for (int i = 1; i < 10; ++i) {
        v.push_back(i);
    }
    cout << endl << "After adding 10 elements:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(6);
    cout << endl << "After resizing to 6 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(9, 999);
    cout << endl << "After resizing to 9 elements with an initialization value of 999:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(12);
    cout << endl << "After resizing to 12 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Ensure there's room for at least 1000 elements.
    v.reserve(1000);
    cout << endl << "After vector::reserve(1000):" << endl;
    printvstats(v);

    // Ensure there's room for at least 2000 elements.
    v.resize(2000);
    cout << endl << "After vector::resize(2000):" << endl;
    printvstats(v);
}

`reverse_iterator`

反転ベクター内の要素を読み取り、または変更できるランダムアクセス反復子を提供する型。

typedef std::reverse_iterator<iterator> reverse_iterator;

解説

型 reverse_iterator は、逆の順序でベクターを反復処理するために使用します。

例

rbegin の例を参照してください。

`shrink_to_fit`

余分なキャパシティを破棄します。

void shrink_to_fit();

例

// vector_shrink_to_fit.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.shrink_to_fit();
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20
Current capacity of v1 = 1

`size`

ベクター内の要素の数を返します。

size_type size() const;

戻り値

ベクターの現在の長さ。

例

// vector_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   v1.push_back( 1 );
   i = v1.size( );
   cout << "Vector length is " << i << "." << endl;

   v1.push_back( 2 );
   i = v1.size( );
   cout << "Vector length is now " << i << "." << endl;
}

Vector length is 1.
Vector length is now 2.

`size_type`

ベクター内の要素の数をカウントする型。

typedef typename Allocator::size_type size_type;

例

capacity の例を参照してください。

`swap`

2 つのベクターの要素を交換します。

void swap(
    vector<Type, Allocator>& right);

friend void swap(
    vector<Type, Allocator>& left,
    vector<Type, Allocator>& right);

パラメーター

right
交換される要素を提供するベクター。または、ベクター left 内の要素と交換される要素を持つベクター。

left
ベクター right 内の要素と交換される要素を持つベクター。

例

// vector_swap.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1, v2;

   v1.push_back( 1 );
   v1.push_back( 2 );
   v1.push_back( 3 );

   v2.push_back( 10 );
   v2.push_back( 20 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
   cout << endl;

   v1.swap( v2 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
}

The number of elements in v1 = 3
The number of elements in v2 = 2

The number of elements in v1 = 2
The number of elements in v2 = 3

`value_type`

ベクター内に格納されているデータ型を表す型。

typedef typename Allocator::value_type value_type;

解説

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

例

// vector_value_type.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

`vector`

ベクターを構築します。オーバーロードでは、特定のサイズのベクター、または特定の値の要素を使用するベクターが構築されます。または、他のベクターの全体または一部のコピーとなります。オーバーロードによっては、使用するアロケーターを指定することもできます。

vector();
explicit vector(const Allocator& allocator);
explicit vector(size_type count);
vector(size_type count, const Type& value);
vector(size_type count, const Type& value, const Allocator& allocator);

vector(const vector& source);
vector(vector&& source);
vector(initializer_list<Type> init_list, const Allocator& allocator);

template <class InputIterator>
vector(InputIterator first, InputIterator last);
template <class InputIterator>
vector(InputIterator first, InputIterator last, const Allocator& allocator);

パラメーター

allocator
このオブジェクトに対して使用するアロケータークラス。 get_allocator は、オブジェクトのアロケータークラスを返します。

count
構築されたベクター内の要素の数。

value
構築されたベクターの要素の値。

source
構築されたベクターがコピーになる元のベクター。

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

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

init_list
コピーする要素を含む initializer_list。

解説

すべてのコンストラクターは、アロケーターオブジェクト (allocator) を格納し、ベクターを初期化します。

最初の 2 つのコンストラクターは、空の初期ベクターを指定します。 2 番目のコンストラクターは、使用するアロケーターの型 (allocator) を明示的に指定します。

3 番目のコンストラクターは、count クラスの、指定された数 (Type) の既定値の要素を繰り返すことを指定します。

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

6 番目のコンストラクターは、ベクター source のコピーを指定します。

7 番目のコンストラクターは、ベクター source を移動します。

8 番目のコンストラクターは、initializer_list を使用して要素を指定します。

9 番目と 10 番目のコンストラクターは、ベクターの範囲 (first、last) をコピーします。

例

// vector_ctor.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector <int>::iterator v1_Iter, v2_Iter, v3_Iter, v4_Iter, v5_Iter, v6_Iter;

    // Create an empty vector v0
    vector <int> v0;

    // Create a vector v1 with 3 elements of default value 0
    vector <int> v1(3);

    // Create a vector v2 with 5 elements of value 2
    vector <int> v2(5, 2);

    // Create a vector v3 with 3 elements of value 1 and with the allocator
    // of vector v2
    vector <int> v3(3, 1, v2.get_allocator());

    // Create a copy, vector v4, of vector v2
    vector <int> v4(v2);

    // Create a new temporary vector for demonstrating copying ranges
    vector <int> v5(5);
    for (auto i : v5) {
        v5[i] = i;
    }

    // Create a vector v6 by copying the range v5[ first,  last)
    vector <int> v6(v5.begin() + 1, v5.begin() + 3);

    cout << "v1 =";
    for (auto& v : v1){
        cout << " " << v;
    }
    cout << endl;

    cout << "v2 =";
    for (auto& v : v2){
        cout << " " << v;
    }
    cout << endl;

    cout << "v3 =";
    for (auto& v : v3){
        cout << " " << v;
    }
    cout << endl;
    cout << "v4 =";
    for (auto& v : v4){
        cout << " " << v;
    }
    cout << endl;

    cout << "v5 =";
    for (auto& v : v5){
        cout << " " << v;
    }
    cout << endl;

    cout << "v6 =";
    for (auto& v : v6){
        cout << " " << v;
    }
    cout << endl;

    // Move vector v2 to vector v7
    vector <int> v7(move(v2));
    vector <int>::iterator v7_Iter;

    cout << "v7 =";
    for (auto& v : v7){
        cout << " " << v;
    }
    cout << endl;

    cout << "v8 =";
    vector<int> v8{ { 1, 2, 3, 4 } };
    for (auto& v : v8){
        cout << " " << v ;
    }
    cout << endl;
}

v1 = 0 0 0
v2 = 2 2 2 2 2
v3 = 1 1 1
v4 = 2 2 2 2 2
v5 = 0 0 0 0 0
v6 = 0 0
v7 = 2 2 2 2 2
v8 = 1 2 3 4