std::vector | Programming Place Plus　新C++編

このページの概要

このページでは、複数の同じ型の変数をひとまとめにして扱う機能を取り上げます。プログラムの内容によっては、大量のデータを取り扱わなければならないことがありますが、そのデータ１個ごとに１つの変数を宣言していたのでは、num1、num2、num3、・・・num100000 のように大量の変数ができてしまい、ソースコードが大変なことになります。変数を１つにまとめて整理できれば、記述量を大きく減らせるうえに、取り扱いも簡単になります。

以下は目次です。要点だけをさっと確認したい方は、「まとめ」をご覧ください。

• std::vector
• 初期化
  • 初期化に使う括弧について
• 要素へのアクセス
  • at関数
• 範囲for文
• 代入
• 比較
• まとめ
• 練習問題
• 参考リンク
• 更新履歴

std::vector

蔵書リストのプログラムを作ることを考えると、登録する本の冊数分のデータを扱わなければならないことがわかると思います。1000冊登録したいのなら、変数は 1000個必要ということになりそうです。本を登録した日時を保存する変数が必要だとすると、次のような宣言が並ぶことになります。

// それぞれの本の登録日時を記憶する変数
int book1_registered_date {};
int book2_registered_date {};
int book3_registered_date {};
int book4_registered_date {};
// こうやって 1000個繰り返す？

例として 1000冊といっただけで、本当は 1万冊ぐらいは登録したいかもしれません。そうなったら 1万個の変数を宣言しなければならないことになります。いずれにしても、これでは大変すぎます。

もし、「登録日時を〇冊分記憶できる変数」というものが作れれば便利でしょう。たとえば次のような感じです（これは仮のコードであって、C++ にこのような構文はありません）。

// 1000冊分の本の登録日時を記憶する変数
int books_registered_date x 1000;

books_registered_date という１つの変数で、int型の値を 1000個記憶できるという理想を示したコードです。これはコンパイルできませんが、同じことを、このページのテーマである std::vector によって実現できます。std::vector を使うと、次のように変数宣言できます。

// 1000冊分の本の登録日時を記憶する変数
std::vector<int> books_registered_date(1000);

books_registered_date という１つの変数で、int型の値を 1000個記憶できます。変数books_registered_date は、int型の変数が 1000個連結されたものであると考えていいです。このような、複数の同じ型の変数が連結された構造を、配列 (array) と呼びます。また、配列を構成する１つ１つの変数のことを、要素 (element) と呼びます。

C++ には、配列を作る方法がいくつかあって、std::vector はその１つです。配列を実現するもっとも初歩的な方法では、要素の個数をプログラムの実行中に変化させられない制約があるのですが、std::vector が実現する配列は、要素を追加したり削除したりして、要素数を変化させられます。このような配列は、可変長配列 (variable-length array) とか動的配列 (dynamic array) などと呼ばれます。解説が膨大になってしまうので、要素を増減させる話はこのページでは取り上げません。

なお、std::string も、char型の変数が複数連結されて１つの文字列になっており、配列の一種とみなせます。

変数books_registered_date を宣言するコードから明らかなように、std::vector<int> が型の名前です。単に std::vector と書くのではなく、<int> を末尾に付けることで、この std::vector の要素が int型だと指定したことになります。std::vector<double> とすれば、要素は double型ですし、std::vector<std::string> とすれば、要素は std::string型ということになります。要素の型の違いだけであって、できることに違いはありません。そのため、要素の型のことは考えずに一般的な話をするときには、単に「std::vector」と読んだり表記したりします。

ただし例外的に、std::vector<bool> だけは特別な扱いを受けることになっており、要素が bool型以外のときとは異なる部分があります¹。熟知したうえで使うことは問題ありませんが、そうでなければ避けておいたほうがいいかもしれません。

変数books_registered_date の宣言のとき、変数名の後ろに (1000) という記述がありました。これは 1000個の要素を持った状態で初期化しているということです。std::vector の初期化の方法は多種多様にあるので、後でまとめて取り上げることにします。

std::vector は、C++ の標準ライブラリ (standard library) の一部です。標準ライブラリとは、C++ の標準規格で仕様が定められている、機能の詰め合わせです。仕様が定められているため、どのコンパイラでも同じ方法で使えます。標準ライブラリに含まれている機能を使うためには、#include による準備が必要で、std::vector の場合は、#include <vector> という記述が必要です。std::string や std::ifstream など、これまでに登場した std:: が付くものたちは、標準ライブラリに含まれています。

