ポインタ

[C++] ポインタのポインタの基本と活用法

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

C++におけるポインタのポインタ(ダブルポインタ)は、ポインタを指すポインタです。

基本的な宣言はint **ptrのように行います。

これは、ptrがint型のポインタを指すことを意味します。

ダブルポインタは、動的な2次元配列の管理や、関数内でポインタを変更する際に使われます。

例えば、関数でポインタの値を変更したい場合、ダブルポインタを引数として渡すことで、元のポインタを直接操作できます。

また、複雑なデータ構造の管理や、メモリの効率的な利用にも役立ちます。

目次から探す

ポインタのポインタとは
ポインタのポインタの宣言と初期化
ポインタのポインタの操作
ポインタのポインタの活用法
ポインタのポインタを使った応用例
ポインタのポインタの注意点
まとめ

ポインタのポインタとは

ポインタのポインタは、C++における重要な概念の一つで、メモリ管理やデータ構造の操作において非常に役立ちます。

ここでは、ポインタの基本からダブルポインタの概念、そしてメモリのアドレスとポインタの関係について詳しく解説します。

ポインタの基本

ポインタは、メモリ上の特定のアドレスを指し示す変数です。

ポインタを使うことで、変数の値を直接操作することができます。

以下に基本的なポインタの宣言と使用例を示します。

#include <iostream>
int main() {
    int number = 10; // 整数型の変数を宣言し、値を10に設定
    int* ptr = &number; // ポインタを宣言し、numberのアドレスを代入
    std::cout << "numberの値: " << number << std::endl; // numberの値を出力
    std::cout << "ptrが指す値: " << *ptr << std::endl; // ポインタが指す値を出力
    return 0;
}

numberの値: 10
ptrが指す値: 10

この例では、ptrはnumberのアドレスを保持しており、*ptrを使うことでnumberの値にアクセスしています。

ダブルポインタの概念

ダブルポインタ(ポインタのポインタ)は、ポインタを指すポインタです。

これは、ポインタ自体のアドレスを保持するために使用されます。

以下にダブルポインタの宣言と使用例を示します。

#include <iostream>
int main() {
    int number = 20; // 整数型の変数を宣言し、値を20に設定
    int* ptr = &number; // ポインタを宣言し、numberのアドレスを代入
    int** doublePtr = &ptr; // ダブルポインタを宣言し、ptrのアドレスを代入
    std::cout << "numberの値: " << number << std::endl; // numberの値を出力
    std::cout << "ptrが指す値: " << *ptr << std::endl; // ポインタが指す値を出力
    std::cout << "doublePtrが指す値: " << **doublePtr << std::endl; // ダブルポインタが指す値を出力
    return 0;
}

numberの値: 20
ptrが指す値: 20
doublePtrが指す値: 20

この例では、doublePtrはptrのアドレスを保持しており、**doublePtrを使うことでnumberの値にアクセスしています。

メモリのアドレスとポインタの関係

ポインタはメモリのアドレスを扱うため、メモリ管理において非常に重要です。

ポインタを使うことで、変数のメモリ上の位置を直接操作することができます。

以下に、メモリのアドレスを表示する例を示します。

#include <iostream>
int main() {
    int number = 30; // 整数型の変数を宣言し、値を30に設定
    int* ptr = &number; // ポインタを宣言し、numberのアドレスを代入
    std::cout << "numberのアドレス: " << &number << std::endl; // numberのアドレスを出力
    std::cout << "ptrの値(numberのアドレス): " << ptr << std::endl; // ptrの値を出力
    return 0;
}

numberのアドレス: 0x7ffee4b3c8ac
ptrの値(numberのアドレス): 0x7ffee4b3c8ac

この例では、&numberとptrの値が同じであることが確認できます。

ポインタを使うことで、変数のメモリ上の位置を直接操作することが可能です。

ポインタのポインタの宣言と初期化

ポインタのポインタ、またはダブルポインタは、ポインタを指すポインタです。

これにより、ポインタ自体のアドレスを操作することが可能になります。

ここでは、ダブルポインタの宣言方法、初期化、そしてNULLポインタとの関係について解説します。

ダブルポインタの宣言方法

ダブルポインタは、通常のポインタの宣言にもう一つのアスタリスクを追加することで宣言します。

