[C++] ポインタを使って配列を引数として渡す方法

2025-04-15更新日: 2025-04-15

C++では、配列を関数に渡す際にポインタを使用して配列の先頭アドレスを引数として渡します。

例えば、int* arr として関数に宣言し、配列のサイズも別途引数で渡すことで、関数内で配列の各要素にアクセスできます。

ポインタを使うことで配列の効率的な操作が可能ですが、配列のサイズ情報はポインタ自体には含まれないため、サイズ管理が必要です。

目次から探す

ポインタと配列の基礎知識
配列をポインタとして扱う方法
関数への引数としてポインタを使用するメリット
実際のコード例
よくある誤解と注意点
ポインタを用いた配列渡しのベストプラクティス
まとめ

ポインタと配列の基礎知識

配列とは何か

配列は、同じデータ型の要素を連続して格納するためのデータ構造です。

配列を使用することで、複数の値を一つの変数名で管理できます。

配列の要素には、インデックスを使ってアクセスします。

インデックスは0から始まるため、最初の要素は配列名[0]でアクセスできます。

#include <iostream>
using namespace std;
int main() {
    int numbers[5] = {10, 20, 30, 40, 50}; // 整数型の配列を定義
    cout << "配列の最初の要素: " << numbers[0] << endl; // 10を出力
    return 0;
}

配列の最初の要素: 10

ポインタの基本

ポインタは、メモリ上のアドレスを格納するための変数です。

ポインタを使うことで、変数のアドレスを直接操作したり、動的メモリ管理を行ったりできます。

ポインタは、特定のデータ型のアドレスを指すため、ポインタの型はそのデータ型に依存します。

ポインタを宣言するには、型名の後にアスタリスク(*)を付けます。

#include <iostream>
using namespace std;
int main() {
    int value = 42; // 整数型の変数を定義
    int* ptr = &value; // valueのアドレスをptrに格納
    cout << "変数の値: " << value << endl; // 42を出力
    cout << "ポインタが指す値: " << *ptr << endl; // 42を出力
    return 0;
}

変数の値: 42
ポインタが指す値: 42

配列とポインタの関係

配列名は、配列の最初の要素のアドレスを指すポインタとして扱われます。

これにより、配列をポインタとして関数に渡すことが可能になります。

配列の要素にアクセスする際、ポインタ演算を使用することもできます。

配列とポインタの関係を理解することで、より効率的なプログラミングが可能になります。

#include <iostream>
using namespace std;
void printArray(int* arr, int size) { // ポインタを引数に取る関数
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " "; // 配列の要素を出力
    }
    cout << endl;
}
int main() {
    int numbers[5] = {1, 2, 3, 4, 5}; // 整数型の配列を定義
    printArray(numbers, 5); // 配列をポインタとして渡す
    return 0;
}

1 2 3 4 5

配列をポインタとして扱う方法

配列名とポインタの違い

配列名は、配列の最初の要素のアドレスを指すポインタとして扱われますが、配列名自体はポインタではありません。

配列名は定数であり、再代入することはできません。

一方、ポインタは変数であり、他のアドレスを指すように変更できます。

この違いを理解することは、配列とポインタを効果的に使用するために重要です。

#include <iostream>
using namespace std;
int main() {
    int arr[3] = {10, 20, 30}; // 整数型の配列を定義
    int* ptr = arr; // 配列名をポインタに代入
    // 配列名は定数なので、以下の行はエラーになる
    // arr = ptr; // エラー: 配列名に再代入はできない
    cout << "配列の最初の要素: " << arr[0] << endl; // 10を出力
    cout << "ポインタが指す最初の要素: " << *ptr << endl; // 10を出力
    return 0;
}

配列の最初の要素: 10
ポインタが指す最初の要素: 10

配列を関数に渡す際のポインタの使用方法

配列を関数に渡す際、配列名を引数として指定することで、ポインタとして扱われます。

これにより、配列の要素を直接操作することが可能になります。

関数内で配列の要素を変更する場合、ポインタを使用することで、元の配列にも影響を与えることができます。

