C言語を学習する上で、多くのプログラマが最初に直面する大きな壁が「ポインタ」です。

そして、そのポインタをさらに一歩進めた概念である「ポインタのポインタ（重ポインタ）」は、データ構造の構築や高度なメモリ管理において避けては通れない非常に重要な要素です。

一見すると複雑に思えるポインタのポインタですが、その本質は「変数のアドレスを格納している変数の、さらにそのアドレスを保持する」というシンプルな階層構造にあります。

この仕組みを正しく理解することで、関数の外部にあるポインタを書き換えたり、動的に多次元配列を生成したりといった、C言語らしい柔軟で強力なプログラミングが可能になります。

本記事では、ポインタのポインタの基礎的な仕組みから、実務で多用される具体的な活用シーンまで、論理的に詳しく解説していきます。

目次 [ close ]
  1. ポインタのポインタの仕組み
    1. メモリ上の配置イメージ
  2. 基本的な構文と演算
    1. 宣言と初期化
    2. 間接参照の階層
  3. 実践例1：関数内でのポインタの書き換え
    1. 動的メモリ確保を関数で行う手法
  4. 実践例2：多次元配列の動的生成
    1. 構造の仕組み
  5. 実践例3：文字列の配列（char型のポインタ配列）
    1. 文字列配列の操作例
  6. 注意点とトラブルシューティング
    1. メモリリークの防止
    2. NULLポインタの間接参照
    3. 型の不一致
  7. まとめ

ポインタのポインタの仕組み

ポインタのポインタを理解するためには、まずC言語におけるメモリとアドレスの関係を整理しておく必要があります。

C言語において、すべての変数はメモリ上の特定の場所に配置され、それぞれ固有の「アドレス」を持っています。

通常のポインタ変数は、このアドレスを値として保持する変数です。

これに対し、ポインタのポインタとは、ポインタ変数自体のメモリ番地（アドレス）を格納するための変数を指します。

メモリ上の配置イメージ

具体的なイメージを持つために、整数の値を保持する変数 int n を考えてみましょう。

  1. 変数 n がメモリのアドレス 0x100 に存在し、値 10 を保持している。
  2. ポインタ変数 p がアドレス 0x200 に存在し、値として n のアドレスである 0x100 を保持している。
  3. ポインタのポインタ変数 pp がアドレス 0x300 に存在し、値として p のアドレスである 0x200 を保持している。

このように、ポインタを多層化することで、元のデータにたどり着くための「経路」を保持することができます。

この「ポインタのポインタ」を利用することで、ポインタが指し示す先（ターゲット）そのものを変更する操作が可能になるのです。

基本的な構文と演算

C言語でポインタのポインタを宣言・利用する際の文法について確認します。

宣言と初期化

ポインタのポインタを宣言するには、アスタリスク \* を2つ重ねて記述します。

C言語
int n = 10;
int *p = &n;    // int型へのポインタ
int **pp = &p;  // int型ポインタへのポインタ

上記の例では、pp は int \*\* 型となり、int \* 型の変数のアドレスを格納できるようになります。

間接参照の階層

ポインタのポインタから元のデータにアクセスするには、アスタリスクを段階的に適用します。

記述意味
ppポインタ変数 p のアドレス
\*pppp が指す中身（＝変数 p の値、つまり n のアドレス）
\*\*pp\*pp が指す中身（＝変数 n の値）

以下のプログラムで、実際に値とアドレスがどのように遷移するかを確認してみましょう。

C言語
#include <stdio.h>

