配列とポインタ | Programming Place Plus　新C++編

このページの概要

このページでは、前のページに続いて「配列」に関する話題を取り上げます。前のページでは深入りしなかった、配列からポインタへの変換についての話題を通して、ポインタについてもより詳しく学ぶことにします。配列をバイトの集まりとみなして 1バイトごとにアクセスする方法や、安全で分かりやすいプログラムを書く助けになる const についても触れています。

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

• 配列とポインタ
• const
  • constポインタ
• 配列を関数に渡す
• 配列を関数から返す
• std::string の内部にある文字列へのポインタ
• ポインタ演算
  • 間接参照
  • 加算
  • 減算
• バイト列
  • マニピュレータ
  • エンディアン
• まとめ
• 参考リンク
• 練習問題
• 更新履歴

配列とポインタ

「配列」のページで説明したとおり、一部の例外的な場面を除いて、式の中で配列はポインタに変換されます。そのため、配列どうしを等価演算子で比較するとうまくいきませんし、関数に配列を渡したり、関数から配列を返したりすることもできません。

配列がポインタに変換された結果は、その配列の先頭要素のメモリアドレスです。その型は、配列の要素の型に、ポインタ型であることをあらわす * を付加したものです。int型の配列は int* になりますし、double型の配列なら double* になるので、そのつもりで変数を初期化したり、代入したりできます。auto による型推論では、配列型ではなくポインタ型に推論されます。

int array[] {1, 2, 3, 4, 5};

// いずれも OK
int* p {array};
p = array;

// 以下は int* に推論される
auto a = array;
auto* a = array;  // 明確にするため auto* としても、同じ結果になる

配列がポインタに変換されたあとでも、添字演算子を使って要素にアクセスできます。p が array の先頭の要素のメモリアドレスを保持している状況では、array[2] と p[2] はまったく同じことです。

#include <iostream>

int main()
{
    int array[] {1, 2, 3, 4, 5};
    int* p {array};

    p[2] = 100;
    std::cout << p[2] << "\n";

    // array側からアクセスしても同じ
    std::cout << array[2] << "\n";
}

実行結果：

100
100

const

文字列リテラルの正体は char型の配列ですが、より正確には、const修飾された配列です。たとえば、文字列リテラルの "Hello" の型は const char[6] と表現されます。

【Ｃ言語プログラマー】Ｃ言語の文字列リテラルは const修飾されていません。しかし、内容を変更しようとする行為は未定義動作です。

この const は、型に新たな意味を付け加える（型を修飾する）、型修飾子 (type specifiers) を表しており、同じ型修飾子の一種である volatile と合わせて、CV修飾子 (cv-qualifiers) に分類されます。const が付加された型を「const修飾された型」「const修飾型」のように表現することがあります。また、「const な型」「const な変数」「const なオブジェクト」といった言い方をすることもあります。また、CV修飾子を付加された型を CV修飾型 (cv-qualified types) と呼びます。

volatile はここでは解説しません。

const修飾型の変数は次のように定義します。

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

const修飾型の変数は、必ず初期値が与えられなければならず、あとから値を書き換えることもできません。いずれかに違反するコードは通常、コンパイラによって検出されてエラーになります。未初期化な状態がないことや、値が変化しないことが保証されるので、プログラムを分かりやすく安全にする効果があります。

int main()
{
    const int value1 {};
    const int value2 {10};
    const int value3;  // エラー。初期化しなければならない

    value1 = 20;  // エラー。値を変更できない
    value2++;     // エラー。値を変更できない
}

型推論では const の有無は無視されますが、明示的に付加することはできます。

const int value {100};
auto v1 = value;        // int
const auto v2 = value;  // const int

文字列リテラルは const修飾された配列なので、次のコードはエラーになります。

"Hello"[2] = 'x';  // エラー。const修飾型の値は変更できない

そもそも少し変なコードに見えるかもしれませんが、文字列リテラルに添字演算子を適用することは問題ありません。c = "Hello"[2] のようにして、文字を読み取ることができます。

