ポインタ

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

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

C++におけるポインタはメモリ上のアドレスを保持する変数で、配列は同種データを連続して格納する構造です。

配列名自体が先頭要素へのポインタとして扱われるため、ポインタ算術を用いて効率的に要素にアクセスできます。

ポインタは動的メモリ管理や関数への参照渡しに活用され、配列と組み合わせることで柔軟なデータ操作や高度なデータ構造の実装が可能です。

例えば、動的配列の生成や多次元配列の操作、効率的なアルゴリズムの実装など、基本を理解することで多様な応用が実現できます。

目次から探す

ポインタと配列の基本
- ポインタとは
- 配列とは
ポインタと配列の関係
- 配列名とポインタの関係
- ポインタ算術の基礎
ポインタの基本操作
配列の基本操作
動的メモリ管理とポインタ
ポインタと配列の応用技術
実践的な活用例
まとめ

ポインタと配列の基本

ポインタとは

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

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

ポインタは、特定のデータ型に関連付けられ、そのデータ型のサイズに基づいてメモリを操作します。

ポインタを使うことで、効率的なデータ処理や、複雑なデータ構造の実装が可能になります。

以下は、ポインタの基本的な使い方を示すサンプルコードです。

#include <iostream>
int main() {
    int value = 10; // 整数型の変数
    int* pointer = &value; // ポインタの宣言と初期化
    std::cout << "変数の値: " << value << std::endl; // 変数の値を表示
    std::cout << "ポインタが指すアドレス: " << pointer << std::endl; // ポインタのアドレスを表示
    std::cout << "ポインタが指す値: " << *pointer << std::endl; // ポインタが指す値を表示
    return 0;
}

変数の値: 10
ポインタが指すアドレス: 0x7ffee4b1c8bc (例)
ポインタが指す値: 10

配列とは

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

配列を使用することで、複数のデータを一つの変数名で管理することができ、効率的なデータ処理が可能になります。

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

以下は、配列の基本的な使い方を示すサンプルコードです。

#include <iostream>
int main() {
    int numbers[5] = {1, 2, 3, 4, 5}; // 整数型の配列の宣言と初期化
    std::cout << "配列の要素: " << std::endl;
    for (int i = 0; i < 5; i++) { // 配列の要素を表示
        std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
    }
    return 0;
}

配列の要素: 
numbers[0] = 1
numbers[1] = 2
numbers[2] = 3
numbers[3] = 4
numbers[4] = 5

ポインタと配列の関係

配列名とポインタの関係

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

つまり、配列名を使うことで、配列の先頭要素のアドレスを取得することができます。

この特性を利用することで、ポインタを使った配列の操作が可能になります。

以下は、配列名とポインタの関係を示すサンプルコードです。

#include <iostream>
int main() {
    int numbers[3] = {10, 20, 30}; // 整数型の配列の宣言と初期化
    int* pointer = numbers; // 配列名をポインタに代入
    std::cout << "配列の要素: " << std::endl;
    for (int i = 0; i < 3; i++) {
        std::cout << "pointer[" << i << "] = " << *(pointer + i) << std::endl; // ポインタを使って配列の要素にアクセス
    }
    return 0;
}

配列の要素: 
pointer[0] = 10
pointer[1] = 20
pointer[2] = 30

ポインタ算術の基礎

ポインタ算術は、ポインタを使ってメモリ上の位置を操作するための技術です。

ポインタに整数を加算または減算することで、ポインタが指すアドレスを移動させることができます。

これは、配列の要素にアクセスする際に非常に便利です。

ポインタ算術を使用する際は、ポインタのデータ型に基づいてアドレスが計算されることに注意が必要です。

以下は、ポインタ算術の基本的な使い方を示すサンプルコードです。

#include <iostream>
int main() {
    int values[4] = {100, 200, 300, 400}; // 整数型の配列の宣言と初期化
    int* pointer = values; // 配列名をポインタに代入
    std::cout << "ポインタ算術を使った配列の要素: " << std::endl;
    for (int i = 0; i < 4; i++) {
        std::cout << "values[" << i << "] = " << *(pointer + i) << std::endl; // ポインタ算術を使って要素にアクセス
    }
    return 0;
}

ポインタ算術を使った配列の要素: 
values[0] = 100
values[1] = 200
values[2] = 300
values[3] = 400

ポインタの基本操作

ポインタの宣言と初期化

ポインタを使用するには、まずポインタ変数を宣言し、初期化する必要があります。

ポインタの宣言では、ポインタが指すデータ型を指定します。

初期化には、他の変数のアドレスを取得するためにアドレス演算子(&)を使用します。

以下は、ポインタの宣言と初期化の例です。