std::vector は非常に多機能ですし、このページまでの知識では説明できないことも多いので、すべてを取り上げて説明することはしません。std::vector の全体像を知りたければ、リファレンスサイト（cpprefjp、cpprefernce.com）などで確認してください。

初期化

std::vector の変数を宣言し、初期化する方法は複数あります。すべてを紹介できませんが、std::vector<int> を例にとって、いくつか取り上げます。

// 要素がない状態で初期化
std::vector<int> v1;

// 要素の値を１つ１つ指定して初期化（この例では要素は 3個になる）
std::vector<int> v2 {10, 100, 1000};

// 要素がない状態で初期化
std::vector<int> v3 {};

// 要素が 1000個ある状態で初期化。各要素はデフォルト値を持つ
std::vector<int> v4 (1000);

// 要素が 1000個ある状態で初期化。各要素は 7 という値を持つ
std::vector<int> v5 (1000, 7);

// ほかの std::vector の内容で初期化（つまり v5 のコピーができる）
std::vector<int> v6 = v5;

【C++17】std::vector<int> v {10, 20, 30}; のように、初期値によって型が判断できる場合（この場合、10、20、30 から int型だと判る）、<int> の部分を省略して、std::vector v {10, 20, 30}; と書けるようになりました²。

v1 と v3 の結果は同じです。v1 のように明示的に初期値を指示しなくても問題ありませんが、これまでのページでそうしてきたように、初期値の指示を明確に書きたければ v3 のようにすればいいでしょう。

v4 の場合、各要素の初期値は、要素の型に応じた値になります。int型なら 0、double型なら 0.0、bool型なら false、char型なら '\0'、std::string型なら "" です。

後で登場しますが、このような初期値のルールは値初期化と呼ばれます。

なお、std::vector を constexpr変数として宣言することはできません。

【C++20】C++20 から可能になりました。

型名 変数名 初期化子;
型名 変数名;

std::vector<int> v1(1000);       // 1000個の要素。各要素は値初期化
std::vector<int> v2(1000, 7);    // 1000個の要素。各要素は 7 で初期化
std::string s1("xyz");           // "xyz" で初期化
std::string s2(1000, 'x');       // 1000文字。各文字は 'x'

std::vector<int> v {10, 100, 1000};
std::string s {'a', ' ', 'b'};

int n {10};        // OK

int n2 {10, 20};   // エラー

std::vector<int> v {};  // 要素無し
std::string s {};       // 空文字列
int n {};               // 0

std::vector<int> v {10.0, 100, 1000};  // 不可。10.0 は double (int へは縮小変換が必要)
std::string s {5000, ' ', 'b'};        // 不可。5000 は int (char へは縮小変換が必要)
int n {100.0};                         // 不可。100.0 は double (int へは縮小変換が必要)

int n = 100;    // 100 で初期化
int n2;         // 要注意。初期値が不明
std::vector v;  // OK. 要素なし
std::string s;  // OK. 空文字列

要素へのアクセス

std::vector の要素へアクセスするには [] を使用します。

v[0] = 10;
int n = v[0];

std::string の [] と同様、[] で範囲外アクセスをしてしまった場合は未定義動作です。この危険を避ける方法を後で取り上げます。

すべての要素に１つ１つアクセスしたければ、for文が便利です。

#include <iostream>
#include <vector>

int main()
{
    constexpr auto element_count = 5;
    std::vector<int> v(element_count);

    // 各要素の値を書き換える
    for (int i = 0; i < element_count; ++i) {
        v[i] = i;
    }

    // 各要素の値を出力
    for (int i = 0; i < element_count; ++i) {
        std::cout << v[i] << "\n";
    }
}

実行結果：

0
1
2
3
4

前述したとおり、範囲外アクセスしないように注意が必要です。ここでは要素数を constexpr変数で宣言して、要素数が登場する箇所の記述を共通化しました。あとから要素数を変えたいと思ったら、constexpr変数の値だけを書き換えれば、すべての箇所が自然に対応され、問題なく動作します。これも１つの方法ですが、そもそも添字を使わないようにすればいいという考え方もあります。これについては後で取り上げます。

