[C++/STL] std::vectorクラスの使い方

2024年1月9日2024年9月8日

当ページのリンクには広告が含まれています。

std::vectorは、C++の標準テンプレートライブラリ（STL）の中核を成すコンテナの一つであり、動的配列の機能を提供します。この記事では、vectorクラスの基本的な概念から、使用方法、そしてパフォーマンスの最適化に至るまで、幅広いトピックにわたって解説します。

vectorクラスとは

vectorクラスの基本的な概念

vectorクラスは、標準テンプレートライブラリ（STL）の一部で、動的配列の機能を提供します。
動的配列とは、プログラムの実行時にサイズを変更できる配列のことを指します。
vectorは、連続したメモリ上に要素を格納し、ランダムアクセス（任意の要素に直接アクセス）が可能です。これにより、通常の配列と同様の性能、および方法で要素にアクセスできます。

vectorクラスは、要素を追加または削除する際に、自動的にメモリを割り当てたり解放したりすることができ柔軟性があります。これは、固定サイズの配列に比べて大きな利点となります。さらに、vectorクラスはテンプレートクラスであるため、様々なデータ型で使用することが可能です。

vectorクラスの重要性

vectorクラスは、高性能で柔軟性も高いため広く使用されています。配列と同じように使える一方で、サイズの動的な変更や様々な便利な操作（ソート、検索、逆順のイテレーションなど）をサポートしています。これにより、プログラマはより効率的なコードを書くことが可能になります。

また、vectorクラスはメモリ管理を自動化しているため、メモリリークのリスクを低減できます。プログラマが直接メモリを割り当てたり解放したりする必要がないため、メモリに関するエラーが発生する可能性が減少します。このように、vectorクラスは効率性、柔軟性、安全性の三つの重要な要件を満たしており、便利なクラスです。

vectorクラスの基本

vectorの作成と初期化

空のvectorの作成方法

std::vector<int> vect; // 空のint型のvector

型を指定して空のvectorを作成することができます。
上記例のvect1は、何も要素を持たないため、そのサイズは0です。

初期サイズを指定して作成する方法

std::vector<int> vect(10); // 10個の要素で初期化されたvector

初期サイズを持つvectorを作成することができます。この場合、各要素はデフォルト値で初期化されます。
上記例のvect2は、10個の整数が格納されており、それぞれの値は0（整数型のデフォルト値）です。

初期サイズと初期値を指定して作成する方法

std::vector<int> vect(10, 5); // 10個の要素が全て5で初期化されたvector

初期サイズとともに初期値を指定することも可能です。この方法では、全ての要素が指定した値で初期化されます。上記例のvect3は、10個の整数が格納されており、それぞれの値は5に初期化されます。

初期化リストで初期値を指定して作成する方法

std::vector<int> vect = {1, 2, 3, 4, 5}; // 初期化リストで初期化されたvector

C++11以降では、初期化リストを使用してvectorを初期化することができます。
上記例のvect4では、5個の整数が格納されており、それぞれ1, 2, 3, 4, 5に初期化されます。

サイズと容量の理解

vectorには「サイズ」と「容量」の2つの重要な属性があります。サイズはvectorに現在含まれる要素の数を指し、容量はvectorがメモリ上で保持している要素の最大数を意味します。

サイズを確認する方法

サイズはsize()メソッドを使って確認できます。

std::cout << "Size: " << vect.size(); // vect4のサイズを出力

容量の確認と拡張

容量はcapacity()メソッドで確認できます。また、reserve()メソッドを使って容量を拡張することができます。

std::cout << "Capacity: " << vect.capacity(); // vectの容量を出力
vect.reserve(10); // vectの容量を少なくとも10に拡張

サイズを超える要素を追加する際、vectorは自動的に容量を増やしますが、頻繁な容量の拡張はパフォーマンスに影響を与えるため、必要な容量があらかじめ分かっている場合はreserve()を使用すると効率的です。

要素へのアクセス方法

インデックスによるアクセス

vectorの要素にアクセスする基本的な方法はインデックスを使用することです。これは通常の配列と同じ方法です。

int elem = vect[0]; // 最初の要素にアクセス

at()メソッドによる安全なアクセス

at()メソッドを使用すると、範囲外アクセス時に例外がスローされるため、より安全に要素にアクセスできます。