const修飾型と、その constされていないバージョンの型との違いは、値が書き換えられるかどうかだけです。表現できる値の範囲や、型の大きさ、アラインメントなどは同じです。

const修飾型の変数には２つの捉え方があります。１つは、「後から値を変更できない、読み取り専用の変数」と捉えることです。変数なので、初期値をほかの変数の値を使って決められる点で、constexpr変数よりも柔軟です。たとえば、何度も繰り返し同じ計算をおこなうとき、その計算結果を変数に取っておくと、計算を１回で済ませられますが、その計算済みの値は変更する必要がありませんから、const修飾型の変数に保存しておくことができます。

const auto tmp = a * b * c;  // 計算結果を取っておく
result = x * tmp + y / tmp + z / tmp;

もう１つは、定数であるとする捉え方です。整数型か列挙型の const修飾型の変数が、定数式で初期化されている場合は、その変数を定数式として使用できます¹。

【Ｃ言語プログラマー】Ｃ言語の const は定数として使うことはできません。

int a {3};
const int size {1000};  // 整数型であり、定数式で初期化している
int array[size] {};     // OK

const int x {3};  // 整数型であり、定数式で初期化している
switch (a) {
case x:  // OK
    break;
}

constexpr auto z = size * 10;  // OK

整数型や列挙型の const修飾型であっても、定数式で初期化されていない場合には、定数として使うことはできません。

int a {3};
const int size {1000 * a};  // 定数式で初期化していない
int array[size] {};         // コンパイルエラー

const int x {a};  // 定数式で初期化していない
switch (a) {
case x:  // コンパイルエラー
    break;
}

constexpr auto z = size * 10;  // コンパイルエラー

定数として使う const は constexpr に置き換えられますし、その方が明確です。整数型や列挙型である必要もなくなります。

const int array[] {1, 2, 3};
const int* p {value};  // OK
int const* p {value};  // これも同じ意味

const int array[] {1, 2, 3};
const int* pc {value};
int* p {pc};  // エラー

int value {100};
const int* p {&value};  // OK

int array[] {1, 2, 3};
const int* p {array};
p[0] = 10;   // エラー。constポインタを使った書き換えは不可

int array2[] {10, 20, 30};
p = array2;  // p の値を変更することはできる

int array[] {1, 2, 3};
int* const p {array};  // p は const修飾型の変数だが、constポインタではない
p[0] = 10;   // OK。constポインタではないので、この書き換えは可能

int array2[] {10, 20, 30};
p = array2;  // エラー。p は const修飾型なので、p 自体を書き換えることはできない

int value {100};
const int* const p {&value};  // constポインタであり、p 自体が const
p[0] = 10;   // エラー

int array2[] {10, 20, 30};
p = array2;  // エラー

const char* s {"Hello"};  // OK. const char[6] から const char* へ変換できる
char* s {"Hello"};        // エラー。const char[6] から char* へは変換できない

const int value {100};
const int* p {&value};
auto p1 = p;         // const int*
const auto p2 = p;   // const int* const

// * は明示してもいい
auto* p1 = p;        // const int*
const auto* p2 = p;  // const int* const

配列を関数に渡す

関数に配列そのものを渡すことはできませんが、ポインタに変換されたうえでならば渡せます。仮引数はポインタ型として宣言します。関数内で要素を書き換えないのであれば、constポインタを使えます。

void f1(int* array);
void f2(const int* array);

int array[] {1, 2, 3, 4, 5};
f1(array);
f2(array);

関数が受け取ったものはもはや配列ではなく、先頭要素のメモリアドレスに過ぎないことに注意が必要です。たとえば「配列」のページで作った SIZE_OF_ARRAYマクロを使って、配列の要素数を得ることはできません。

#include <iostream>

#define SIZE_OF_ARRAY(array)  (sizeof(array) / sizeof(array[0]))

void f(const int* array)
{
    // 正しくない
    for (std::size_t i = 0; i < SIZE_OF_ARRAY(array); ++i) {
        std::cout << array[i] << "\n";
    }
}