int main(void) {
    int n = 100;
    int *p = &n;
    int **pp = &p;

    printf("変数 n の値: %d\n", n);
    printf("変数 n のアドレス (&n): %p\n", (void*)&n);
    printf("ポインタ p の値 (p): %p\n", (void*)p);
    printf("ポインタ p のアドレス (&p): %p\n", (void*)&p);
    printf("ポインタのポインタ pp の値 (pp): %p\n", (void*)pp);

    printf("\n--- 間接参照によるアクセス ---\n");
    printf("*pp の値 (pの値と同じ): %p\n", (void*)*pp);
    printf("**pp の値 (nの値と同じ): %d\n", **pp);

    return 0;
}
実行結果
変数 n の値: 100
変数 n のアドレス (&n): 0x7ffee1234568
ポインタ p の値 (p): 0x7ffee1234568
ポインタ p のアドレス (&p): 0x7ffee1234570
ポインタのポインタ pp の値 (pp): 0x7ffee1234570

--- 間接参照によるアクセス ---
*pp の値 (pの値と同じ): 0x7ffee1234568
**pp の値 (nの値と同じ): 100

実践例1：関数内でのポインタの書き換え

ポインタのポインタが最も威力を発揮する場面の一つが、「関数内で、呼び出し元のポインタ変数の値を書き換えたい場合」です。

通常、関数の引数にポインタを渡すと、そのポインタが指している「メモリ領域の中身」を書き換えることはできます。

しかし、ポインタそのものが保持している「アドレス」を書き換えて、別の場所を指すようにすることはできません。

これはC言語が「値渡し」を採用しているため、関数に渡されたポインタはコピーに過ぎないからです。

そこで、ポインタ変数のアドレス（ポインタのポインタ）を渡すことで、関数の中から呼び出し元のポインタを操作します。

動的メモリ確保を関数で行う手法

例えば、関数内で malloc を使用してメモリを確保し、そのアドレスを呼び出し元のポインタにセットしたい場合に利用します。

C言語
#include <stdio.h>
#include <stdlib.h>

// ポインタのポインタを引数に取る関数
void allocate_memory(int **ptr_ptr) {
    // 呼び出し元のポインタ変数そのものを書き換える
    *ptr_ptr = (int *)malloc(sizeof(int));
    if (*ptr_ptr == NULL) {
        fprintf(stderr, "メモリ確保に失敗しました\n");
        return;
    }
    // 確保した領域に値を代入
    **ptr_ptr = 500;
}

int main(void) {
    int *p = NULL;

    printf("呼び出し前の p のアドレス: %p\n", (void*)p);

    // pのアドレス (&p) を渡す
    allocate_memory(&p);

    if (p != NULL) {
        printf("呼び出し後の p のアドレス: %p\n", (void*)p);
        printf("p が指す値: %d\n", *p);
        free(p);
    }

    return 0;
}
実行結果
呼び出し前の p のアドレス: (nil)
呼び出し後の p のアドレス: 0x55d... (確保されたアドレス)
p が指す値: 500

もしこの関数が void allocate\_memory(int \*ptr) で定義されていた場合、関数内の ptr を書き換えても main 関数の p には影響を与えません。

ポインタのポインタを使うことで、関数の外側のポインタ変数を直接操作できるようになります。

実践例2：多次元配列の動的生成

C言語において、ポインタのポインタは「2次元配列」を動的に生成する際にも多用されます。

固定長の2次元配列 int matrix[3][4] はメモリ上に連続して配置されますが、各行の長さが異なる場合や、実行時に行数と列数を決定したい場合には、ポインタのポインタによる管理が適しています。

構造の仕組み

ポインタのポインタを用いた2次元配列は、以下の2ステップでメモリを構築します。

  1. int \* 型の要素を持つ「ポインタの配列」を確保する。
  2. その各ポインタに対して、実際のデータ領域となる int 配列を確保する。

これにより、matrix[i][j] という形式でデータにアクセスできるようになります。

