C++という言語において、配列はもっとも基本的かつ重要なデータ構造の一つです。

しかし、そのシンプルさの裏には、メモリ管理、パフォーマンス、安全性のトレードオフが複雑に絡み合っています。

2026年現在、C++20やC++23、そして次期標準であるC++26を見据えた開発現場では、古くからある「生の配列」を使用する機会は激減しました。

代わりに、コンパイル時最適化を享受できるstd::array、柔軟な動的管理を可能にするstd::vector、そして多次元データ処理に革命をもたらしたstd::mdspanなど、用途に応じた最適な選択肢が用意されています。

本記事では、現代のC++開発者が知っておくべき配列の「最適解」を、最新の言語仕様に基づいて整理します。

目次 [ close ]
  1. なぜ「生の配列」を避けるべきなのか
    1. 安全性を欠く生の配列の例
  2. std::array ― 固定長配列の現代的標準
    1. std::array の利点と特徴
  3. std::vector ― 動的配列の決定版
    1. メモリレイアウトとパフォーマンス
    2. std::pmr::vector による高度なメモリ制御
  4. std::span ― 所有権を持たない「窓」
    1. なぜ std::span が重要なのか
  5. std::mdspan ― 多次元配列の革命
    1. std::mdspan の仕組み
    2. std::mdspan による行列操作の例
  6. コンパイル時最適化と配列の選択
    1. 固定長か動的長か
    2. 読み取り専用データの扱い
  7. 安全な配列操作のためのベストプラクティス
  8. まとめ

なぜ「生の配列」を避けるべきなのか

C++の学習者が最初に出会う配列は、int arr[5]; のような形式でしょう。

しかし、この「生の配列 (C-style array)」には、プログラミング上の大きな欠点がいくつか存在します。

第一に、ポインタへの暗黙的な減衰 (Pointer Decay)です。

関数に配列を渡すと、配列は即座に先頭要素を指すポインタへと変換され、要素数情報が失われてしまいます。

これにより、境界外アクセスによる脆弱性やバグが発生しやすくなります。

第二に、代入や比較の不便さです。

生の配列は直接代入することができず、コピーを行うには std::copy や memcpy を呼ぶ必要があります。

また、配列同士を == で比較することもできず、これはポインタの比較になってしまいます。

安全性を欠く生の配列の例

C++
#include <iostream>

void print_size(int arr[]) {
    // arrはポインタに減衰しているため、sizeof(arr)は配列全体のサイズを返さない
    std::cout << "関数内でのサイズ: " << sizeof(arr) << std::endl;
}

int main() {
    int my_array[5] = {1, 2, 3, 4, 5};
    std::cout << "main内でのサイズ: " << sizeof(my_array) << std::endl;
    print_size(my_array);
    return 0;
}
実行結果
main内でのサイズ: 20
関数内でのサイズ: 8

このように、生の配列はサイズ情報を自己管理できないため、現代的な設計では「生の配列はインターフェースとして不適格」であると断言できます。

std::array ― 固定長配列の現代的標準

サイズがコンパイル時に決定している場合、最も強力な選択肢は std::array です。

これは C-style 配列をラップしたクラスであり、生の配列と同等のオーバーヘッド（ゼロコスト抽象化）で動作しながら、コンテナとしての便利なインターフェースを提供します。

std::array の利点と特徴

  1. サイズ情報の保持：size() メソッドにより、いつでも要素数を取得できます。
  2. 値セマンティクス：配列同士を = でコピーしたり、== で中身を比較したりできます。
  3. 境界チェック：at() メソッドを使用することで、実行時の境界チェックが可能です。
  4. constexpr 親和性：C++20以降、std::array のほぼすべての操作が constexpr に対応しており、コンパイル時計算に最適です。
C++
#include <iostream>
#include <array>
#include <algorithm>