#include <iostream>
#include <vector>

int main()
{
    constexpr auto element_count = 5;
    std::vector<int> v(element_count);

    for (int i = 0; i < element_count; ++i) {
        v.at(i) = i;
    }

    for (int i = 0; i < element_count; ++i) {
        std::cout << v.at(i) << "\n";
    }
}

0
1
2
3
4

#include <iostream>
#include <vector>

int main()
{
    constexpr auto element_count = 5;
    std::vector<int> v(element_count);

    // わざと範囲外アクセスしてみる
    for (int i = 0; i < element_count + 10; ++i) {
        std::cout << v.at(i) << "\n";
    }
}

0
0
0
0
0
(ここで強制終了)

範囲for文

範囲外アクセスによる未定義動作を防ぐためには、そもそも添字を登場させないという発想もあります。使える場面は限定されますが、その方法として、範囲for文 (range-based for) があります。

範囲for文は、配列のような「複数の要素が集まったもの」を、先頭から末尾まで１つ１つアクセスするという目的に特化した、特殊な for文です。したがって、std::vector や std::string に対して使用できます。

範囲for文が使える対象は厳密なルールがあり⁶、「複数の要素が集まったもの」であれば必ず使えるというわけではありません。

範囲for文の文法は次のようになっています。

for (変数宣言 : 複数の要素が集まったもの)
    繰り返したい文

使用するキーワードは、通常の for文と同じく「for」です。( ) の中の構文の違いによって、通常の for文なのか、範囲for文なのかが判断されます。

範囲for文は１周ごとに、「複数の要素が集まったもの」から要素を１つ、「変数宣言」で宣言した変数へコピーします。１周目は先頭の要素がコピーされます。この変数は「繰り返したい文」の中で使うことができます。次の周回では、さきほどコピーした要素の次の要素がコピーされます。末尾の要素まで終わっていたら、ループを抜け出します。要素が１つもない場合は、範囲for文の内側に入ることはありません。

「変数宣言」のところに記述するのは、int e のような型名と変数名だけで、ここには初期化子は書きません。

「繰り返したい文」に書ける文は１つだけですが、{ } で囲んでブロック文にすることで、複数の文を書けます。また、break文や continue文を使うことも可能です。

【C++20】「変数宣言」の手前に、for文と同じ「初期化文」を置けるようになりました。これによりたとえば、添字として使う変数を併用できます（for (int i = 0; int e : v) { std::cout << i << ": " << e << "\n"; ++i; }）。

実際のプログラムにすると、次のようになります。

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v {3, 4, 5, 6};

    for (int e : v) {
        std::cout << e << "\n";
    }
}

実行結果：

3
4
5
6

はじめて範囲for文のところが実行されるとき、v[0] の値が e にコピーされ、範囲for文の内側で e を使えます。２周目では、v[1] が e にコピーされ、範囲for文の内側で e を使えます。これが末尾まで繰り返されます。

間違えてはならないのは、e は v に含まれている要素の “コピー” であって、v に含まれている要素そのものではないということです。その意味は次のサンプルからわかります。

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v {3, 4, 5, 6};

    // 各要素を書き換える？
    for (int e : v) {
        e = 10;
    }

    // 各要素の値を出力
    for (int e : v) {
        std::cout << e << "\n";
    }
}

実行結果：

3
4
5
6

範囲for文の内側で e = 10; とすることで、v に含まれている各要素の値を 10 に書き換えたつもりですが、出力してみるとそうはなっていません。書き換えられたのは、コピーである e の方であって、コピー元になった v の各要素ではないからです。

範囲for文を使いつつ、要素の値を書き換えたい場合は、次のように変更します。

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v {3, 4, 5, 6};

    // 各要素を書き換える
    for (int& e : v) {
        e = 10;
    }

    // 各要素の値を出力
    for (int e : v) {
        std::cout << e << "\n";
    }
}

実行結果：

10
10
10
10

１つ目の範囲for文の変数宣言で、型名を int から int& に変更しただけです。型名に & が付くことで、参照型 (reference type) という型になります。

参照型の変数は、ほかの変数の別名として機能します。int& であれば、int型の変数に対する別名になれます。たとえば、int& r {n}; と宣言したあとに r = 10; とした場合、変数n に 10 を代入したことになります。つまり r が n の別名として機能したということです。