int main()
{
    int array[] {1, 2, 3, 4, 5};
    f(array);
}

実行結果：

1

SIZE_OF_ARRAY(array) を置換した結果は (sizeof(array) / sizeof(array[0])) です。ここで sizeof(array) は、配列全体の大きさではなく、ポインタ型の大きさを調べていることになるので、計算結果は欲しかったものとは違います。

関数内で配列の要素数が必要になるときには、呼び出し側で要素数を計算して渡す方法がよく使われます。

#include <iostream>

#define SIZE_OF_ARRAY(array)  (sizeof(array) / sizeof(array[0]))

void f(const int* array, std::size_t size)
{
    for (std::size_t i = 0; i < size; ++i) {
        std::cout << array[i] << "\n";
    }
}

int main()
{
    int array[] {1, 2, 3, 4, 5};
    f(array, SIZE_OF_ARRAY(array));
}

実行結果：

1
2
3
4
5

配列を関数から返す

ここまでの話と同じ理屈で、関数から配列を返すには、ポインタ型として返すことになります。しかし、関数を抜け出した時点で寿命が終わってしまう配列を返そうとしてはいけません。

#include <algorithm>
#include <iostream>

int* get_fill_array(int value)
{
    int array[1024];
    std::fill(std::begin(array), std::end(array), value);
    return array;  // 危険。直後に array の寿命が尽きる
}

int main()
{
    int* array {get_fill_array(100)};
    std::cout << array[0] << "\n";  // 未定義動作
}

静的ストレージ期間を持つ配列であれば、このような危険性はないですが、ローカルな配列のメモリアドレスを外にさらすことになります。ほかの関数内の変数にアクセスできることになるので、プログラムとしては分かりづらく管理しづらいものになります。

自動ストレージ期間を持つ配列のメモリアドレスを返していても、次のコードには問題がありません。

#include <algorithm>
#include <iostream>

#define SIZE_OF_ARRAY(array)  (sizeof(array) / sizeof(array[0]))

int* get_fill_array(int* array, std::size_t size, int value)
{
    std::fill_n(array, size, value);
    return array;  // OK。array の実体は呼び出し元のほうにあるので、ここで寿命が尽きるわけではない
}

int main()
{
    int array[1024] {};
    int* p {get_fill_array(array, SIZE_OF_ARRAY(array), 100)};
    std::cout << p[0] << "\n";  // OK
}

実行結果：

100

この場合、返している array は、仮引数の array です。仮引数の array は元々、main関数側にある array をポインタに変換したものですから、結局のところ、main関数の array のメモリアドレスが get_fill_array関数を経由して返ってきているだけです。main関数の array も、仮引数の array も自動ストレージ期間を持ちますが、main関数の array は、main関数内にいるかぎり寿命が尽きないので、p[0] にアクセスしても問題ありません。

std::string の内部にある文字列へのポインタ

std::string は、char型の生の配列を内部に隠して、安全で便利に使えるようにしたものですが、まれに std::string のまま取り扱うことができず、内部の生の文字列が必要なことがあります。典型的なのは、文字列を渡す関数の仮引数が std::string になっておらず、const char* になっている場合です。

#include <iostream>
#include <string>

// s に c が含まれているか？
bool contains(const char* s, char c)
{
    // ...
}

int main()
{
    std::string s {"abcde"};
    std::cout << std::boolalpha << contains(s, 'c') << "\n";  // エラー
}

対応方法の１つは、&s[0] のようにして、先頭要素を指すポインタを取得することですが、s.length() == 0 の場合に未定義動作にならないように注意が必要です。

もう１つのより良い方法に、c_strメンバ関数⁸あるいは dataメンバ関数⁹があります。どちらの関数を使っても同じで、std::string の内部にある文字列への constポインタを返します。s.length() == 0 の場合でも、ヌル文字だけが含まれた文字列を指すポインタを得られます。