int main() {
    // コンパイル時にサイズが確定する固定長配列
    std::array<int, 5> data = {5, 2, 8, 1, 9};

    // コピーが可能
    auto data_copy = data;

    // ソートなどのアルゴリズムも自然に適用できる
    std::sort(data.begin(), data.end());

    for (const auto& val : data) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    // 境界チェック付きアクセス
    try {
        std::cout << data.at(10); // 例外を投げる
    } catch (const std::out_of_range& e) {
        std::cerr << "エラー: " << e.what() << std::endl;
    }

    return 0;
}
実行結果
1 2 5 8 9 
エラー: array::at: __n (which is 10) >= _Nm (which is 5)

std::array はスタック領域に確保されるため、メモリの動的確保（ヒープ）を伴いません。

そのため、極めて高速なアクセスが求められる小規模な固定データに適しています。

std::vector ― 動的配列の決定版

実行時に要素数が変わる、あるいは要素数が非常に大きくスタックを圧迫する可能性がある場合は、std::vector を選択します。

C++において、「デフォルトで選ぶべきコンテナ」は常に std::vector です。

メモリレイアウトとパフォーマンス

std::vector は連続したメモリ領域（ヒープ）を確保します。

これにより、CPUキャッシュ効率が極めて高いという特徴を持ちます。

連結リスト（std::list）などは各要素がメモリ上に分散するため、現代のCPUアーキテクチャでは std::vector のほうが圧倒的に高速に動作することが一般的です。

キャパシティ管理の重要性

std::vector は要素が追加されるたびに必要に応じて再確保を行いますが、これにはコストがかかります。

パフォーマンスを最適化するためには、あらかじめ必要なサイズが予測できる場合に reserve() を活用することが推奨されます。

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

int main() {
    std::vector<int> vec;
    
    // あらかじめメモリを予約しておくことで、再確保のオーバーヘッドを防ぐ
    vec.reserve(100);

    for (int i = 0; i < 10; ++i) {
        vec.push_back(i * 10);
    }

    std::cout << "Size: " << vec.size() << ", Capacity: " << vec.capacity() << std::endl;

    return 0;
}
実行結果
Size: 10, Capacity: 100

std::pmr::vector による高度なメモリ制御

2026年現在のモダンな開発では、標準の std::allocator 以外にも、Polymorphic Memory Resources (PMR) を活用した std::pmr::vector の利用が進んでいます。

これにより、特定のメモリプールから高速にアロケーションを行うといった、柔軟なメモリ戦略が可能になります。

std::span ― 所有権を持たない「窓」

C++20で導入された std::span は、配列の扱いにおけるパラダイムシフトをもたらしました。

std::span は、データの所有権を持たず、既存の連続したメモリ領域への参照（ビュー）のみを提供します。

なぜ std::span が重要なのか

関数の引数として配列を渡す際、以前は「ポインタとサイズ」のペア、あるいはテンプレートを用いた煩雑な記述が必要でした。

std::span を使えば、std::array、std::vector、さらには生の配列であっても、同じインターフェースで受け取ることができます。

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

// 連続したメモリ領域なら何でも受け取れる汎用的な関数
void print_buffer(std::span<const int> view) {
    std::cout << "要素数: " << view.size() << " | 内容: ";
    for (int x : view) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
}

int main() {
    int raw_arr[] = {1, 2};
    std::vector<int> vec = {3, 4, 5};
    std::array<int, 4> arr = {6, 7, 8, 9};

    print_buffer(raw_arr);
    print_buffer(vec);
    print_buffer(arr);

    // 一部分だけを切り出す（サブスパン）
    print_buffer(vec.as_span().subspan(1, 2)); 

    return 0;
}
実行結果
要素数: 2 | 内容: 1 2 
要素数: 3 | 内容: 3 4 5 
要素数: 4 | 内容: 6 7 8 9 
要素数: 2 | 内容: 4 5

std::span は軽量（ポインタとサイズのペアのみ）であり、コピーコストがほぼゼロです。

関数の引数には積極的に std::span を採用することで、コードの汎用性と安全性を劇的に向上させることができます。

std::mdspan ― 多次元配列の革命

C++23で導入され、2026年現在広く普及しているのが std::mdspan です。

これまでC++には、標準で使い勝手の良い多次元配列が存在しませんでした。

