ポインタ

[C++] ポインタの配列を初期化する方法

2025-01-18更新日: 2025-01-18

C++でポインタの配列を初期化する方法はいくつかあります。

まず、静的配列として初期化する場合、要素数を指定してポインタを格納する配列を宣言し、各要素にアドレスを代入します。

例えば、int* arr[3] = {&a, &b, &c};のように、整数型変数a, b, cのアドレスを配列に格納します。

動的配列として初期化する場合は、new演算子を使ってメモリを確保し、ポインタを格納します。

例えば、int** arr = new int*[3];でポインタの配列を作成し、各要素にnewで確保したメモリのアドレスを代入します。

これにより、柔軟にメモリを管理できます。

目次から探す

静的配列としてのポインタの配列の初期化
動的配列としてのポインタの配列の初期化
ポインタの配列の操作
応用例
まとめ

静的配列としてのポインタの配列の初期化

静的配列の宣言方法

C++において、ポインタの配列を静的に宣言する方法は、通常の配列の宣言と似ています。

以下に基本的な宣言方法を示します。

#include <iostream>
// int型のポインタを格納する配列を宣言
int* ptrArray[5];

この例では、ptrArrayは5つのint型ポインタを格納できる配列として宣言されています。

初期化時の要素の指定

ポインタの配列を初期化する際には、各要素に適切なアドレスを割り当てる必要があります。

以下の例では、静的配列の各要素にint型変数のアドレスを割り当てています。

#include <iostream>
int main() {
    int a = 10;
    int b = 20;
    int c = 30;
    // ポインタの配列を初期化
    int* ptrArray[3] = { &a, &b, &c };
    // 各要素の値を出力
    for (int i = 0; i < 3; ++i) {
        std::cout << "ptrArray[" << i << "]が指す値: " << *ptrArray[i] << std::endl;
    }
    return 0;
}

ptrArray[0]が指す値: 10
ptrArray[1]が指す値: 20
ptrArray[2]が指す値: 30

このコードでは、ptrArrayの各要素がそれぞれa, b, cのアドレスを指しており、ループを通じて各ポインタが指す値を出力しています。

初期化の例と注意点

ポインタの配列を初期化する際には、以下の点に注意が必要です。

初期化されていないポインタ: 配列の要素として使用するポインタは、必ず有効なアドレスを指すように初期化する必要があります。

未初期化のポインタを使用すると、未定義の動作を引き起こす可能性があります。

配列のサイズ: 静的配列のサイズはコンパイル時に決定されるため、サイズを超える要素を追加することはできません。

以下に、初期化の注意点を含む例を示します。

#include <iostream>
int main() {
    int x = 5;
    int y = 15;
    // 初期化されていないポインタを含む配列
    int* ptrArray[3] = { &x, &y, nullptr };
    // 各要素の値を出力
    for (int i = 0; i < 3; ++i) {
        if (ptrArray[i] != nullptr) {
            std::cout << "ptrArray[" << i << "]が指す値: " << *ptrArray[i] << std::endl;
        } else {
            std::cout << "ptrArray[" << i << "]はnullptrを指しています" << std::endl;
        }
    }
    return 0;
}

ptrArray[0]が指す値: 5
ptrArray[1]が指す値: 15
ptrArray[2]はnullptrを指しています

この例では、ptrArray[2]がnullptrで初期化されているため、アクセス時に特別な処理を行っています。

未初期化のポインタを使用しないように注意しましょう。

動的配列としてのポインタの配列の初期化

動的メモリ確保の基本

C++では、動的メモリ確保を行うことで、実行時に必要なメモリを柔軟に管理することができます。

動的メモリ確保は、new演算子を使用して行い、確保したメモリはdelete演算子を用いて解放します。

これにより、プログラムの実行中に必要なメモリを効率的に利用できます。

new演算子を用いた初期化

動的配列としてポインタの配列を初期化するには、まずポインタの配列自体を動的に確保し、その後、各要素に対しても動的メモリを確保します。

以下にその例を示します。

