vector クラス

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

構文

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

パラメーター

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

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

解説

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

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

vector<bool> クラスは、型の要素のクラステンプレートベクターを完全に特殊化したものです bool 。 これには、特殊化によって使用される基になる型のアロケーターがあります。

vector<bool> Reference クラスは、オブジェクト内の要素 (単一ビット) への参照をオブジェクトが提供できる、入れ子になったクラスです 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 オブジェクトを変更できます。

1または2として定義されたを使用してコンパイルした場合 _ITERATOR_DEBUG_LEVEL 、空のベクター内の要素にアクセスしようとすると、ランタイムエラーが発生します。 詳細については、「チェックを行う 反復子」を参照してください。

// 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 vector::cend 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 オブジェクトを変更できます。

1または2として定義されたを使用してコンパイルした場合 _ITERATOR_DEBUG_LEVEL 、空のベクター内の要素にアクセスしようとすると、ランタイムエラーが発生します。 詳細については、「チェックを行う 反復子」を参照してください。

// 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++ 機能です。

// 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 オブジェクトを変更できます。

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

// 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;

atVector クラスでを使用する方法の例については、「」を参照してください reference

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;
}
44

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番目のコンストラクターは、値の () 要素の繰り返しを指定し count value ます。

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

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

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

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

// 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;

    vector<int> v8{ { 1, 2, 3, 4 } };
    for (auto& v : v8){
        cout << " " << v ;
    }
    cout << endl;
}
v1 = 0 0 0v2 = 2 2 2 2 2v3 = 1 1 1v4 = 2 2 2 2 2v5 = 0 1 2 3 4v6 = 1 2v7 = 2 2 2 2 21 2 3 4

関連項目

C++ 標準ライブラリのスレッドセーフ
C++ 標準ライブラリリファレンス