try{
    int elem = vect.at(10); // 範囲外アクセスの試み
}catch(std::out_of_range& e){
    std::cout << "Out of Range error: " << e.what() << '\n';
}

front()とback()メソッド

front()とback()メソッドは、それぞれvectorの最初と最後の要素に簡単にアクセスするための方法です。

int first = vect.front(); // 最初の要素
int last  = vect.back();  // 最後の要素

vectorとlistの比較

vectorとlistクラスの違い

vectorとlistの主な違いは、内部のデータ構造とその操作にあります。

vector

vectorは動的配列を実装しており、要素は連続したメモリブロックに格納されます。この特性により、ランダムアクセス（任意の位置の要素への直接アクセス）が高速です。

std::vector<int> vect = {1, 2, 3, 4, 5};
int elem = vect[2]; // 3番目の要素に高速アクセス

しかし、vectorの中間に要素を挿入または削除すると、後続の全要素を移動させる必要があり、これが大きなコストになります。

list

listはダブルリンクリストを実装しており、各要素はメモリ上の別々の場所に格納され、前後の要素へのポインタによって接続されています。このため、要素の挿入と削除が高速です。

std::list<int> list = {1, 2, 3, 4, 5};
auto it = std::next(list.begin(), 2);
list.insert(it, 6); // 3番目の位置に6を挿入

しかし、リストのランダムアクセスは効率が悪く、特定の要素にアクセスするには先頭から順にたどる必要があります。

各クラスの利点と使い分け

vectorの利点

ランダムアクセスの効率
任意の要素へのアクセスが高速。
メモリ効率
連続したメモリブロックを使用するため、メモリの断片化が少ない。
キャッシュ効率
要素が物理的に隣接しているため、CPUキャッシュ効率が良い。

listの利点

要素の挿入と削除
リストの任意の位置での挿入と削除が効率的。
メモリ使用量
必要な分だけのメモリを使用し、容量を事前に予測する必要がない。

使い分けの基準

ランダムアクセスが重要な場合
ランダムアクセスが頻繁に必要な場合、vectorが適しています。
挿入・削除の頻度が高い場合
中間に頻繁に要素を挿入または削除する必要がある場合、listが適しています。
メモリ管理の考慮
メモリの断片化やキャッシュ効率を考慮する必要がある場合、vectorが適しています。

vectorの操作

要素の追加と削除

vectorへの要素の追加と削除は、多くの便利なメソッドが用意されています。

要素の追加

末尾への追加
push_back()メソッドを用いて、vectorの末尾に新しい要素を追加できます。

std::vector<int> vect;
vect.push_back(1); // vectは {1}
vect.push_back(2); // vectは {1, 2}

特定の位置への挿入
insert()メソッドを使用すると、指定した位置に新しい要素を挿入できます。

std::vector<int> vect = {1, 2};
auto it = vect.begin();
vect.insert(it, 0); // vectは {0, 1, 2}

要素の削除

末尾の要素の削除
pop_back()メソッドで、vectorの末尾の要素を削除できます。

std::vector<int> vect = {0, 1, 2};
vect.pop_back(); // vectは {0, 1}

特定の要素の削除
erase()メソッドを用いて、特定の位置の要素、または特定の範囲の要素を削除できます。

std::vector<int> vect = {0, 1};
vect.erase(vect.begin()); // 最初の要素を削除、vは {1}

全要素のクリア
clear()メソッドを使用すると、vector内の全ての要素を削除し、サイズを0に戻すことができます。この操作は、vectorを完全にリセットする場合に有用です。

vect.clear(); // すべての要素を削除し、vectのサイズを0にする

clear()メソッドは、要素のメモリを解放する点でerase()メソッドとは異なりますが、vectorの容量は変更しません。もし容量も削減したい場合は、shrink_to_fit()メソッドを使用することができます。

サイズ変更と容量の管理

vectorのサイズと容量を管理することで、メモリ使用効率とパフォーマンスを向上させることができます。

サイズの変更

resize()メソッドを使って、vectorのサイズを変更できます。サイズを増やすと、新しい要素が追加され、デフォルト値で初期化されます。サイズを減らすと、余分な要素が削除されます。

