C++を扱うエンジニアにとって、std::vectorは最も頻繁に利用されるコンテナの一つです。

その利便性の中心にあるのは、実行時に要素数を柔軟に変更できる動的配列としての機能ですが、この「サイズ管理」を正しく理解しているかどうかで、プログラムの実行速度やメモリ効率は劇的に変わります。

本記事では、std::vectorにおける要素数の取得から、メモリの内部構造、そしてパフォーマンスを最大化するための最適化手法までを詳しく解説します。

2026年現在のモダンなC++開発において、標準的に用いられるテクニックを整理していきましょう。

目次 [ close ]
  1. size()とempty()の基本：要素数を正確に把握する
    1. size()の戻り値と符号なし整数の注意点
    2. empty()による空判定の推奨
  2. sizeとcapacityの決定的な違い：メモリ確保の裏側
    1. 動的再確保のメカニズム
  3. 実行速度を左右するreserve()とresize()の使い分け
    1. reserve()：メモリの予約
    2. resize()：要素数の変更
  4. C++20以降の新しいサイズ管理：std::ssize()の導入
    1. 符号付きサイズ取得のメリット
  5. メモリ消費を最小限に抑える：shrink_to_fit()と最適化
    1. 不要なメモリを返却する
  6. 要素追加とサイズ変動に伴う「イテレータの無効化」
  7. まとめ

size()とempty()の基本：要素数を正確に把握する

std::vectorに格納されている現在の要素数を知るためには、size()メンバ関数を使用します。

これは基本中の基本ですが、いくつかの重要な性質があります。

size()の戻り値と符号なし整数の注意点

size()が返す型は、そのコンテナで定義されているsize_type（通常はstd::size_t）であり、これは符号なし整数型です。

C++
#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    
    // 要素数の取得
    std::size_t count = numbers.size();
    std::cout << "要素数: " << count << std::endl;

    return 0;
}
実行結果
要素数: 5

ここで注意が必要なのは、符号なし整数同士の計算です。

たとえば、numbers.size() - 10 のような計算を行う際、size()が10未満であれば計算結果は大きな正の値にアンダーフローしてしまいます。

ループの条件式などでこれを見落とすと、予期せぬ無限ループやバッファオーバーフローの原因となるため、比較の際は型の一致に注意を払う必要があります。

empty()による空判定の推奨

「要素が空かどうか」を判定する場合、vec.size() == 0 と書くこともできますが、C++のコーディング規約では vec.empty() の使用が強く推奨されています。

理由は主に2つあります。

一つは意図が明確になること、もう一つは計算量の保証です。

std::vectorにおいてsize()は常に定数時間 O(1) で実行されますが、他のコンテナ（例えば古い特定のリスト実装など）ではsize()が要素を数え上げるために O(N) かかる場合がありました。

一方、empty()は常に定数時間で実行されることが期待できるため、汎用的なコードを書く上でもempty()を使う癖をつけておくのがベストプラクティスです。

sizeとcapacityの決定的な違い：メモリ確保の裏側

std::vectorのサイズ管理を深く理解する上で避けて通れないのが、size（サイズ）とcapacity（キャパシティ）の違いです。

用語意味関連するメンバ関数
size現在実際に格納されている要素の数size()
capacity再確保なしで格納できる最大要素数（メモリ確保済みの領域）capacity()

動的再確保のメカニズム

std::vectorは、要素が追加されて現在のcapacityを超えそうになると、より大きなメモリ領域を自動的に確保し、既存の要素を新しい場所へ移動（またはコピー）します。

この「再確保」は非常にコストが高い処理です。

  1. 新しいメモリ領域を確保する（通常は現在のサイズの1.5倍～2倍）。
  2. 古い領域から新しい領域へ要素をムーブ（またはコピー）する。
  3. 古い領域を解放する。

この挙動を以下のコードで確認してみましょう。

C++
#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;
    
    for (int i = 0; i < 10; ++i) {
        vec.push_back(i);
        std::cout << "Size: " << vec.size() << ", Capacity: " << vec.capacity() << std::endl;
    }
    
    return 0;
}

実行結果（実行環境により増分は異なります）：

text
Size: 1, Capacity: 1
Size: 2, Capacity: 2
Size: 3, Capacity: 4
Size: 4, Capacity: 4
Size: 5, Capacity: 8
Size: 6, Capacity: 8
Size: 7, Capacity: 8
Size: 8, Capacity: 8
Size: 9, Capacity: 16
Size: 10, Capacity: 16

このように、要素が1つ増えるたびに毎回メモリが確保されるわけではなく、まとめて多めに確保される仕組みになっています。

しかし、再確保が発生する瞬間には処理のスパイク（遅延）が発生するため、リアルタイム性が求められるアプリケーションではこの制御が不可欠です。

実行速度を左右するreserve()とresize()の使い分け

メモリ管理を最適化するための主要な武器が、reserve() と resize() です。

これらは名前が似ていますが、動作は全く異なります。

reserve()：メモリの予約

reserve(n) は、capacity を少なくとも n に変更します。

このとき、size は変化しません。

つまり、将来的に要素が増えることを見越して、あらかじめメモリだけを確保しておくメソッドです。