以下にダブルポインタの宣言例を示します。

#include <iostream>
int main() {
    int number = 10; // 整数型の変数を宣言し、値を10に設定
    int* ptr = &number; // ポインタを宣言し、numberのアドレスを代入
    int** doublePtr; // ダブルポインタを宣言
    doublePtr = &ptr; // ダブルポインタにptrのアドレスを代入
    std::cout << "numberの値: " << number << std::endl; // numberの値を出力
    std::cout << "ptrが指す値: " << *ptr << std::endl; // ポインタが指す値を出力
    std::cout << "doublePtrが指す値: " << **doublePtr << std::endl; // ダブルポインタが指す値を出力
    return 0;
}

numberの値: 10
ptrが指す値: 10
doublePtrが指す値: 10

この例では、doublePtrはptrのアドレスを保持し、**doublePtrを使うことでnumberの値にアクセスしています。

ダブルポインタの初期化

ダブルポインタを初期化する際には、まず通常のポインタを初期化し、その後にダブルポインタを初期化します。

以下に初期化の例を示します。

#include <iostream>
int main() {
    int number = 20; // 整数型の変数を宣言し、値を20に設定
    int* ptr = &number; // ポインタを宣言し、numberのアドレスを代入
    int** doublePtr = &ptr; // ダブルポインタを宣言し、ptrのアドレスを代入
    std::cout << "numberの値: " << number << std::endl; // numberの値を出力
    std::cout << "ptrが指す値: " << *ptr << std::endl; // ポインタが指す値を出力
    std::cout << "doublePtrが指す値: " << **doublePtr << std::endl; // ダブルポインタが指す値を出力
    return 0;
}

numberの値: 20
ptrが指す値: 20
doublePtrが指す値: 20

この例では、ptrとdoublePtrの両方が正しく初期化されており、numberの値にアクセスできます。

NULLポインタとダブルポインタ

ダブルポインタを使用する際には、NULLポインタを扱うことも重要です。

NULLポインタは、ポインタが有効なメモリアドレスを指していないことを示します。

以下にNULLポインタを使った例を示します。

#include <iostream>
int main() {
    int* ptr = nullptr; // ポインタをNULLで初期化
    int** doublePtr = &ptr; // ダブルポインタを宣言し、ptrのアドレスを代入
    if (*doublePtr == nullptr) {
        std::cout << "ptrはNULLを指しています。" << std::endl; // ptrがNULLを指していることを出力
    } else {
        std::cout << "ptrが指す値: " << **doublePtr << std::endl; // ポインタが指す値を出力
    }
    return 0;
}

ptrはNULLを指しています。

この例では、ptrがNULLで初期化されているため、*doublePtrもNULLを指しています。

NULLポインタを扱う際には、必ずNULLチェックを行うことが重要です。

ポインタのポインタの操作

ポインタのポインタ、またはダブルポインタを使うことで、ポインタ自体の値を操作したり、メモリ上のデータを効率的に管理することができます。

ここでは、ダブルポインタを使った値の変更、デリファレンス、そしてインクリメントとデクリメントについて解説します。

ダブルポインタを使った値の変更

ダブルポインタを使うことで、ポインタが指す値を間接的に変更することができます。

以下にダブルポインタを使った値の変更の例を示します。

#include <iostream>
void changeValue(int** doublePtr) {
    **doublePtr = 50; // ダブルポインタを使って値を変更
}
int main() {
    int number = 10; // 整数型の変数を宣言し、値を10に設定
    int* ptr = &number; // ポインタを宣言し、numberのアドレスを代入
    int** doublePtr = &ptr; // ダブルポインタを宣言し、ptrのアドレスを代入
    std::cout << "変更前のnumberの値: " << number << std::endl; // 変更前のnumberの値を出力
    changeValue(doublePtr); // ダブルポインタを使って値を変更
    std::cout << "変更後のnumberの値: " << number << std::endl; // 変更後のnumberの値を出力
    return 0;
}

変更前のnumberの値: 10
変更後のnumberの値: 50

この例では、changeValue関数を通じて、ダブルポインタを使ってnumberの値を変更しています。

ダブルポインタのデリファレンス

ダブルポインタのデリファレンスは、ポインタが指すポインタの指す値にアクセスするために使用されます。

以下にデリファレンスの例を示します。