#include <iostream>
using namespace std;
void modifyArray(int* arr, int size) { // ポインタを引数に取る関数
    for (int i = 0; i < size; i++) {
        arr[i] += 10; // 各要素に10を加算
    }
}
int main() {
    int numbers[3] = {1, 2, 3}; // 整数型の配列を定義
    modifyArray(numbers, 3); // 配列をポインタとして渡す
    // 変更後の配列を出力
    for (int i = 0; i < 3; i++) {
        cout << numbers[i] << " "; // 11 12 13を出力
    }
    cout << endl;
    return 0;
}

11 12 13

配列サイズの取り扱い

配列をポインタとして渡す場合、配列のサイズを関数に渡す必要があります。

C++では、配列のサイズ情報は自動的には渡されないため、別途引数として指定する必要があります。

これにより、関数内で配列の範囲を正しく管理し、範囲外アクセスを防ぐことができます。

#include <iostream>
using namespace std;
void printArraySize(int* arr, int size) { // ポインタとサイズを引数に取る関数
    cout << "配列のサイズ: " << size << endl; // サイズを出力
}
int main() {
    int numbers[5] = {1, 2, 3, 4, 5}; // 整数型の配列を定義
    printArraySize(numbers, sizeof(numbers) / sizeof(numbers[0])); // サイズを計算して渡す
    return 0;
}

配列のサイズ: 5

関数への引数としてポインタを使用するメリット

メモリ効率の向上

ポインタを使用して配列を関数に渡すことで、メモリ効率が向上します。

配列全体をコピーするのではなく、配列の最初の要素のアドレスだけを渡すため、メモリの使用量が大幅に削減されます。

特に大きな配列を扱う場合、このメリットは顕著です。

#include <iostream>
using namespace std;
void processArray(int* arr, int size) { // ポインタを引数に取る関数
    // 配列の要素を処理する
    for (int i = 0; i < size; i++) {
        arr[i] *= 2; // 各要素を2倍にする
    }
}
int main() {
    int largeArray[1000]; // 大きな配列を定義
    for (int i = 0; i < 1000; i++) {
        largeArray[i] = i + 1; // 配列に値を設定
    }
    processArray(largeArray, 1000); // ポインタを渡す
    return 0;
}

(出力はありませんが、メモリ効率が向上しています)

関数内での配列操作の柔軟性

ポインタを使用することで、関数内で配列の要素を直接操作できるため、柔軟性が増します。

配列のサイズや内容に応じて、さまざまな操作を行うことが可能です。

また、ポインタを使うことで、配列の一部を操作することも容易になります。

#include <iostream>
using namespace std;
void modifySubArray(int* arr, int start, int end) { // ポインタと範囲を引数に取る関数
    for (int i = start; i <= end; i++) {
        arr[i] += 5; // 指定範囲の各要素に5を加算
    }
}
int main() {
    int numbers[5] = {1, 2, 3, 4, 5}; // 整数型の配列を定義
    modifySubArray(numbers, 1, 3); // 配列の一部を変更
    // 変更後の配列を出力
    for (int i = 0; i < 5; i++) {
        cout << numbers[i] << " "; // 1 7 8 9 5を出力
    }
    cout << endl;
    return 0;
}

1 7 8 9 5

パフォーマンスの最適化

ポインタを使用することで、関数呼び出しの際のパフォーマンスが向上します。

配列全体をコピーする必要がないため、関数呼び出しのオーバーヘッドが減少します。

特に大きなデータセットを扱う場合、ポインタを使用することで、プログラム全体の実行速度が向上します。

#include <iostream>
using namespace std;
void sumArray(int* arr, int size, int& sum) { // ポインタと参照を引数に取る関数
    sum = 0; // 合計を初期化
    for (int i = 0; i < size; i++) {
        sum += arr[i]; // 各要素を合計
    }
}
int main() {
    int numbers[1000]; // 大きな配列を定義
    for (int i = 0; i < 1000; i++) {
        numbers[i] = i + 1; // 配列に値を設定
    }
    int total = 0; // 合計を格納する変数
    sumArray(numbers, 1000, total); // ポインタを渡す
    cout << "合計: " << total << endl; // 合計を出力
    return 0;
}