std::vector<int> vect = {1};
vect.resize(5); // サイズを5に変更、vectは {1, 0, 0, 0, 0}
vect.resize(3); // サイズを3に変更、vectは {1, 0, 0}

容量の管理

reserve()メソッドを使って、必要な容量を予め確保することができます。大量の要素を追加する予定がある場合に、パフォーマンスを向上させることができます。

std::vector<int> vect;
vect.reserve(1000); // 容量を1000に設定

メモリの効率的な利用

vectorのメモリ効率を最適化するためには、以下のポイントを考慮する必要があります。

適切な容量の事前確保
不必要なメモリ再割り当てを避けるため、reserve()メソッドで十分な容量を予め確保することが重要です。
不要な要素の削除
erase()メソッドで不要な要素を削除し、shrink_to_fit()メソッドで余分なメモリを解放することができます。ただし、shrink_to_fit()は要求であって保証ではないことに注意してください。

vect.shrink_to_fit(); // メモリを解放する試み

これらの操作を通じて、vectorは高い柔軟性を保ちながらも、メモリ使用効率を最大化することが可能です。

vectorとイテレータ

イテレータの基本とvectorでの使用方法

イテレータは、コンテナ内の要素を指すオブジェクトで、ポインタに似た概念です。vectorのイテレータを使用することで、コンテナ内の要素に対して順序立ててアクセスすることができます。

イテレータの取得

begin()メソッドは、vectorの最初の要素を指すイテレータを返し、end()メソッドは、vectorの最後の要素の次を指すイテレータを返します。

std::vector<int> vect = {1, 2, 3, 4, 5};
auto it_begin = vect.begin(); // 最初の要素を指す
auto it_end = vect.end();     // 最後の要素の次を指す

イテレータによる要素へのアクセス

イテレータをデリファレンスする（*演算子を使用する）ことで、その指す要素にアクセスできます。

int value = *it_begin; // 最初の要素の値

begin()、end()を使用したループ処理

begin()とend()を使用して、vectorの全要素を反復処理することができます。

イテレータを使用したforループ

for(auto it=vect.begin(); it!=vect.end(); ++it){
    std::cout << *it << ' '; // 各要素を出力
}

範囲ベースのforループ（C++11以降）

C++11以降では、範囲ベースのforループを使用して、より簡単にイテレータを利用できます。

for(int n : vect){
    std::cout << n << ' '; // 同じく各要素を出力
}

イテレータを使用した要素の追加と削除

vectorでは、イテレータを使用して特定の位置に要素を挿入したり、要素を削除したりすることができます。

要素の挿入

insert()メソッドを使用すると、イテレータが指す位置に新しい要素を挿入できます。

vect.insert(v.begin() + 2, 10); // 3番目の位置に10を挿入

要素の削除

erase()メソッドを使用すると、イテレータが指す要素を削除できます。

vect.erase(v.begin() + 1); // 2番目の要素を削除

イテレータを用いた操作は、vector内の要素を効率的に操作する上で非常に重要な役割を果たします。これらのテクニックをマスターすることで、vectorをより柔軟に、効果的に使用することができます。

良い使い方と悪い使い方

vectorは非常に強力なコンテナですが、最大の効果を発揮するためには適切な使い方を理解することが重要です。

vectorの良い使い方

vectorを効果的に使用するための最適な方法をいくつか紹介します。

適切な容量の予測と予約

事前に必要な容量が予測できる場合は、reserve()メソッドを使用して容量を確保すると効率的です。これにより、要素の追加時に発生する可能性のあるメモリ再割り当てを防ぐことができます。

std::vector<int> vect;
vect.reserve(100); // 100要素分のメモリを予約

範囲ベースのforループの使用

C++11以降では、範囲ベースのforループを使用して、vectorの要素をより簡単に処理できます。

for(auto& elem : vect){
  // 各要素に対する処理
}

適切なメソッドの選択

vectorは様々な操作を行うための多くのメソッドを提供しており、これらのメソッドを適切に選択することは、vectorのパフォーマンスを最大化し、意図しないバグや効率の悪い操作を避けるために重要なことです。

push_back() と emplace_back()

push_back()メソッドは、既に構築されたオブジェクトをvectorの末尾にコピー（またはムーブ）します。

std::vector<std::string> vect;
std::string str = "example";
vect.push_back(str); // strをコピーして追加