#include <iostream>
int main() {
    int number = 30; // 整数型の変数を宣言し、値を30に設定
    int* ptr = &number; // ポインタを宣言し、numberのアドレスを代入
    int** doublePtr = &ptr; // ダブルポインタを宣言し、ptrのアドレスを代入
    std::cout << "ptrが指す値: " << *ptr << std::endl; // ポインタが指す値を出力
    std::cout << "doublePtrが指す値: " << **doublePtr << std::endl; // ダブルポインタが指す値を出力
    return 0;
}

ptrが指す値: 30
doublePtrが指す値: 30

この例では、*ptrと**doublePtrの両方がnumberの値にアクセスしています。

ダブルポインタのインクリメントとデクリメント

ダブルポインタのインクリメントとデクリメントは、ポインタのアドレスを操作するために使用されます。

以下にインクリメントとデクリメントの例を示します。

#include <iostream>
int main() {
    int numbers[] = {10, 20, 30}; // 整数型の配列を宣言
    int* ptr = numbers; // 配列の先頭アドレスをポインタに代入
    int** doublePtr = &ptr; // ダブルポインタを宣言し、ptrのアドレスを代入
    std::cout << "初期の値: " << **doublePtr << std::endl; // 初期の値を出力
    (*doublePtr)++; // ダブルポインタを使ってポインタをインクリメント
    std::cout << "インクリメント後の値: " << **doublePtr << std::endl; // インクリメント後の値を出力
    (*doublePtr)--; // ダブルポインタを使ってポインタをデクリメント
    std::cout << "デクリメント後の値: " << **doublePtr << std::endl; // デクリメント後の値を出力
    return 0;
}

初期の値: 10
インクリメント後の値: 20
デクリメント後の値: 10

この例では、(*doublePtr)++と(*doublePtr)--を使って、ptrが指すアドレスを操作し、配列内の異なる要素にアクセスしています。

ポインタのポインタの活用法

ポインタのポインタは、C++において様々な場面で活用されます。

特に、2次元配列の管理や関数でのポインタの変更、複雑なデータ構造の管理においてその威力を発揮します。

ここでは、それぞれの活用法について詳しく解説します。

2次元配列の管理

2次元配列は、行列のようなデータを扱う際に使用されます。

ポインタのポインタを使うことで、2次元配列を動的に管理することが可能です。

以下に2次元配列の管理の例を示します。