#include <iostream>
int main() {
    // ポインタの配列を動的に確保
    int** ptrArray = new int*[3];
    // 各ポインタに動的メモリを割り当て
    for (int i = 0; i < 3; ++i) {
        ptrArray[i] = new int(i * 10); // 0, 10, 20で初期化
    }
    // 各要素の値を出力
    for (int i = 0; i < 3; ++i) {
        std::cout << "ptrArray[" << i << "]が指す値: " << *ptrArray[i] << std::endl;
    }
    // メモリの解放
    for (int i = 0; i < 3; ++i) {
        delete ptrArray[i];
    }
    delete[] ptrArray;
    return 0;
}

ptrArray[0]が指す値: 0
ptrArray[1]が指す値: 10
ptrArray[2]が指す値: 20

このコードでは、ptrArrayは3つのint型ポインタを格納する配列として動的に確保され、各ポインタはそれぞれ0, 10, 20で初期化されています。

delete演算子によるメモリ解放

動的に確保したメモリは、使用後に必ず解放する必要があります。

解放を怠ると、メモリリークが発生し、プログラムのメモリ使用量が増加し続ける可能性があります。

delete演算子を使用して、個々のポインタが指すメモリを解放し、最後にポインタの配列自体をdelete[]で解放します。

以下に、メモリ解放の手順を示します。

#include <iostream>
int main() {
    // ポインタの配列を動的に確保
    int** ptrArray = new int*[3];
    // 各ポインタに動的メモリを割り当て
    for (int i = 0; i < 3; ++i) {
        ptrArray[i] = new int(i * 10);
    }
    // メモリの解放
    for (int i = 0; i < 3; ++i) {
        delete ptrArray[i]; // 各ポインタが指すメモリを解放
    }
    delete[] ptrArray; // ポインタの配列自体を解放
    return 0;
}

この例では、deleteを用いて各ポインタが指すメモリを解放し、delete[]を用いてポインタの配列自体を解放しています。

これにより、メモリリークを防ぐことができます。

ポインタの配列の操作

要素へのアクセス方法

ポインタの配列における要素へのアクセスは、通常の配列と同様にインデックスを使用して行います。

ポインタの配列では、各要素がポインタであるため、間接参照演算子*を用いて実際の値にアクセスします。

#include <iostream>
int main() {
    int a = 5;
    int b = 10;
    int c = 15;
    // ポインタの配列を初期化
    int* ptrArray[3] = { &a, &b, &c };
    // 各要素へのアクセスと出力
    for (int i = 0; i < 3; ++i) {
        std::cout << "ptrArray[" << i << "]が指す値: " << *ptrArray[i] << std::endl;
    }
    return 0;
}

ptrArray[0]が指す値: 5
ptrArray[1]が指す値: 10
ptrArray[2]が指す値: 15

このコードでは、ptrArrayの各要素に対して間接参照を行い、実際の値を出力しています。

ポインタの配列のサイズ変更

静的配列のサイズはコンパイル時に決定されるため、直接変更することはできません。

しかし、動的配列を使用することで、サイズを変更することが可能です。

動的配列のサイズを変更するには、新しいサイズの配列を確保し、既存の要素をコピーしてから古い配列を解放します。

#include <iostream>
int main() {
    // 初期のポインタの配列を動的に確保
    int** ptrArray = new int*[2];
    ptrArray[0] = new int(10);
    ptrArray[1] = new int(20);
    // 新しいサイズの配列を確保
    int** newPtrArray = new int*[3];
    for (int i = 0; i < 2; ++i) {
        newPtrArray[i] = ptrArray[i]; // 既存の要素をコピー
    }
    newPtrArray[2] = new int(30); // 新しい要素を追加
    // 古い配列を解放
    delete[] ptrArray;
    // 新しい配列の要素を出力
    for (int i = 0; i < 3; ++i) {
        std::cout << "newPtrArray[" << i << "]が指す値: " << *newPtrArray[i] << std::endl;
    }
    // メモリの解放
    for (int i = 0; i < 3; ++i) {
        delete newPtrArray[i];
    }
    delete[] newPtrArray;
    return 0;
}