emplace_back()メソッド（C++11）は、オブジェクトをvector内のメモリに直接構築します。これにより、不要なコピーまたはムーブ操作を省略し、パフォーマンスを向上させることができます。

vect.emplace_back("example"); // 直接構築

insert()の使用

insert()メソッドは、指定された位置に要素を挿入します。この操作は、vectorの要素を移動させる必要があるため、特に大きなvectorでの使用は慎重に行う必要があります。

erase()の使用

erase()メソッドは指定された要素または範囲の要素を削除します。削除された要素の後ろにある要素は前に移動するため、大量の要素がある場合はコストが高くなります。

vect.erase(v.begin() + 1); // 2番目の要素を削除

clear()の使用

clear()メソッドは、vectorの全要素を削除し、サイズを0にします。vectorの容量は変更されないため、再割り当てのコストは発生しません。

これらのメソッドの選択は、vectorの現在の状態、操作の種類、パフォーマンス要件に基づいて行う必要があります。適切なメソッドを選択することで、メモリの無駄遣いを避け、アプリケーションの効率を高めることができます。

例外安全の考慮

at()メソッドを使用して範囲外のアクセスをチェックし、プログラムの安全性を保つことが重要です。

try{
  int value = vect.at(10); // 範囲外アクセスのチェック
}catch(const std::out_of_range& e){
  // エラー処理
}

vectorの悪い使い方

以下は、vectorを使用する際に避けるべき使い方です。

無駄な再割り当て

容量を予め確保せずに要素を追加すると、頻繁なメモリ再割り当てが発生し、パフォーマンスが低下します。

ランダムアクセスにat()の過剰使用

vectorのat()メソッドは、指定したインデックスで要素にアクセスする際に範囲チェックを行います。範囲外のインデックスにアクセスしようとすると、std::out_of_range例外が投げられます。これに対して、通常の添字演算子[]は範囲チェックを行わず、範囲外アクセスが行われた場合、未定義の挙動が発生する可能性があります。

at()メソッドが必要な場合

範囲外アクセスの可能性がある場合
動的なデータやユーザー入力に基づいてインデックスが決定される場合、範囲外アクセスのリスクがあります。このような状況では、at()を使用して安全なアクセスを保証することが推奨されます。

try{
    int value = vect.at(userInput); // ユーザー入力に基づくアクセス
}catch(const std::out_of_range& e){
    // 範囲外アクセスの処理
}

デバッグ時
新しいアルゴリズムや複雑なデータ処理を実装する際、初期のデバッグフェーズではat()を使うことで、範囲外アクセスを検出しやすくなります。

通常の添字演算子[]の使用

以下のような状況では通常の添字演算子[]の使用が適しています。

パフォーマンスが重要な場合
範囲チェックは追加の処理コストを伴います。インデックスがプログラムのロジックによって安全であることが保証されている場合、添字演算子[]を使用してパフォーマンスを向上させることができます。

for(size_t i=0; i<vect.size(); ++i){
    process(vect[i]); // 安全が保証されているインデックスアクセス
}

既知の安全なインデックスでのアクセス
アルゴリズムやプログラムの構造上、インデックスが常に有効な範囲内にあることが明らかな場合、添字演算子[]を使うことが適切です。

要するに、「必要な場合のみat()を使用する」とは、安全性が不確実な状況やデバッグフェーズで範囲外アクセスを防ぐためにat()を用い、安全が保証されている場合はパフォーマンス向上のために添字演算子[]を使用するという意味です。

不適切な要素の削除

vectorで要素を削除する際には、特に大きなサイズのvectorや、頻繁な削除操作が行われる場合において、パフォーマンスに影響を及ぼす可能性があります。vectorは要素が連続したメモリ上に格納されているため、要素の削除には次のような問題が生じる可能性があります。

中間の要素を削除する際のコスト
vectorの中間にある要素を削除すると、その後ろにある全ての要素を前にシフトする必要があります。これは、特にvectorが大きい場合には非常にコストが高くなります。

std::vector<int> vect = {1, 2, 3, 4, 5};
vect.erase(v.begin() + 2); // 3番目の要素を削除
// この操作後、4と5が前にシフトされます。