【C++98/03 経験者】C++03 までの dataメンバ関数は、返された文字列の終端にヌル文字がありませんでした。C++11 で仕様が変更され、ヌル文字で終端されるようになったため、c_strメンバ関数とまったく同じ意味の関数になっています。

#include <iostream>
#include <string>

// s に c が含まれているか？
bool contains(const char* s, char c)
{
    for (const char* p {s}; p != '\0'; ++p) {
        if (*p == c) {
            return true;
        }
    }
    return false;
}

int main()
{
    std::string s {"abcde"};
    std::cout << std::boolalpha << contains(s.c_str(), 'c') << "\n";
}

実行結果：

true

constポインタでないポインタが欲しい場合は、（C++14 では）&s[0] の方法を使うしかありません。

【C++17】dataメンバ関数に、constポインタでないポインタを返すタイプが追加されました⁹。この追加は c_strメンバ関数には行われていないので、相互に置換可能なまったく同じ関数というわけでもなくなっています。

ただし、constポインタを使っていないということは、ポインタを経由した書き換えが行われるかもしれないということです。std::string が管理している内部の文字列を直接書き換えられると危険です。たとえば、+=演算子を使うなどの正当な方法を使わずに文字を追加すると、おかしなことになります。

#include <iostream>
#include <string>

// 末尾に１文字追加する
void add_char(char* s, char c)
{
    char* p {s};
    while (*p != '\0') {
        ++p;
    }
    *p = c;
    *(p + 1) = '\0';
}

int main()
{
    std::string s {"abcde"};
    add_char(&s[0], 'f');  // 危険
    std::cout << s.length() << "\n";
    std::cout << s << "\n";
}

実行結果：

5
abcde

意図どおりなら、１文字追加後の文字列は “abcdef” ですし、文字数は 6 であるはずですが、実行結果では変化が起きていません（Visual Studio 2015 で確認）。

ポインタ演算

ここまでポインタ型に対して、添字演算子以外の演算子を使うことはありませんでしたが、ほかにもいくつかの演算子が適用可能です。

*ポインタ

#include <iostream>

int main()
{
    int array[] {0, 1, 2, 3, 4, 5};

    int* p {array};
    std::cout << *p << "\n";

    p = &array[3];
    std::cout << *p << "\n";

    *p = 100;
    std::cout << *p << "\n";
}

0
3
100

#include <iostream>

int main()
{
    int array[] {0, 1, 2, 3, 4, 5};
    int* p {array};

    std::cout << p << "\n";
    std::cout << p + 1 << "\n";
    std::cout << p + 2 << "\n";

    ++p;
    std::cout << p << "\n";

    p += 3;
    std::cout << p << "\n";
}

00D6FA10
00D6FA14
00D6FA18
00D6FA14
00D6FA20

int array[] {0, 1, 2, 3, 4, 5};
int* p {&array[5]};

++p;  // OK. array の末尾の１つ後ろを指し示す
++p;  // 未定義動作

#include <iostream>

int main()
{
    int array[] {0, 1, 2, 3, 4, 5};
    int* p {&array[5]};

    std::cout << p << "\n";
    std::cout << p - 1 << "\n";
    std::cout << p - 2 << "\n";

    --p;
    std::cout << p << "\n";

    p -= 3;
    std::cout << p << "\n";
}

00AFFDC8
00AFFDC4
00AFFDC0
00AFFDC4
00AFFDB8

#include <iostream>

int main()
{
    int array[] {0, 1, 2, 3, 4, 5};
    int* p1 {&array[1]};
    int* p2 {&array[6]};

    std::cout << p2 - p1 << "\n";
}

5

バイト列

現在の目標であるバイナリエディタは、メモリの内容を確認するために用いるツールです。メモリはバイトが並んだものなので、各バイトにどんな値が入っているかを表示すれば、メモリの内容を可視化できます。

たとえば 4バイトの int型の値をそのまま表示するのではなく、1バイトずつに分割して、それぞれのバイトの値を表示するようにします。10億という値は、2進数では「00111011100110101100101000000000」という 32ビットで表現できますが、これを 1バイト（8ビット）ごとに区切ると、「00111011」「10011010」「11001010」「00000000」になります。一般的にバイナリエディタでは、これらを 16進数に変換して 2桁表記で表示します。すると、「3B」「9A」「CA」「00」となります。