#include <iostream>
int main() {
    int value = 42; // 整数型の変数
    int* pointer = &value; // ポインタの宣言と初期化
    std::cout << "ポインタが指すアドレス: " << pointer << std::endl; // ポインタのアドレスを表示
    std::cout << "ポインタが指す値: " << *pointer << std::endl; // ポインタが指す値を表示
    return 0;
}

ポインタが指すアドレス: 0x7ffee4b1c8bc (例)
ポインタが指す値: 42

アドレス演算子(&)と間接演算子(*)

アドレス演算子(&)は、変数のメモリアドレスを取得するために使用されます。

一方、間接演算子(*)は、ポインタが指すアドレスの値を取得するために使用されます。

これにより、ポインタを通じて変数の値を操作することができます。

以下は、アドレス演算子と間接演算子の使用例です。

#include <iostream>
int main() {
    int number = 25; // 整数型の変数
    int* pointer = &number; // ポインタの宣言と初期化
    std::cout << "変数の値: " << number << std::endl; // 変数の値を表示
    std::cout << "ポインタが指すアドレス: " << pointer << std::endl; // ポインタのアドレスを表示
    std::cout << "ポインタが指す値: " << *pointer << std::endl; // ポインタが指す値を表示
    return 0;
}

変数の値: 25
ポインタが指すアドレス: 0x7ffee4b1c8bc (例)
ポインタが指す値: 25

ポインタの参照とデリファレンス

ポインタの参照は、ポインタが指すアドレスを通じて、元の変数にアクセスすることを意味します。

デリファレンスは、ポインタが指すアドレスの値を取得することを指します。

これにより、ポインタを使って変数の値を変更することも可能です。

以下は、ポインタの参照とデリファレンスの例です。

#include <iostream>
int main() {
    int value = 15; // 整数型の変数
    int* pointer = &value; // ポインタの宣言と初期化
    std::cout << "元の値: " << value << std::endl; // 元の値を表示
    *pointer = 30; // ポインタを通じて値を変更
    std::cout << "変更後の値: " << value << std::endl; // 変更後の値を表示
    return 0;
}

元の値: 15
変更後の値: 30

配列の基本操作

配列の宣言と初期化

配列を使用するには、まず配列を宣言し、必要に応じて初期化します。

配列の宣言では、データ型と要素数を指定します。

初期化は、宣言時に行うことも、後から行うことも可能です。

以下は、配列の宣言と初期化の例です。

#include <iostream>
int main() {
    int numbers[5] = {1, 2, 3, 4, 5}; // 整数型の配列の宣言と初期化
    std::cout << "配列の要素: " << std::endl;
    for (int i = 0; i < 5; i++) {
        std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl; // 配列の要素を表示
    }
    return 0;
}

配列の要素: 
numbers[0] = 1
numbers[1] = 2
numbers[2] = 3
numbers[3] = 4
numbers[4] = 5

配列要素へのアクセス方法

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

インデックスは0から始まり、配列のサイズより小さい整数で指定します。

配列の要素にアクセスすることで、値の取得や変更が可能です。

以下は、配列要素へのアクセス方法を示すサンプルコードです。

#include <iostream>
int main() {
    char letters[4] = {'A', 'B', 'C', 'D'}; // 文字型の配列の宣言と初期化
    std::cout << "配列の要素: " << std::endl;
    for (int i = 0; i < 4; i++) {
        std::cout << "letters[" << i << "] = " << letters[i] << std::endl; // 配列の要素を表示
    }
    letters[2] = 'Z'; // 配列の要素を変更
    std::cout << "変更後の配列の要素: " << letters[2] << std::endl; // 変更後の要素を表示
    return 0;
}

配列の要素: 
letters[0] = A
letters[1] = B
letters[2] = C
letters[3] = D
変更後の配列の要素: Z

多次元配列の扱い方

多次元配列は、配列の中に配列を持つデータ構造です。

最も一般的な多次元配列は2次元配列で、行と列を持ちます。

多次元配列の要素には、複数のインデックスを使用してアクセスします。

以下は、2次元配列の扱い方を示すサンプルコードです。

#include <iostream>
int main() {
    int matrix[2][3] = { {1, 2, 3}, {4, 5, 6} }; // 2次元整数型配列の宣言と初期化
    std::cout << "2次元配列の要素: " << std::endl;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << "matrix[" << i << "][" << j << "] = " << matrix[i][j] << std::endl; // 要素を表示
        }
    }
    return 0;
}

2次元配列の要素: 
matrix[0][0] = 1
matrix[0][1] = 2
matrix[0][2] = 3
matrix[1][0] = 4
matrix[1][1] = 5
matrix[1][2] = 6