多くの開発者は vector<vector<T>> を使うか、1次元配列をインデックス計算（y \* width + x）で操作していましたが、これらにはパフォーマンス面や可読性の問題がありました。

std::mdspan の仕組み

std::mdspan は、1次元のデータレイアウトに対して多次元のインターフェースを提供します。

最大の特徴は、レイアウト（Layout）とアクセサ（Accessor）をカスタマイズできる点です。

コンポーネント役割
Extents多次元の形状（各次元のサイズ）を定義する。
Layout Policy多次元インデックスを1次元のオフセットにどう変換するかを決める（行優先・列優先など）。
Accessor Policyデータへのアクセス方法（アトミックアクセス、読み取り専用など）を定義する。

std::mdspan による行列操作の例

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

int main() {
    // 1次元のデータを用意
    std::vector<double> buffer(6, 0.0);
    for (int i = 0; i < 6; ++i) buffer[i] = i * 1.1;

    // 2行3列の多次元ビューを作成
    std::mdspan ms(buffer.data(), 2, 3);

    // 2次元インデックスでアクセス
    for (std::size_t i = 0; i < ms.extent(0); ++i) {
        for (std::size_t j = 0; j < ms.extent(1); ++j) {
            std::cout << "ms[" << i << ", " << j << "] = " << ms[i, j] << "\t";
        }
        std::cout << std::endl;
    }

    return 0;
}
実行結果
ms[0, 0] = 0	ms[0, 1] = 1.1	ms[0, 2] = 2.2	
ms[1, 0] = 3.3	ms[1, 1] = 4.4	ms[1, 2] = 5.5

C++23からは、角括弧内の複数引数 ms[i, j] がサポートされるようになり、数学的な表記に近い記述が可能になりました。

これにより、数値計算や画像処理のコードが非常にスッキリと記述できます。

コンパイル時最適化と配列の選択

現代のC++開発において、パフォーマンスを追求するなら「可能な限りコンパイル時に情報を確定させる」ことが鉄則です。

固定長か動的長か

もしデータの最大サイズが事前に分かっているなら、std::vector を使うよりも std::array を検討してください。

スタック割り当てはヒープ割り当てに比べて遥かに高速であり、メモリの断片化も防げます。

読み取り専用データの扱い

マスタデータやルックアップテーブルのような、一度定義したら変更しない配列については、constexpr と std::array を組み合わせるのが最適解です。

C++20以降、std::vector も constexpr 内で一時的に利用可能になりましたが、最終的な定数データとして保持するなら std::array に軍配が上がります。

安全な配列操作のためのベストプラクティス

2026年のコーディングスタンダードでは、安全性がこれまで以上に重視されます。

以下のガイドラインを意識しましょう。

  1. 境界チェックの使い分け：パフォーマンスが最優先されるループ内では [] 演算子を使い、ユーザー入力などを扱う不安定な箇所では at() を使って例外処理を行う。
  2. イテレータとRangeの活用：インデックスによるループ（for(int i=0; ...)）よりも、範囲ベースforループや std::ranges のアルゴリズムを使用する。これにより、インデックスのオフセットミス（オフバイワンエラー）を根本から排除できます。
  3. constの徹底：配列の内容を変更しない場合は、必ず const std::span<const T> のように、ビューに対しても const を付与する。

まとめ

C++における配列の扱いは、単なるデータの羅列から、「型安全で意図が明確な抽象化コンテナ」へと進化しました。

  • サイズが固定なら std::array
  • サイズが変動する、あるいは巨大なら std::vector
  • 関数引数として渡すなら std::span
  • 多次元データを扱うなら std::mdspan

これらを適切に使い分けることで、生の配列が抱えていた「ポインタ減衰」や「境界外アクセス」といったリスクを回避しつつ、C++本来の強みであるハードウェアに近いパフォーマンスを最大限に引き出すことができます。

2026年の今、改めて自身のコードを見直し、これらのモダンな道具を使いこなせているか確認してみましょう。

新しい標準機能を積極的に取り入れることは、単にコードを短くするだけでなく、長期的なメンテナンス性と安全性を確保するための最短ルートなのです。