[C++] ポインタと配列の基本と応用

Q: ポインタと参照の違いは何ですか？

ポインタと参照は、どちらも他の変数を指し示すために使用されますが、いくつかの重要な違いがあります。 宣言と初期化 : ポインタはint* ptr = &value;のように宣言し、アドレスを格納します。 一方、参照はint& ref = value;のように宣言し、初期化時に必ず対象を指定しなければなりません。 再代入 : ポインタは後から別のアドレスを指すように変更できますが、参照は一度初期化されると、他の変数を指すように変更することはできません。 NULLの扱い : ポインタはNULLを指すことができますが、参照はNULLを指すことができません。 参照は常に有効なオブジェクトを指している必要があります。

2024-08-24

C++におけるポインタと配列は、メモリ管理やデータ操作において重要な役割を果たします。

ポインタはメモリのアドレスを保持し、配列は同じ型のデータを連続して格納するための構造です。

ポインタを使うことで、配列の要素に直接アクセスしたり、動的メモリ割り当てを行うことが可能です。

また、ポインタ演算を利用して配列を操作することで、効率的なデータ処理が実現できます。

これらの基本と応用を理解することで、C++プログラミングの幅が広がります。

この記事でわかること

配列名がポインタとして扱われる理由とその操作方法
ポインタを使った配列の走査とコピーの方法
文字列リテラルとポインタの関係、および文字列操作関数の実装方法
二次元配列のポインタ操作と動的メモリ割り当ての方法
関数ポインタの宣言と使用方法、コールバック関数の実装方法

目次から探す

ポインタと配列の関係

C++において、ポインタと配列は密接な関係があります。

配列名はポインタとして扱われることが多く、ポインタを使って配列を操作することが可能です。

このセクションでは、配列名とポインタの関係、そしてポインタを使った配列操作について詳しく解説します。

配列名とポインタ

配列名はポインタ

配列名は、配列の最初の要素へのポインタとして扱われます。

これは、配列名を使ってポインタ演算を行うことができることを意味します。

#include <iostream>
int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    int* ptr = numbers; // 配列名は最初の要素へのポインタとして扱われる
    std::cout << "最初の要素: " << *ptr << std::endl; // ポインタを使って最初の要素を出力
    return 0;
}

最初の要素: 10

この例では、numbersという配列名が、配列の最初の要素へのポインタとしてptrに代入されています。

配列とポインタの相互変換

配列とポインタは相互に変換可能です。

配列の要素にアクセスする際に、ポインタを使ってアクセスすることができます。

#include <iostream>
int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    int* ptr = numbers;
    // ポインタを使って配列の要素にアクセス
    for (int i = 0; i < 5; ++i) {
        std::cout << "要素 " << i << ": " << *(ptr + i) << std::endl;
    }
    return 0;
}

要素 0: 10
要素 1: 20
要素 2: 30
要素 3: 40
要素 4: 50

この例では、ポインタ演算を使って配列の各要素にアクセスしています。

ポインタによる配列操作

ポインタを使った配列の走査

ポインタを使うことで、配列の要素を効率的に走査することができます。

ポインタをインクリメントすることで、次の要素に移動することが可能です。

#include <iostream>
int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    int* ptr = numbers;
    // ポインタを使って配列を走査
    while (ptr < numbers + 5) {
        std::cout << "要素: " << *ptr << std::endl;
        ++ptr; // ポインタを次の要素に移動
    }
    return 0;
}

要素: 10
要素: 20
要素: 30
要素: 40
要素: 50

この例では、ポインタを使って配列の各要素を順に出力しています。

ポインタによる配列のコピー

ポインタを使って配列の内容を別の配列にコピーすることもできます。

これは、ポインタを使ったメモリ操作の一例です。

#include <iostream>
int main() {
    int source[] = {10, 20, 30, 40, 50};
    int destination[5];
    int* srcPtr = source;
    int* destPtr = destination;
    // ポインタを使って配列をコピー
    for (int i = 0; i < 5; ++i) {
        *(destPtr + i) = *(srcPtr + i);
    }
    // コピーされた配列を出力
    for (int i = 0; i < 5; ++i) {
        std::cout << "コピーされた要素 " << i << ": " << destination[i] << std::endl;
    }
    return 0;
}

コピーされた要素 0: 10
コピーされた要素 1: 20
コピーされた要素 2: 30
コピーされた要素 3: 40
コピーされた要素 4: 50