動的メモリ管理とポインタ

動的配列の生成と解放

C++では、動的メモリ管理を使用して、実行時に必要なサイズの配列を生成することができます。

これにより、プログラムの実行中に配列のサイズを変更することが可能になります。

動的に生成した配列は、使用が終わったら必ず解放する必要があります。

以下は、動的配列の生成と解放の例です。

#include <iostream>
int main() {
    int size = 5; // 配列のサイズ
    int* dynamicArray = new int[size]; // 動的配列の生成
    // 配列に値を代入
    for (int i = 0; i < size; i++) {
        dynamicArray[i] = i + 1; // 1から5までの値を代入
    }
    std::cout << "動的配列の要素: " << std::endl;
    for (int i = 0; i < size; i++) {
        std::cout << "dynamicArray[" << i << "] = " << dynamicArray[i] << std::endl; // 要素を表示
    }
    delete[] dynamicArray; // 動的配列の解放
    return 0;
}

動的配列の要素: 
dynamicArray[0] = 1
dynamicArray[1] = 2
dynamicArray[2] = 3
dynamicArray[3] = 4
dynamicArray[4] = 5

newとdeleteの使用方法

new演算子を使用すると、動的にメモリを確保することができます。

確保したメモリは、delete演算子を使用して解放する必要があります。

配列の場合は、delete[]を使用して解放します。

以下は、newとdeleteの使用方法を示すサンプルコードです。

#include <iostream>
int main() {
    int* singleValue = new int; // 単一の整数を動的に生成
    *singleValue = 10; // 値を代入
    std::cout << "動的に生成した値: " << *singleValue << std::endl; // 値を表示
    delete singleValue; // メモリの解放
    return 0;
}

動的に生成した値: 10

多次元配列の動的確保

多次元配列も動的に確保することができます。

2次元配列の場合、ポインタのポインタを使用して、各行の配列を動的に生成します。

以下は、2次元配列の動的確保の例です。

#include <iostream>
int main() {
    int rows = 2; // 行数
    int cols = 3; // 列数
    // 行のポインタを動的に生成
    int** dynamicMatrix = new int*[rows]; 
    // 各行の配列を動的に生成
    for (int i = 0; i < rows; i++) {
        dynamicMatrix[i] = new int[cols]; 
    }
    // 配列に値を代入
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            dynamicMatrix[i][j] = i * cols + j + 1; // 1から6までの値を代入
        }
    }
    std::cout << "動的に生成した2次元配列の要素: " << std::endl;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            std::cout << "dynamicMatrix[" << i << "][" << j << "] = " << dynamicMatrix[i][j] << std::endl; // 要素を表示
        }
    }
    // メモリの解放
    for (int i = 0; i < rows; i++) {
        delete[] dynamicMatrix[i]; // 各行の配列を解放
    }
    delete[] dynamicMatrix; // 行のポインタを解放
    return 0;
}

動的に生成した2次元配列の要素: 
dynamicMatrix[0][0] = 1
dynamicMatrix[0][1] = 2
dynamicMatrix[0][2] = 3
dynamicMatrix[1][0] = 4
dynamicMatrix[1][1] = 5
dynamicMatrix[1][2] = 6

ポインタと配列の応用技術

関数への配列とポインタの渡し方

C++では、配列を関数に渡す際に、配列名をポインタとして扱うことができます。

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

配列のサイズを関数に渡すことも重要です。

以下は、配列を関数に渡す例です。

#include <iostream>
void printArray(int* arr, int size) { // ポインタとサイズを引数に取る関数
    for (int i = 0; i < size; i++) {
        std::cout << "arr[" << i << "] = " << arr[i] << std::endl; // 配列の要素を表示
    }
}
int main() {
    int numbers[5] = {10, 20, 30, 40, 50}; // 整数型の配列の宣言と初期化
    printArray(numbers, 5); // 配列を関数に渡す
    return 0;
}

arr[0] = 10
arr[1] = 20
arr[2] = 30
arr[3] = 40
arr[4] = 50

ポインタを用いた効率的なアルゴリズム

ポインタを使用することで、メモリの直接操作が可能になり、効率的なアルゴリズムを実装できます。

特に、配列の要素をポインタで操作することで、ループのオーバーヘッドを減らすことができます。

以下は、ポインタを用いた配列の合計を計算する例です。

#include <iostream>
int main() {
    int numbers[5] = {1, 2, 3, 4, 5}; // 整数型の配列の宣言と初期化
    int sum = 0; // 合計を格納する変数
    int* pointer = numbers; // ポインタの初期化
    for (int i = 0; i < 5; i++) {
        sum += *(pointer + i); // ポインタを使って合計を計算
    }
    std::cout << "配列の合計: " << sum << std::endl; // 合計を表示
    return 0;
}