頻繁な削除によるパフォーマンス低下
要素の削除が頻繁に行われる場合、各削除操作ごとに要素のシフトが発生し、全体的なパフォーマンスに影響を及ぼします。

効率的な削除方法

末尾の要素の削除
可能であれば、末尾の要素を削除することが推奨されます。pop_back()メソッドは、末尾の要素を削除する際に他の要素の移動が不要であり、効率的です。

vect.pop_back(); // 末尾の要素を削除

一度に複数の要素を削除
一度に複数の要素を削除することで、要素のシフト操作を減らすことができます。

vect.erase(vect.begin(), vect.begin() + 3); // 最初の3つの要素を削除

removeとeraseの組み合わせ
非効率的な削除操作を避けるために、std::removeアルゴリズムとeraseメソッドを組み合わせて使用することができます。これにより、特定の条件に合致する要素を一度に効率的に削除することが可能です。

vect.erase(std::remove(vect.begin(), vect.end(), value), vect.end());
// valueに一致する要素を全て削除

このように、vectorでの要素削除を行う際には、削除の位置、頻度、およびその削除が全体的なパフォーマンスに与える影響を考慮することが重要です。適切な削除方法を選択することで、効率的なプログラムを維持することができます。

安全性に対して考慮するべきこと

vectorの使用において、安全性を保つためには以下の点を考慮する必要があります。

メモリの範囲外アクセスの防止

at()メソッドを使用して、範囲外アクセスを防ぐことが重要です。

イテレータの無効化

イテレータの無効化とは、あるvector操作の結果として、そのvectorを指していたイテレータがもはや有効な要素を指さなくなる状態を指します。イテレータが無効化されると、そのイテレータを使用した時点でのプログラムの動作は未定義となり、これはバグやクラッシュの原因になりえます。

イテレータが無効化される主な原因

要素の追加や削除
vectorに要素を追加（push_back、insert）したり、削除（erase、clear）したりすると、これらの操作がイテレータの指す位置やvectorのメモリ配置に影響を与える可能性があります。

std::vector<int> vect = {1, 2, 3, 4, 5};
auto it = vect.begin() + 2; // 3番目の要素を指すイテレータ
vect.erase(it); // この操作によりitは無効化される

容量の変更
vectorの容量が変更される（例えば要素の追加によって自動的に容量が増加する場合）と、既存のイテレータが無効化されることがあります。これは、vectorが新しいメモリ領域に要素を再配置するためです。

vect.push_back(6); // もし容量が再割り当てされれば、全てのイテレータは無効化される

イテレータの無効化を避ける方法

イテレータの再取得
特定の操作後には、必要なイテレータを再取得します。たとえば、要素を削除した後に新しいイテレータを取得することで、無効化されたイテレータを使うリスクを避けることができます。

it = vect.erase(it); // eraseは削除された要素の次の要素を指す新しいイテレータを返す

操作前のインデックスを保存
イテレータではなく、要素のインデックスを保存しておき、必要に応じて新しいイテレータをそのインデックスから生成する方法もあります。

size_t index = it - vect.begin(); // イテレータの位置をインデックスとして保存
// ...何らかの操作...
it = vect.begin() + index; // 新しいイテレータをインデックスから再生成

イテレータの無効化に注意することは、vectorを安全に扱う上で非常に重要です。特にvectorの中間での要素の挿入や削除を行う場合には、この点を特に意識する必要があります。無効化を適切に管理することで、プログラムの安定性と信頼性を保つことができます。

型安全の保持

自動型変換によるエラーを防ぐために、型安全を意識したコーディングを行うことが重要です。
vectorを使う際に型安全を保持するための具体的な方法は以下の通りです。

正しい型の使用

vectorを宣言する際には、正確なデータ型を指定します。型の推測や不適切な型変換は避けます。

std::vector<int> intVector; // 整数のvector
std::vector<std::string> stringVector; // 文字列のvector

自動型推論の適切な使用

C++11以降で導入されたautoキーワードを使う際には注意が必要です。特にループやアルゴリズム内でvectorの要素にアクセスする際には、型が正しく推論されていることを確認します。

for(auto& elem : intVector){ // 正しい型で要素にアクセス
  // ...
}

型変換の慎重な使用

明示的な型変換（キャスト）は慎重に行います。特にstatic_castやdynamic_castを使用する際には、変換先の型が適切であることを確認する必要があります。