newPtrArray[0]が指す値: 10
newPtrArray[1]が指す値: 20
newPtrArray[2]が指す値: 30

このコードでは、動的に確保した配列のサイズを変更し、新しい要素を追加しています。

ポインタの配列のコピー

ポインタの配列をコピーする際には、各ポインタが指すメモリの内容を新しいメモリ領域にコピーする必要があります。

単純にポインタをコピーするだけでは、同じメモリ領域を指すことになり、意図しない動作を引き起こす可能性があります。

#include <iostream>
#include <cstring> // memcpyを使用するために必要
int main() {
    // 元のポインタの配列を動的に確保
    int** originalArray = new int*[2];
    originalArray[0] = new int(100);
    originalArray[1] = new int(200);
    // コピー先の配列を動的に確保
    int** copiedArray = new int*[2];
    for (int i = 0; i < 2; ++i) {
        copiedArray[i] = new int(*originalArray[i]); // メモリの内容をコピー
    }
    // コピーされた配列の要素を出力
    for (int i = 0; i < 2; ++i) {
        std::cout << "copiedArray[" << i << "]が指す値: " << *copiedArray[i] << std::endl;
    }
    // メモリの解放
    for (int i = 0; i < 2; ++i) {
        delete originalArray[i];
        delete copiedArray[i];
    }
    delete[] originalArray;
    delete[] copiedArray;
    return 0;
}

copiedArray[0]が指す値: 100
copiedArray[1]が指す値: 200

このコードでは、originalArrayの各要素が指すメモリの内容をcopiedArrayにコピーしています。

これにより、コピー先の配列が独立したメモリ領域を持つことが保証されます。

応用例

文字列の配列としての利用

ポインタの配列は、文字列の配列として利用することができます。

C++では、文字列はchar型の配列として扱われるため、char*型のポインタを使用して文字列を指すことができます。

#include <iostream>
int main() {
    // 文字列の配列を初期化
    const char* stringArray[] = { "こんにちは", "世界", "C++" };
    // 各文字列を出力
    for (int i = 0; i < 3; ++i) {
        std::cout << "stringArray[" << i << "]: " << stringArray[i] << std::endl;
    }
    return 0;
}

stringArray[0]: こんにちは
stringArray[1]: 世界
stringArray[2]: C++

このコードでは、stringArrayは3つの文字列を指すポインタの配列として初期化され、各文字列が出力されています。

多次元配列の実装

ポインタの配列を用いることで、多次元配列を動的に実装することができます。

以下の例では、2次元配列を動的に確保し、各要素に値を設定しています。

#include <iostream>
int main() {
    // 2次元配列を動的に確保
    int rows = 2;
    int cols = 3;
    int** matrix = new int*[rows];
    for (int i = 0; i < rows; ++i) {
        matrix[i] = new int[cols];
    }
    // 配列に値を設定
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            matrix[i][j] = i * cols + j;
        }
    }
    // 配列の内容を出力
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
    // メモリの解放
    for (int i = 0; i < rows; ++i) {
        delete[] matrix[i];
    }
    delete[] matrix;
    return 0;
}

0 1 2 
3 4 5

このコードでは、2次元配列matrixが動的に確保され、各要素に値が設定されています。

最後に、メモリが適切に解放されています。

関数ポインタの配列

関数ポインタの配列を使用することで、異なる関数を動的に呼び出すことができます。

以下の例では、異なる計算を行う関数を関数ポインタの配列に格納し、動的に呼び出しています。

#include <iostream>
// 加算を行う関数
int add(int a, int b) {
    return a + b;
}
// 減算を行う関数
int subtract(int a, int b) {
    return a - b;
}
int main() {
    // 関数ポインタの配列を初期化
    int (*operationArray[2])(int, int) = { add, subtract };
    int x = 10;
    int y = 5;
    // 各関数を呼び出し
    std::cout << "加算: " << operationArray[0](x, y) << std::endl;
    std::cout << "減算: " << operationArray[1](x, y) << std::endl;
    return 0;
}