このように、int型の整数値だったという事実は無視して、バイトの中身が何であるかだけを表示することを望みます。このような、本来の意味が無視された単なるバイトの並びをバイト列 (byte string) と呼びます。

バイト列は 1バイト単位の配列であると考えられます。そのため C++ では、大きさが 1バイトである unsigned char型の配列を使って表現します。符号にも用がないので、unsigned を使います。

【C++17】std::byte型という、より意味が明確になる型が追加されました⁴。

バイナリエディタで確認したいメモリの範囲が unsigned char型の配列で表現できれば、あとはその要素を出力すればいいだけです（16進数に変換することも簡単にできます）。「ポインタ演算」の項で説明したように、ポインタに対する加算の演算は、ポインタの型に応じた距離だけ移動するという特性を持っていますから、int型の配列を unsigned char型のポインタで指し示してやれば、++ を繰り返すことで、1バイトずつアクセスできます。

とはいえ、int型の配列は int* にしか変換されませんし、int* から unsigned char* のような、異なるポインタ型への変換も自由には行えません。

int array[1024];  // 各バイトを確認したい配列

unsigned char* bytes {array};  // コンパイルエラー
bytes = array;                 // コンパイルエラー

これはキャストによって解決できます。ただし static_cast ではなく、以下の２つの方法のいずれかを使わなければなりません。

bytes = reinterpret_cast<unsigned char*>(array);
bytes = (unsigned char*)array;

１行目のほうは、reinterpret_cast を用いています。reinterpret_cast は、指し示す先の型が異なるポインタどうしでの変換や、ポインタ型と整数型のあいだでの変換といった、限られたケースでのみ許されるキャストです。reinterpret_cast が許可するこれらのキャストは、結果が保証される範囲が限定的であったり、型変換はできるものの、変換後の値の扱い方を間違えると未定義動作などの危険な結果になることが多く、使用には慎重にならなければなりません。

たとえば、アラインメント（「メモリとオブジェクト」のページを参照）の要求が厳しくなる方向への変換（char* から int* など）は、変換自体はできるものの危険性があります。char* のポインタは、どんなメモリアドレスでも指し示せますが、int* ではたとえば 4 の倍数のメモリアドレスを指し示すことしか保証できないためです。キャスト後の型で間接参照を行った途端に、異常な結果になるかもしれません。

【C++98/03 経験者】reinterpret_cast で異なる型のポインタにキャストすることには結果の保証がなかったため、static_cast<T*>(static_cast<void*>(p)) のように、static_cast を使って、void* を経由させるコードを書くことがありました。C++11 以降、アラインメントの要求が厳しくならないのであれば、reinterpret_cast<T*>(p) がまったく同じ意味になる保証があります⁵。

２行目のほうは、Ｃ言語から受け継いだキャスト構文です。キャストの意図が分かりづらく、難解な型変換でも許されることがあり、C++ での利用は推奨されません⁶（こちらの方が入力量が少なくて、使いたくなりますが）。

C++ のキャストに static_cast や reinterpret_cast のように複数の種類が存在するのは（ほかに２つあります）、キャストの意図をプログラムが明確に示すことで、間違った使い方をコンパイラに発見してもらう意味があります。また、ソースコード上で目立つので、本来の型ではない型として、いわば例外的な扱いをしている箇所を見つけやすくなる利点もあります。

【上級】Ｃ言語のキャスト構文は、static_cast、reinterpret_cast（および const_cast）で行えることがすべて許され（異なるタイプのキャストを同時にまとめて行うことも含む）、さらに追加でいくつかの（多くは奇怪な）変換が可能になっています。⁷

次のプログラムは、int型の配列の中身を 1バイト単位で出力するものです。

#include <iostream>