テンプレートとジェネリクスの正確な使用

テンプレートやジェネリックプログラミングを使用する際には、型パラメータが正しく、予期された型であることを確認します。

template <typename T>
void processVector(const std::vector<T>& vect) {
  // ...
}

型安全の保持は、プログラムの正確性と安定性を保つために不可欠です。特にvectorのようなジェネリックコンテナを使用する際には、この点を十分に考慮することが重要です。適切な型の使用と慎重な型変換により、多くの一般的なプログラミングエラーを回避することができます。

vectorの使用例とユースケース

さまざまなデータ型での使用例

vectorはジェネリックコンテナであるため、ほぼあらゆる種類のデータを格納することができます。

整数のvector

std::vector<int> intVector = {1, 2, 3, 4, 5};

これは整数のリストを保持する最も基本的なvectorの使用例です。

文字列のvector

std::vector<std::string> stringVector = {"apple", "banana", "cherry"};

文字列を格納するvectorは、文字列のコレクションを管理する場合に便利です。

ユーザー定義型のvector

class MyClass {
public:
    MyClass(int x) : value(x) {}
    int value;
};

std::vector<MyClass> customVector;
customVector.emplace_back(10);
customVector.emplace_back(20);

ユーザー定義型（例えば、クラスや構造体）もvectorに格納できます。

プログラム例

vectorの実用的なプログラム例をいくつか紹介します。

要素の追加とアクセス

std::vector<int> vect;
vect.push_back(1);
vect.push_back(2);

for(int n : vect){
    std::cout << n << "\n"; // 出力: 1 2
}

この例では、整数をvectorに追加し、その要素にアクセスしています。

サイズと容量の確認

std::cout << "Size: " << vect.size() << "\n"; // 出力: サイズ
std::cout << "Capacity: " << vect.capacity() << "\n"; // 出力: 容量

vectorのサイズと容量を確認する例です。

要素の削除

vect.erase(v.begin());

この操作により、vectorの最初の要素が削除されます。

ユースケース

vectorは様々なシナリオで利用されます。いくつかの一般的なユースケースを以下に示します。

データの収集と処理

vectorは、データポイントの集約や統計情報の計算、データのソートやフィルタリングに使用されます。

動的配列の代替

固定サイズの配列ではなく、実行時にサイズが変更される可能性のあるデータ構造が必要な場合、vectorは理想的な選択肢です。

アルゴリズムの入力

標準アルゴリズム（std::sort、std::findなど）の入力として、vectorがよく使用されます。

std::sortの使用例

std::sortは、与えられた範囲内の要素をソートするために使用されます。vectorの全要素をソートする一般的な方法は次の通りです。

#include <algorithm> // std::sortのために必要
#include <vector>
#include <iostream>

int main(void)
{
    std::vector<int> vect = {4, 1, 3, 5, 2};

    std::sort(vect.begin(), vect.end()); // 昇順にソート

    for(int n : vect){
        std::cout << n << " "; // 出力: 1 2 3 4 5
    }

    return 0;
}

std::findの使用例

std::findは、指定した値を持つ要素を探す際に使用されます。この関数は、指定した値が見つかった場合、その要素を指すイテレータを返します。

#include <algorithm> // std::findのために必要
#include <vector>
#include <iostream>

int main(void)
{
    std::vector<int> vect = {1, 2, 3, 4, 5};
    int target = 3;

    auto it = std::find(vect.begin(), vect.end(), target);

    if(it != vect.end()){
        std::cout << "Found: " << *it << "\n"; // 出力: Found: 3
    }else{
        std::cout << "Not found\n";
    }

    return 0;
}

重複データの削除

重複要素を削除する一般的な方法は、まずvectorをソートし、その後std::uniqueを使って重複を削除することです。unique関数は重複を削除した後の新しい終端を返しますが、実際にはコンテナのサイズは変わりません。そのため、eraseと組み合わせて余分な要素を削除します。

#include <algorithm> // std::sortとstd::uniqueのために必要
#include <vector>
#include <iostream>