この例では、source配列の内容がdestination配列にコピーされています。

ポインタを使うことで、直接メモリ操作を行うことができます。

応用例

ポインタはC++において非常に強力な機能であり、さまざまな応用が可能です。

このセクションでは、ポインタを使った文字列操作、多次元配列の操作、関数ポインタの利用について解説します。

ポインタを使った文字列操作

文字列リテラルとポインタ

文字列リテラルは、実際には文字の配列であり、ポインタを使って操作することができます。

文字列リテラルは読み取り専用のメモリ領域に格納されるため、ポインタを使ってその内容を変更することはできません。

#include <iostream>
int main() {
    const char* str = "こんにちは"; // 文字列リテラルへのポインタ
    std::cout << "文字列: " << str << std::endl; // ポインタを使って文字列を出力
    return 0;
}

文字列: こんにちは

この例では、strは文字列リテラルへのポインタとして扱われています。

文字列操作関数の実装

ポインタを使って文字列操作関数を実装することができます。

例えば、文字列の長さを計算する関数を作成してみましょう。

#include <iostream>
// 文字列の長さを計算する関数
int stringLength(const char* str) {
    const char* ptr = str;
    int length = 0;
    while (*ptr != '\0') { // 終端文字までループ
        ++length;
        ++ptr;
    }
    return length;
}
int main() {
    const char* str = "こんにちは";
    std::cout << "文字列の長さ: " << stringLength(str) << std::endl;
    return 0;
}

文字列の長さ: 5

この例では、ポインタを使って文字列の長さを計算する関数を実装しています。

多次元配列とポインタ

二次元配列のポインタ操作

二次元配列は、ポインタを使って操作することができます。

二次元配列は、配列の配列として扱われます。

#include <iostream>
int main() {
    int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int (*ptr)[3] = matrix; // 二次元配列へのポインタ
    // ポインタを使って二次元配列を出力
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 3; ++j) {
            std::cout << "要素 [" << i << "][" << j << "]: " << ptr[i][j] << std::endl;
        }
    }
    return 0;
}

要素 [0][0]: 1
要素 [0][1]: 2
要素 [0][2]: 3
要素 [1][0]: 4
要素 [1][1]: 5
要素 [1][2]: 6

この例では、二次元配列matrixをポインタを使って操作しています。

多次元配列の動的メモリ割り当て

多次元配列を動的にメモリ割り当てすることも可能です。

これは、ポインタを使ってメモリを管理することで実現できます。

#include <iostream>
int main() {
    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 + 1;
        }
    }
    // 配列を出力
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << "要素 [" << i << "][" << j << "]: " << matrix[i][j] << std::endl;
        }
    }
    // メモリを解放
    for (int i = 0; i < rows; ++i) {
        delete[] matrix[i];
    }
    delete[] matrix;
    return 0;
}

要素 [0][0]: 1
要素 [0][1]: 2
要素 [0][2]: 3
要素 [1][0]: 4
要素 [1][1]: 5
要素 [1][2]: 6

この例では、動的にメモリを割り当てて二次元配列を作成し、操作しています。

関数ポインタの利用

関数ポインタの宣言と使用

関数ポインタは、関数のアドレスを格納するためのポインタです。

これを使うことで、関数を動的に呼び出すことができます。

#include <iostream>
// 関数の宣言
int add(int a, int b) {
    return a + b;
}
int main() {
    // 関数ポインタの宣言と初期化
    int (*funcPtr)(int, int) = add;
    // 関数ポインタを使って関数を呼び出し
    std::cout << "合計: " << funcPtr(3, 4) << std::endl;
    return 0;
}

合計: 7

この例では、add関数のアドレスを関数ポインタfuncPtrに格納し、関数を呼び出しています。

コールバック関数の実装

コールバック関数は、関数ポインタを使って他の関数から呼び出される関数です。

これにより、柔軟なプログラム設計が可能になります。

#include <iostream>
// コールバック関数の宣言
void callbackFunction(int result) {
    std::cout << "計算結果: " << result << std::endl;
}
// 計算を行い、コールバック関数を呼び出す関数
void performCalculation(int a, int b, void (*callback)(int)) {
    int result = a + b;
    callback(result); // コールバック関数を呼び出し
}
int main() {
    performCalculation(5, 7, callbackFunction);
    return 0;
}