C言語
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int rows = 3;
    int cols = 4;

    // 1. int* 型のポインタ配列を確保
    int **matrix = (int **)malloc(sizeof(int *) * rows);
    if (matrix == NULL) return 1;

    // 2. 各行に対して int 型の配列を確保
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(sizeof(int) * cols);
        if (matrix[i] == NULL) return 1;
    }

    // 値の代入
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = i * 10 + j;
        }
    }

    // 表示
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%02d ", matrix[i][j]);
        }
        printf("\n");
    }

    // 後始末: 解放の順番に注意（内側から外側へ）
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);

    return 0;
}
実行結果
00 01 02 03 
10 11 12 13 
20 21 22 23

この手法の利点は、各行のメモリが必ずしも連続している必要がないため、巨大なメモリを確保する際の断片化リスクを抑えられる点や、ジャグ配列（各行の長さがバラバラな配列）を構築できる点にあります。

実践例3：文字列の配列（char型のポインタ配列）

C言語で複数の文字列を扱う場合、char \*\* という型が頻繁に登場します。

これは「文字列（char \*）を要素に持つ配列」のアドレスを指すため、実質的にポインタのポインタとして機能します。

最も身近な例は、main 関数の引数である argv です。

C言語
int main(int argc, char **argv)

ここで argv は、コマンドライン引数として渡された各文字列へのポインタを格納した配列の先頭を指しています。

文字列配列の操作例

以下のコードは、ポインタのポインタを用いて文字列のリストを操作する例です。

C言語
#include <stdio.h>

void print_list(char **list, int count) {
    for (int i = 0; i < count; i++) {
        // list[i] は char* 型
        printf("Item %d: %s\n", i, list[i]);
    }
}

int main(void) {
    char *fruits[] = {"Apple", "Banana", "Orange", "Grape"};
    int count = 4;

    // 配列名は先頭要素へのポインタとして振る舞うため、char** として渡せる
    print_list(fruits, count);

    return 0;
}
実行結果
Item 0: Apple
Item 1: Banana
Item 2: Orange
Item 3: Grape

char \*\*list を使うことで、複数の単語を柔軟に管理し、関数間で受け渡しすることが可能になります。

注意点とトラブルシューティング

ポインタのポインタは非常に強力ですが、その分誤用によるバグが発生しやすく、注意が必要です。

メモリリークの防止

特に多次元配列を動的に確保した場合、解放（free）の順序を間違えるとメモリリークが発生します。 先ほどの例のように、先に子要素（各行）を解放し、最後に親要素（ポインタ配列自体）を解放しなければなりません。

親を先に解放してしまうと、子要素のアドレスが分からなくなり、OSにメモリを返却できなくなります。

NULLポインタの間接参照

ポインタのポインタ pp 自体が NULL である場合や、その中身 \*pp が NULL である場合に \*\*pp を参照しようとすると、セグメンテーションフォールト（強制終了）が発生します。

複雑なポインタ操作を行う際は、常に以下のチェックを行う習慣をつけることが推奨されます。

C言語
if (pp != NULL && *pp != NULL) {
    // 安全にアクセス可能
}

型の不一致

int \*\* 型に int \* 型の変数を代入しようとするなど、ポインタの深さを誤るミスもよく見られます。

コンパイラの警告を無視せず、アスタリスクの数が意図したデータ構造と一致しているか常に確認しましょう。

まとめ

C言語におけるポインタのポインタは、メモリ管理の自由度を最大限に引き出すための重要な概念です。

  • 基本的な仕組み：ポインタ変数のアドレスを保持するものであり、2段階の間接参照によって元のデータに到達する。
  • 主な活用法：関数内でのポインタの書き換え、動的な2次元配列の生成、文字列リストの管理など。
  • 管理の要諦：メモリの確保と解放の順序を正しく保ち、NULLチェックを徹底することが安全な実装の鍵となる。

この概念を習得することで、リンクリストやツリー構造といった複雑なデータ構造の実装、あるいはシステムプログラミングにおける高度なリソース管理が可能になります。

一見遠回りに見える「アドレスのアドレス」という概念ですが、その背後にある論理的な構造を理解すれば、より堅牢で効率的なC言語プログラムを書くための強力な武器となるはずです。