for (int& e : v) の場合、１周目の e は v[0] の別名です。したがって、e = 10; は v[0] = 10; をしていることになります。同様に２周目のときには、e は v[1] の別名です。そのため、e = 10; は v[1] = 10; をしていることになります。変更前のサンプルプログラムとちがって、v の要素のコピーを作っているわけではなくなり、v の要素を e という別名を通して変更していることになります。

【Ｃ言語プログラマー】実質的にはポインタと同じ考え方ですが、参照はポインタの機能を限定したような仕様になっており、ポインタにまつわる色々な危険な面を回避できます。たとえば、ヌルポインタのような状態がなく、ヌルアクセスが防がれます。

代入

std::vector の変数を、代入によってコピーすることは可能です。

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v1(5, 7);
    std::vector<int> v2 {};

    v2 = v1;

    for (int& e : v2) {
        std::cout << e << "\n";
    }
}

実行結果：

7
7
7
7
7

代入によって、= の右辺側の std::vector と同じ内容になります。このサンプルでいえば、v2 は要素なしの状態で初期化されていますが、v1 を代入したことによって、v1 と同様に、要素数が 5個、それぞれの値が 7 という状態になります。

なお、たとえば、std::vector<int> と std::vector<double> は別の型なので、代入できません。< > の中まで含めて、同じでなければなりません。

【Ｃ言語プログラマー】std::vector はシンプルな配列とは違い、memcpy関数や memmove関数を使ってコピーしてはいけません。

比較

std::vector 同士での比較も可能ですが、これもやはり < > の中まで含めて、同じ型でなければなりません。

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v1 {3, 4, 5};
    std::vector<int> v2 {3, 4, 6};

    std::cout << std::boolalpha
              << (v1 == v2) << "\n"
              << (v1 != v2) << "\n"
              << (v1 < v2) << "\n"
              << (v1 <= v2) << "\n"
              << (v1 > v2) << "\n"
              << (v1 >= v2) << "\n";
}

実行結果：

false
true
true
true
false
false

std::vector 同士での比較は、互いの要素を先頭から１つずつ突き合わせて比較します。このサンプルでは、3 と 3、4 と 4 の比較では同等ですが、5 と 6 の比較のところで 5 の方が小さいため、v1 の方が小さいということになります。どちらかの方が要素が少なくて、比較の最中に末尾に到達してしまった場合、要素が少ない方が小さいということになります。

【Ｃ言語プログラマー】std::vector はシンプルな配列とは違い、memcmp関数を使って比較してはいけません。

まとめ

• std::vector を使って、同じ型の複数の変数がまとまった配列を実現できる（std::vector<int> v (100); のように）
  • std::vector を使うには、#include <vector> が必要
  • 配列内の各変数のことを要素と呼ぶ
• std::vector を初期化する方法はさまざまあり、要素なしの状態で初期化したり、要素の個数を指定したり、初期値を指定したりできる
  • () を用いる方法は、コンストラクタと呼ばれる初期化機能を呼び出している
  • {} を用いる方法は、各要素の初期値を１つずつ指定するもので、リスト初期化と呼ばれる
  • = v; のような方法では、ほかの std::vector の内容と同じになる
  • 初期化子がない場合、要素が空の状態になる
• 要素へのアクセスには [] か at関数を用いる（v[i] とか v.at(i) のように）
  • 範囲外アクセスのとき、[] は未定義動作だが、at関数は（特に何もしなければ）プログラムが強制終了する
• 範囲for文を使って、複数の値が集まったものに対して、先頭から末尾まで順番にアクセスするコードを記述できる（for (int e : v) {} のように）
  • 要素はコピーされるため、書き換えを行っても、元になっている側の変数に変化はない。必要ならば参照型を使う（for (int& e : v) {} のように）
• std::vector の変数同士で代入したり比較したりできるが、< > の内側も含めて、同じ型でなければならない

新C++編の【本編】の各ページには、末尾に練習問題があります。ページ内で学んだ知識を確認する簡単な問題から、これまでに学んだ知識を組み合わせなければならない問題、あるいは更なる自力での調査や模索が必要になるような高難易度な問題をいくつか掲載しています。