C++
std::vector<int> vec;
vec.reserve(1000); // 1000個分のメモリを確保
// この時点では size は 0、capacity は 1000 以上

あらかじめ必要な要素数がわかっている場合に reserve() を呼んでおくと、その後の push_back() 等で再確保が発生しなくなり、実行パフォーマンスが劇的に向上します。

resize()：要素数の変更

一方、resize(n) は実際の要素数（size）を変更します。

  • 現在のサイズより大きい値を指定した場合：新しい要素がデフォルトコンストラクタで生成されます。
  • 現在のサイズより小さい値を指定した場合：末尾の要素が破棄されます。
C++
std::vector<int> vec = {1, 2, 3};
vec.resize(5); // size は 5 になり、新しい要素は 0 で初期化される
vec.resize(2); // size は 2 になり、3つ目以降の要素は破棄される

resize() は実際にオブジェクトを生成・破棄するため、reserve() よりも重い処理になる可能性があります。

単にメモリを確保したいだけなのか、実際に要素を並べたいのかを明確に区別しましょう。

C++20以降の新しいサイズ管理：std::ssize()の導入

モダンC++、特にC++20からは、サイズ取得に関する重要なアップデートがありました。

それが std::ssize() の導入です。

符号付きサイズ取得のメリット

先述の通り、size() は符号なし整数を返します。

しかし、通常の計算や比較では符号付き整数（int など）を扱うことが多く、これが警告やバグの温床となっていました。

C++20で追加された std::ssize() を使うと、符号付き整数としてのサイズを簡単に取得できます。

C++
#include <iostream>
#include <vector>
#include <iterator> // std::ssize に必要

int main() {
    std::vector<int> vec = {1, 2, 3};
    
    // 符号付き整数として取得
    auto size = std::ssize(vec);
    
    for (auto i = 0; i < size; ++i) { // 警告が出ない
        std::cout << vec[i] << " ";
    }
    
    // 逆順ループも安全
    for (auto i = size - 1; i >= 0; --i) {
        std::cout << vec[i] << " ";
    }

    return 0;
}

このように、逆順ループ（デクリメント）を行う際にアンダーフローを気にする必要がなくなるため、2026年現在の開発現場では、計算が伴うサイズ利用には std::ssize() を積極的に活用するのが主流となっています。

メモリ消費を最小限に抑える：shrink_to_fit()と最適化

std::vector は一度確保した capacity を、要素を削除（pop_back() や clear()）しただけでは自動的に解放しません。

これは、将来の要素追加に備えるための仕様ですが、メモリ制約が厳しい環境では問題になることがあります。

不要なメモリを返却する

不要になったメモリをOSに返却したい場合は、shrink_to_fit() を呼び出します。

C++
std::vector<int> vec(10000);
vec.clear(); // size は 0 になるが、capacity は 10000 のまま
vec.shrink_to_fit(); // capacity を size に合わせて縮小（メモリ解放を試みる）

ただし、shrink_to_fit() は「リクエスト」であり、実際にメモリが解放されるかどうかは実装に依存します。

また、この処理自体も新しいメモリ確保と全要素のコピーを伴う可能性があるため、頻繁に呼び出すとパフォーマンスを大きく損なう点に注意してください。

要素追加とサイズ変動に伴う「イテレータの無効化」

サイズ管理において最も危険な落とし穴が、イテレータの無効化です。

std::vector のサイズが増大し、再確保が発生すると、既存の要素がメモリ上の別の場所に移動します。

このとき、それまで使用していたポインタやイテレータ、参照はすべて無効になります。

無効になったイテレータにアクセスすることは、未定義動作を引き起こし、クラッシュやデータ破損の直接的な原因となります。

C++
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3};
    auto it = vec.begin();
    
    std::cout << "追加前: " << *it << std::endl;
    
    // 多数の要素を追加し、再確保を発生させる
    for (int i = 0; i < 100; ++i) {
        vec.push_back(i);
    }
    
    // std::cout << *it << std::endl; // 危険！ it は無効化されている可能性がある
    
    return 0;
}

これを防ぐためには、以下の対策を徹底しましょう。

  1. 要素追加後はイテレータを再取得する。
  2. reserve() であらかじめ十分なメモリを確保しておき、再確保が発生しないようにする。
  3. インデックス（添字）によるアクセスを検討する（インデックスなら再確保後も有効です）。

まとめ

std::vectorのサイズ管理は、単に要素数を数えるだけではなく、メモリ効率と実行速度のトレードオフを制御するための重要な技術です。

  • size() は現在の要素数、capacity() は確保済みのメモリ量を示す。
  • 空判定には empty() を使用し、計算が伴うサイズ取得には C++20 の std::ssize() が推奨される。
  • reserve() を適切に使い、無駄な再確保（メモリコピー）を最小限に抑えることがパフォーマンス向上の鍵。
  • サイズ変更に伴うイテレータの無効化には細心の注意を払い、安全なメモリアクセスを心がける。

これらの原則をマスターすることで、C++の持つ高いポテンシャルを最大限に引き出した、堅牢で高速なプログラムを構築できるようになります。

特に、大量のデータを扱う現代のアプリケーション開発において、std::vector のサイズとメモリの状態を意識したコーディングは、プロフェッショナルなC++エンジニアにとって必須のスキルと言えるでしょう。