合計: 500500

実際のコード例

基本的な配列渡しの例

配列を関数に渡す基本的な例を示します。

この例では、配列の要素を出力する関数を定義し、配列をポインタとして渡します。

#include <iostream>
using namespace std;
void printArray(int* arr, int size) { // ポインタを引数に取る関数
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " "; // 配列の要素を出力
    }
    cout << endl;
}
int main() {
    int numbers[5] = {10, 20, 30, 40, 50}; // 整数型の配列を定義
    printArray(numbers, 5); // 配列をポインタとして渡す
    return 0;
}

10 20 30 40 50

ポインタを用いた配列操作の例

ポインタを使用して配列の要素を変更する例です。

この例では、配列の各要素に10を加算する関数を定義しています。

#include <iostream>
using namespace std;
void addToArray(int* arr, int size) { // ポインタを引数に取る関数
    for (int i = 0; i < size; i++) {
        arr[i] += 10; // 各要素に10を加算
    }
}
int main() {
    int numbers[5] = {1, 2, 3, 4, 5}; // 整数型の配列を定義
    addToArray(numbers, 5); // 配列をポインタとして渡す
    // 変更後の配列を出力
    for (int i = 0; i < 5; i++) {
        cout << numbers[i] << " "; // 11 12 13 14 15を出力
    }
    cout << endl;
    return 0;
}

11 12 13 14 15

動的配列とポインタの応用

動的メモリを使用して配列を作成し、ポインタを使って操作する例です。

この例では、ユーザーからの入力に基づいて配列のサイズを決定し、動的にメモリを確保します。

#include <iostream>
using namespace std;
int main() {
    int size;
    cout << "配列のサイズを入力してください: ";
    cin >> size; // ユーザーから配列のサイズを取得
    int* dynamicArray = new int[size]; // 動的に配列を確保
    // 配列に値を設定
    for (int i = 0; i < size; i++) {
        dynamicArray[i] = i + 1; // 1から始まる値を設定
    }
    // 配列の要素を出力
    for (int i = 0; i < size; i++) {
        cout << dynamicArray[i] << " "; // 1 2 3 ...を出力
    }
    cout << endl;
    delete[] dynamicArray; // 動的に確保したメモリを解放
    return 0;
}

配列のサイズを入力してください: 5
1 2 3 4 5

よくある誤解と注意点

配列の範囲外アクセス

配列の範囲外アクセスは、プログラムの不具合や予期しない動作を引き起こす一般的な問題です。

C++では、配列のインデックスは0から始まるため、配列のサイズを超えたインデックスにアクセスすると、未定義の動作が発生します。

これを防ぐためには、常にインデックスが配列の範囲内であることを確認する必要があります。

#include <iostream>
using namespace std;
int main() {
    int numbers[3] = {1, 2, 3}; // 整数型の配列を定義
    // 範囲外アクセスの例
    for (int i = 0; i <= 3; i++) { // iが3のとき、範囲外アクセス
        cout << numbers[i] << " "; // 未定義の動作が発生する可能性がある
    }
    cout << endl;
    return 0;
}

(未定義の動作が発生する可能性があります)

メモリ管理の重要性

動的メモリを使用する場合、メモリ管理は非常に重要です。

new演算子で確保したメモリは、使用後に必ずdeleteまたはdelete[]で解放する必要があります。

メモリを解放しないと、メモリリークが発生し、プログラムのパフォーマンスが低下する原因となります。

適切なメモリ管理を行うことで、プログラムの安定性と効率を保つことができます。

#include <iostream>
using namespace std;
int main() {
    int* dynamicArray = new int[5]; // 動的に配列を確保
    // 配列に値を設定
    for (int i = 0; i < 5; i++) {
        dynamicArray[i] = i + 1; // 1から5までの値を設定
    }
    // メモリを解放しない場合、メモリリークが発生する
    // delete[] dynamicArray; // これを忘れるとメモリリークになる
    return 0;
}