int main()
{
    int array[] {7249, -53075, 547, 6082, 120};

    auto* bytes = reinterpret_cast<const unsigned char*>(array);
    for (std::size_t i = 0; i < sizeof(array); ++i) {
        std::cout << static_cast<unsigned int>(bytes[i]) << " ";
    }
    std::cout << "\n";
}

実行結果：

81 28 0 0 173 48 255 255 35 2 0 0 194 23 0 0 120 0 0 0

unsigned char型のポインタさえ得られれば、あとは末尾までループさせながら出力していくだけです。末尾の位置は、変換前の配列 (array) の大きさによって判断します。1バイト単位で取り扱うので、要素数ではなくて、sizeof で得られる大きさそのものを使います（i < sizeof(array)）。なお、std::cout は unsigned char型を整数として出力してくれないので、unsigned int にキャストしてから出力させています。

#include <iostream>

int main()
{
    int array[] {7249, -53075, 547, 6082, 120};

    auto* bytes = reinterpret_cast<const unsigned char*>(array);
    for (std::size_t i = 0; i < sizeof(array); ++i) {
        std::cout << std::hex << static_cast<unsigned int>(bytes[i]) << " ";
    }
    std::cout << "\n";
}

51 1c 0 0 ad 30 ff ff 23 2 0 0 c2 17 0 0 78 0 0 0

#include <iostream>

int main()
{
    int array[] {7249, -53075, 547, 6082, 120};

    auto* bytes = reinterpret_cast<const unsigned char*>(array);
    for (std::size_t i = 0; i < sizeof(array); ++i) {
        std::cout << std::hex << std::uppercase << static_cast<unsigned int>(bytes[i]) << " ";
    }
    std::cout << "\n";
}

51 1C 0 0 AD 30 FF FF 23 2 0 0 C2 17 0 0 78 0 0 0

#include <iomanip>
#include <iostream>

int main()
{
    int array[] {7249, -53075, 547, 6082, 120};

    auto* bytes = reinterpret_cast<const unsigned char*>(array);
    for (std::size_t i = 0; i < sizeof(array); ++i) {
        std::cout << std::setw(2) << std::setfill('0') << std::hex << std::uppercase
            << static_cast<unsigned int>(bytes[i]) << " ";
    }
    std::cout << "\n";
}

51 1C 00 00 AD 30 FF FF 23 02 00 00 C2 17 00 00 78 00 00 00

まとめ

• 配列はポインタへ暗黙的に変換される。結果は先頭の要素のメモリアドレスであり、その型は、要素の型を指すポインタ型である
• 配列を関数に渡すときや返すときにも、ポインタ型として扱う必要がある
  • 返すときには、ストレージ期間を超えてアクセスされないように注意を要する
• const int v {100}; といったように const修飾された型の変数は、初期化が必須であり、値をあとから変更できない
• 整数型や列挙型の const修飾型は、その値を定数式の中で使用できる。ただしこの用途では constexpr を使ったほうが明確である
• const int* p とか int const* p のように宣言されたポインタは constポインタであり、指し示す先の値を変更できない
• const修飾された型のオブジェクトを指し示すには、constポインタを使わなければならない
• 文字列リテラルは const修飾された char型の配列である
• ポインタp に対して *p とすることで、指し示す先にある値にアクセスできる。この操作を間接参照と呼ぶ
• 配列の要素を指すポインタは、+、+=、++ によって、要素の大きさに応じた距離だけメモリアドレスが加算される。減算も同様
• 同じ配列の要素を指す２つのポインタは減算でき、互いのあいだにある要素数が std::ptrdiff_t型の値として得られる
• reinterpret_cast を使って unsigned char* に変換することで、配列をバイト列とみなして、1バイト単位でアクセスできる
• 各種のマニピュレータによって、ストリームの挙動を制御できる
• ２バイト以上のデータは、各バイトがメモリ上で並ぶ順番に関する決まりがあり、エンディアンと呼ばれる
  • リトルエンディアンでは下位のバイトが上位側に来るように並び、ビッグエンディアンでは上位のバイトが上位側に来るように並ぶ

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