配列の合計: 15

高度なデータ構造の実装

ポインタと配列を使用することで、リンクリストやスタック、キューなどの高度なデータ構造を実装することができます。

以下は、単純なリンクリストの実装例です。

#include <iostream>
struct Node { // ノードの構造体
    int data; // データ
    Node* next; // 次のノードへのポインタ
};
void printList(Node* head) { // リストを表示する関数
    Node* current = head; // 現在のノード
    while (current != nullptr) {
        std::cout << current->data << " -> "; // データを表示
        current = current->next; // 次のノードに移動
    }
    std::cout << "nullptr" << std::endl; // リストの終わりを表示
}
int main() {
    // リストのノードを動的に生成
    Node* head = new Node{1, nullptr}; // 最初のノード
    head->next = new Node{2, nullptr}; // 2番目のノード
    head->next->next = new Node{3, nullptr}; // 3番目のノード
    printList(head); // リストを表示
    // メモリの解放
    Node* current = head;
    while (current != nullptr) {
        Node* nextNode = current->next; // 次のノードを保存
        delete current; // 現在のノードを解放
        current = nextNode; // 次のノードに移動
    }
    return 0;
}

1 -> 2 -> 3 -> nullptr

実践的な活用例

動的配列を利用したプログラム例

動的配列を使用することで、ユーザーからの入力に基づいてサイズを変更できるプログラムを作成できます。

以下は、ユーザーが入力した数値を動的配列に格納し、その合計を計算する例です。

#include <iostream>
int main() {
    int size; // 配列のサイズ
    std::cout << "配列のサイズを入力してください: ";
    std::cin >> size; // ユーザーからサイズを取得
    int* dynamicArray = new int[size]; // 動的配列の生成
    // ユーザーからの入力を配列に格納
    std::cout << "配列の要素を入力してください: " << std::endl;
    for (int i = 0; i < size; i++) {
        std::cin >> dynamicArray[i]; // 要素を入力
    }
    // 合計を計算
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += dynamicArray[i]; // 合計を計算
    }
    std::cout << "配列の合計: " << sum << std::endl; // 合計を表示
    delete[] dynamicArray; // メモリの解放
    return 0;
}

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

多次元配列を使ったデータ処理

多次元配列を使用して、行列の加算を行うプログラムを作成できます。

以下は、2つの2次元配列を加算する例です。

#include <iostream>
int main() {
    const int rows = 2; // 行数
    const int cols = 3; // 列数
    // 2つの2次元配列の宣言と初期化
    int matrixA[rows][cols] = { {1, 2, 3}, {4, 5, 6} };
    int matrixB[rows][cols] = { {7, 8, 9}, {10, 11, 12} };
    int result[rows][cols]; // 結果を格納する配列
    // 行列の加算
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            result[i][j] = matrixA[i][j] + matrixB[i][j]; // 加算
        }
    }
    // 結果を表示
    std::cout << "行列の加算結果: " << std::endl;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            std::cout << result[i][j] << " "; // 結果を表示
        }
        std::cout << std::endl;
    }
    return 0;
}

行列の加算結果: 
8 10 12 
14 16 18

ポインタと配列を組み合わせたプロジェクト事例

ポインタと配列を組み合わせて、簡単な学生の成績管理システムを作成することができます。

以下は、学生の名前と成績を管理するプログラムの例です。

#include <iostream>
#include <string>
struct Student { // 学生の構造体
    std::string name; // 名前
    int score; // 成績
};
void printStudents(Student* students, int count) { // 学生情報を表示する関数
    for (int i = 0; i < count; i++) {
        std::cout << "学生名: " << students[i].name << ", 成績: " << students[i].score << std::endl; // 学生情報を表示
    }
}
int main() {
    int studentCount = 3; // 学生の数
    Student* students = new Student[studentCount]; // 動的配列の生成
    // 学生情報の入力
    for (int i = 0; i < studentCount; i++) {
        std::cout << "学生名を入力してください: ";
        std::cin >> students[i].name; // 名前を入力
        std::cout << "成績を入力してください: ";
        std::cin >> students[i].score; // 成績を入力
    }
    printStudents(students, studentCount); // 学生情報を表示
    delete[] students; // メモリの解放
    return 0;
}

学生名を入力してください: Alice
成績を入力してください: 85
学生名を入力してください: Bob
成績を入力してください: 90
学生名を入力してください: Charlie
成績を入力してください: 78
学生名: Alice, 成績: 85
学生名: Bob, 成績: 90
学生名: Charlie, 成績: 78