(メモリリークが発生する可能性があります)

型の一致とキャストの必要性

ポインタを使用する際、型の一致は非常に重要です。

異なるデータ型のポインタを混同すると、予期しない動作やエラーが発生する可能性があります。

必要に応じてキャストを行うことで、型の不一致を解消できますが、キャストを行う際は注意が必要です。

特に、ポインタの型を変更する場合は、元のデータ型のサイズや構造を理解しておくことが重要です。

#include <iostream>
using namespace std;
int main() {
    double value = 3.14; // double型の変数を定義
    void* ptr = &value; // voidポインタに格納
    // voidポインタをdoubleポインタにキャスト
    double* doublePtr = static_cast<double*>(ptr); // キャストを行う
    cout << "値: " << *doublePtr << endl; // 3.14を出力
    return 0;
}

値: 3.14

ポインタを用いた配列渡しのベストプラクティス

コードの可読性を保つ方法

ポインタを用いた配列渡しの際、コードの可読性を保つためには、関数名や変数名を明確にすることが重要です。

また、関数の引数に配列のサイズを明示的に渡すことで、関数の動作が理解しやすくなります。

さらに、コメントを適切に追加することで、他の開発者がコードの意図を理解しやすくなります。

#include <iostream>
using namespace std;
// 配列の要素を出力する関数
void printArray(int* arr, int size) {
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " "; // 各要素を出力
    }
    cout << endl;
}
int main() {
    int numbers[5] = {1, 2, 3, 4, 5}; // 整数型の配列を定義
    printArray(numbers, 5); // 配列をポインタとして渡す
    return 0;
}

1 2 3 4 5

安全なプログラミング手法

ポインタを使用する際は、常に安全性を考慮することが重要です。

配列の範囲外アクセスを防ぐために、インデックスのチェックを行うことが推奨されます。

また、ポインタがnullptrでないことを確認してからアクセスすることで、未定義の動作を防ぐことができます。

これにより、プログラムの安定性が向上します。

#include <iostream>
using namespace std;
void safeAccess(int* arr, int size, int index) {
    if (index >= 0 && index < size) { // インデックスの範囲をチェック
        cout << "要素: " << arr[index] << endl; // 要素を出力
    } else {
        cout << "エラー: インデックスが範囲外です。" << endl; // エラーメッセージ
    }
}
int main() {
    int numbers[5] = {10, 20, 30, 40, 50}; // 整数型の配列を定義
    safeAccess(numbers, 5, 2); // 有効なインデックス
    safeAccess(numbers, 5, 5); // 範囲外のインデックス
    return 0;
}

要素: 30
エラー: インデックスが範囲外です。

効率的なデバッグ方法

ポインタを使用するプログラムでは、デバッグが難しくなることがあります。

効率的なデバッグのためには、ポインタの値や配列の内容を定期的に出力することが有効です。

また、デバッガを使用して、ポインタのアドレスや配列の状態を確認することも重要です。

これにより、問題の特定が容易になります。

#include <iostream>
using namespace std;
void debugArray(int* arr, int size) {
    for (int i = 0; i < size; i++) {
        cout << "arr[" << i << "] = " << arr[i] << " (アドレス: " << &arr[i] << ")" << endl; // 要素とアドレスを出力
    }
}
int main() {
    int numbers[3] = {5, 10, 15}; // 整数型の配列を定義
    debugArray(numbers, 3); // デバッグ情報を出力
    return 0;
}

arr[0] = 5 (アドレス: 0x7ffee3b1c8a0)
arr[1] = 10 (アドレス: 0x7ffee3b1c8a4)
arr[2] = 15 (アドレス: 0x7ffee3b1c8a8)

まとめ

この記事では、C++におけるポインタを用いた配列の渡し方やその利点、注意点について詳しく解説しました。

ポインタを使用することで、メモリ効率の向上や柔軟な配列操作が可能になる一方で、範囲外アクセスやメモリ管理の重要性を理解することが求められます。

これらの知識を活かして、より安全で効率的なプログラミングを実践してみてください。