#include <iostream>
int main() {
    int rows = 3; // 行数を設定
    int cols = 3; // 列数を設定
    // 2次元配列を動的に確保
    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 
6 7 8

この例では、ポインタのポインタを使って2次元配列を動的に確保し、行列のようにデータを管理しています。

関数でのポインタの変更

関数内でポインタの値を変更する場合、ポインタのポインタを使うことで、元のポインタを変更することができます。

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

#include <iostream>
void updatePointer(int** ptr) {
    static int newValue = 100; // 新しい値を設定
    *ptr = &newValue; // ポインタの指す先を変更
}
int main() {
    int number = 50; // 整数型の変数を宣言し、値を50に設定
    int* ptr = &number; // ポインタを宣言し、numberのアドレスを代入
    std::cout << "変更前のptrが指す値: " << *ptr << std::endl; // 変更前の値を出力
    updatePointer(&ptr); // 関数を呼び出してポインタを変更
    std::cout << "変更後のptrが指す値: " << *ptr << std::endl; // 変更後の値を出力
    return 0;
}

変更前のptrが指す値: 50
変更後のptrが指す値: 100

この例では、updatePointer関数を使って、ptrが指す先を変更しています。

複雑なデータ構造の管理

ポインタのポインタは、リンクリストやツリー構造などの複雑なデータ構造を管理する際にも役立ちます。

以下にリンクリストのノードを追加する例を示します。

#include <iostream>
struct Node {
    int data; // ノードのデータ
    Node* next; // 次のノードへのポインタ
};
void addNode(Node** head, int value) {
    Node* newNode = new Node(); // 新しいノードを作成
    newNode->data = value; // データを設定
    newNode->next = *head; // 新しいノードの次を現在のヘッドに設定
    *head = newNode; // ヘッドを新しいノードに更新
}
void printList(Node* head) {
    while (head != nullptr) {
        std::cout << head->data << " "; // ノードのデータを出力
        head = head->next; // 次のノードに移動
    }
    std::cout << std::endl;
}
int main() {
    Node* head = nullptr; // リストのヘッドを初期化
    addNode(&head, 10); // ノードを追加
    addNode(&head, 20); // ノードを追加
    addNode(&head, 30); // ノードを追加
    printList(head); // リストの内容を出力
    return 0;
}

30 20 10

この例では、ポインタのポインタを使ってリンクリストにノードを追加し、リスト全体を管理しています。

ポインタのポインタを使うことで、データ構造の先頭を効率的に操作することができます。

ポインタのポインタを使った応用例

ポインタのポインタは、C++における高度なプログラミングテクニックとして、動的メモリ管理やデータ構造の実装において非常に有用です。

ここでは、動的メモリ管理、リンクリストの実装、ツリー構造の操作における応用例を紹介します。

動的メモリ管理

ポインタのポインタを使うことで、動的にメモリを確保し、効率的に管理することができます。

以下に動的メモリ管理の例を示します。

#include <iostream>
void allocateMemory(int** ptr, int size) {
    *ptr = new int[size]; // 動的にメモリを確保
    for (int i = 0; i < size; ++i) {
        (*ptr)[i] = i; // 確保したメモリに値を設定
    }
}
int main() {
    int* array = nullptr; // ポインタを初期化
    int size = 5; // 配列のサイズを設定
    allocateMemory(&array, size); // メモリを確保
    for (int i = 0; i < size; ++i) {
        std::cout << array[i] << " "; // 配列の内容を出力
    }
    std::cout << std::endl;
    delete[] array; // メモリを解放
    return 0;
}

0 1 2 3 4

この例では、allocateMemory関数を使って動的にメモリを確保し、配列に値を設定しています。

ポインタのポインタを使うことで、関数内でメモリを確保し、呼び出し元にそのアドレスを渡すことができます。

リンクリストの実装

リンクリストは、ポインタのポインタを使って効率的に実装することができます。

以下にリンクリストの追加と表示の例を示します。

#include <iostream>
struct Node {
    int data; // ノードのデータ
    Node* next; // 次のノードへのポインタ
};
void insertNode(Node** head, int value) {
    Node* newNode = new Node(); // 新しいノードを作成
    newNode->data = value; // データを設定
    newNode->next = *head; // 新しいノードの次を現在のヘッドに設定
    *head = newNode; // ヘッドを新しいノードに更新
}
void displayList(Node* head) {
    while (head != nullptr) {
        std::cout << head->data << " "; // ノードのデータを出力
        head = head->next; // 次のノードに移動
    }
    std::cout << std::endl;
}
int main() {
    Node* head = nullptr; // リストのヘッドを初期化
    insertNode(&head, 10); // ノードを追加
    insertNode(&head, 20); // ノードを追加
    insertNode(&head, 30); // ノードを追加
    displayList(head); // リストの内容を出力
    return 0;
}

30 20 10

この例では、insertNode関数を使ってリンクリストにノードを追加し、displayList関数でリストの内容を表示しています。

ポインタのポインタを使うことで、リストの先頭を効率的に操作することができます。

ツリー構造の操作

ツリー構造の操作においても、ポインタのポインタは役立ちます。

以下に二分木のノード追加の例を示します。

#include <iostream>
struct TreeNode {
    int data; // ノードのデータ
    TreeNode* left; // 左の子ノードへのポインタ
    TreeNode* right; // 右の子ノードへのポインタ
};
void insertTreeNode(TreeNode** root, int value) {
    if (*root == nullptr) {
        *root = new TreeNode(); // 新しいノードを作成
        (*root)->data = value; // データを設定
        (*root)->left = nullptr; // 左の子ノードを初期化
        (*root)->right = nullptr; // 右の子ノードを初期化
    } else if (value < (*root)->data) {
        insertTreeNode(&((*root)->left), value); // 左の子ノードに挿入
    } else {
        insertTreeNode(&((*root)->right), value); // 右の子ノードに挿入
    }
}
void inorderTraversal(TreeNode* root) {
    if (root != nullptr) {
        inorderTraversal(root->left); // 左の子ノードを訪問
        std::cout << root->data << " "; // ノードのデータを出力
        inorderTraversal(root->right); // 右の子ノードを訪問
    }
}
int main() {
    TreeNode* root = nullptr; // ツリーのルートを初期化
    insertTreeNode(&root, 20); // ノードを追加
    insertTreeNode(&root, 10); // ノードを追加
    insertTreeNode(&root, 30); // ノードを追加
    inorderTraversal(root); // ツリーの内容を中順で出力
    return 0;
}

10 20 30

この例では、insertTreeNode関数を使って二分木にノードを追加し、inorderTraversal関数でツリーの内容を中順で表示しています。

ポインタのポインタを使うことで、ツリー構造のノードを効率的に操作することができます。

ポインタのポインタの注意点

ポインタのポインタを使用する際には、いくつかの注意点があります。

特に、メモリリークの防止やデバッグ、安全なポインタ操作のためのベストプラクティスを理解しておくことが重要です。

ここでは、それぞれの注意点について詳しく解説します。

メモリリークの防止

メモリリークは、動的に確保したメモリを解放しないままプログラムが終了することで発生します。

ポインタのポインタを使用する場合、メモリリークを防ぐために、確保したメモリを適切に解放することが重要です。

#include <iostream>
void allocateMemory(int** ptr, int size) {
    *ptr = new int[size]; // 動的にメモリを確保
}
void deallocateMemory(int** ptr) {
    delete[] *ptr; // メモリを解放
    *ptr = nullptr; // ポインタをNULLに設定
}
int main() {
    int* array = nullptr; // ポインタを初期化
    int size = 5; // 配列のサイズを設定
    allocateMemory(&array, size); // メモリを確保
    // 配列の内容を出力
    for (int i = 0; i < size; ++i) {
        array[i] = i;
        std::cout << array[i] << " ";
    }
    std::cout << std::endl;
    deallocateMemory(&array); // メモリを解放
    return 0;
}

0 1 2 3 4

この例では、deallocateMemory関数を使って確保したメモリを解放し、メモリリークを防いでいます。

ポインタのポインタのデバッグ

ポインタのポインタをデバッグする際には、ポインタが正しいアドレスを指しているか、NULLポインタを適切にチェックしているかを確認することが重要です。

デバッグ時には、以下のようなチェックを行うと良いでしょう。

ポインタがNULLでないことを確認する。
ポインタが指すメモリが有効であることを確認する。
ポインタのアドレスを出力して確認する。

#include <iostream>
void debugPointer(int** ptr) {
    if (*ptr == nullptr) {
        std::cout << "ポインタはNULLを指しています。" << std::endl;
    } else {
        std::cout << "ポインタのアドレス: " << *ptr << std::endl;
        std::cout << "ポインタが指す値: " << **ptr << std::endl;
    }
}
int main() {
    int number = 10; // 整数型の変数を宣言し、値を10に設定
    int* ptr = &number; // ポインタを宣言し、numberのアドレスを代入
    int** doublePtr = &ptr; // ダブルポインタを宣言し、ptrのアドレスを代入
    debugPointer(doublePtr); // ポインタのデバッグ
    return 0;
}

ポインタのアドレス: 0x7ffee4b3c8ac
ポインタが指す値: 10

この例では、debugPointer関数を使ってポインタの状態を確認しています。

安全なポインタ操作のためのベストプラクティス

ポインタのポインタを安全に操作するためには、以下のベストプラクティスを守ることが重要です。

ポインタを初期化する：ポインタを使用する前に必ず初期化し、未定義の状態で使用しないようにします。
NULLチェックを行う：ポインタがNULLでないことを確認してからデリファレンスを行います。
メモリを適切に解放する：動的に確保したメモリは必ず解放し、メモリリークを防ぎます。
ポインタを再利用しない：解放したメモリを指すポインタを再利用しないようにします。

これらのベストプラクティスを守ることで、ポインタのポインタを安全に操作し、バグやメモリリークを防ぐことができます。

まとめ

この記事では、C++におけるポインタのポインタの基本から応用例までを詳しく解説し、メモリ管理やデータ構造の操作におけるその重要性を確認しました。

ポインタのポインタを正しく活用することで、プログラムの柔軟性と効率性を高めることが可能です。

これを機に、実際のプログラムでポインタのポインタを活用し、より高度なC++プログラミングに挑戦してみてください。