int main(void)
{
    std::vector<int> vect = {1, 5, 2, 4, 3, 5, 4, 3, 1, 2, 3};

    std::sort(vect.begin(), vect.end()); // 昇順にソート
    auto newEnd = std::unique(vect.begin(), vect.end());
    vect.erase(newEnd, vect.end()); // 重複削除

    for(int n : vect){
        std::cout << n << " "; // 出力: 1 2 3 4 5
    }

    return 0;
}

これらの例では、vectorが標準アルゴリズムとどのように組み合わせて使用できるかを示しています。vectorの柔軟性とこれらのアルゴリズムの強力さを活用することで、効率的かつ表現力豊かなコードを書くことが可能になります。

パフォーマンスと最適化

vectorは、パフォーマンスの観点から考えると、非常に効率的なデータ構造ですが、その使用方法によってはパフォーマンスに影響を与える可能性があります。この章では、vectorのパフォーマンスに関連する様々な側面と、それを最適化するためのテクニックについて詳しく見ていきます。

vectorのパフォーマンス

メモリ割り当てと再割り当て

vectorの要素がメモリ上で連続しているため、ランダムアクセスが高速です。しかし、要素を追加する際、既存の容量を超えると、vectorはより大きなメモリブロックを割り当て直し、既存の要素を新しいメモリにコピーします。この再割り当てはコストが高い操作です。

キャッシュ効率

vectorの要素は連続しているため、CPUキャッシュを効率的に利用できます。これにより、要素に対する反復処理が高速になります。

vectorクラスを使用する際のテクニック

適切な容量の予測と予約

パフォーマンスを最適化するためには、可能な限り再割り当てを避けることが重要です。reserve()メソッドを使用して、予想される要素数に応じた容量を事前に確保します。

std::vector<int> vect;
vect.reserve(1000); // 1000要素分のメモリを予約

要素の効率的な追加

新しい要素をvectorに追加する際には、emplace_back()メソッドを使用すると効率的です。これにより、余計なコピー操作を省くことができます。

vect.emplace_back(42); // コピーまたはムーブ操作を省略

不必要な要素の削除

vectorから要素を削除する際には、erase()メソッドを慎重に使用し、不必要な要素の移動を防ぎます。可能であれば、末尾の要素の削除に限定します。

vect.pop_back(); // 末尾の要素を削除（効率的）

メモリと実行時間の最適化

メモリの再割り当ての最小化

vectorの容量は、必要に応じて自動的に増加しますが、この動作はコストがかかります。予め大きな容量を確保しておくことで、この再割り当てのコストを削減できます。

軽量な要素の使用

vectorの要素が大きなクラスや構造体の場合、メモリのオーバーヘッドが大きくなる可能性があります。可能であれば、より軽量なデータ型を使用します。

アルゴリズムの選択

標準アルゴリズム（std::sort、std::findなど）を適切に使用し、効率的なデータ処理を行います。

std::sort(vect.begin(), vect.end()); // ソートは効率的なアルゴリズムを使用

vectorを使用する際のこれらのテクニックを理解し適用することで、メモリ使用と実行時間を最適化し、より効率的なプログラムを実現することができます。パフォーマンスはアプリケーションの要件に大きく依存するため、各シナリオに応じた最適な戦略を選択することが重要です。

まとめ

本記事では、vectorについて、その基本から応用まで幅広く説明してきました。
本章では、まとめとしてvectorの核心的な概念とその使用法について簡潔に再確認します。

vectorの基本概念

vectorは、動的配列を実現する標準テンプレートライブラリ（STL）の一部で、その主要な特徴は以下の通りです。

動的なサイズ管理
実行時にサイズを変更できます。
メモリの連続性
要素はメモリ上で連続して配置されているため、ランダムアクセスが高速です。
柔軟性
さまざまなデータ型を扱うことができ、動的に要素を追加・削除できます。

vectorの使用法

要素の追加とアクセス

std::vector<int> vect = {1, 2, 3};
vect.push_back(4);   // 要素の追加
int value = vect[2]; // 要素へのアクセス

イテレータの使用

for(auto it=vect.begin(); it!=v.end(); ++it){
    std::cout << *it << ' '; // イテレータによる要素の反復処理
}

要素の削除とメモリ管理

vect.pop_back();          // 末尾の要素を削除
vect.erase(vect.begin()); // 最初の要素を削除
vect.clear();             // 全要素を削除
vect.shrink_to_fit();     // 未使用のメモリを解放