【2026年7月最新】C言語ポインタ完全ガイド｜基本・配列・関数・構造体の使い方とClaude Code活用

この記事の内容

1. 01変数とメモリアドレス｜ポインタが指すもの
2. 02&演算子（アドレス取得）と*演算子（間接参照）の使い方
3. 03ポインタと配列の等価性
4. 04関数へのポインタ渡し（call by reference）
5. 05構造体ポインタとアロー演算子
6. 06ポインタのポインタ（ダブルポインタ）
7. 07よくあるセグメンテーションフォールトと対策
8. 08Claude Codeでポインタ問題をデバッグする
9. FAQよくある質問

📚 用語解説

メモリアドレス：メモリ（RAM）の各バイトに割り当てられた一意の番号。通常16進数で表示される（例: 0x7ffee4b）。プログラムが変数を宣言すると、OSがメモリ上の空きアドレスを割り当てて変数を格納する。int型は4バイト、char型は1バイト、double型は8バイトなど、型によって占有するバイト数が決まる。ポインタはこのアドレスを値として保持する変数で、「そのアドレスにある値」を読み書きできる。

#include 

int main(void) {
    int x = 42;        // 変数xに42を格納
    int *p;            // int型のポインタ変数pを宣言
    p = &x;            // &x = xのアドレスをpに代入

    printf("xの値: %d\n", x);          // → 42
    printf("xのアドレス: %p\n", &x);   // → 0x7ffee4b2c9ac（例）
    printf("pの値: %p\n", p);          // → 0x7ffee4b2c9ac（xと同じ）
    printf("pが指す値: %d\n", *p);     // → 42（間接参照）

    return 0;
}

* 演算子はC言語で2つの意味を持ちます。①ポインタ宣言: int *p; のように型名の後に書くと「pはint型ポインタ変数」という宣言になります。②間接参照: 式の中で *p と書くと「pが指すアドレスの値」を意味します。どちらの*かは文脈（宣言か式か）で判断します。

#include 

int main(void) {
    int x = 10;
    int y = 20;

    /* --- ポインタ宣言と代入 --- */
    int *p;         // pはint型ポインタ（宣言時の*）
    p = &x;         // &x = xのアドレスをpに代入

    /* --- 間接参照（値の読み書き） --- */
    printf("%d\n", *p);   // → 10（xの値を間接参照）
    *p = 99;               // pが指すアドレスの値を変更（xが99になる）
    printf("%d\n", x);    // → 99（xが書き換えられた）

    /* --- ポインタの差し替え --- */
    p = &y;          // pがyを指すように変更
    printf("%d\n", *p);   // → 20（yの値）

    /* --- アドレス演算 --- */
    int arr[3] = {10, 20, 30};
    int *ap = arr;   // 配列の先頭アドレス
    printf("%d\n", *ap);       // → 10 (arr[0])
    printf("%d\n", *(ap + 1)); // → 20 (arr[1])
    printf("%d\n", *(ap + 2)); // → 30 (arr[2])

    return 0;
}

📚 用語解説

アドレス演算子（&）と間接参照演算子（*）：&変数名: 変数のメモリアドレスを返す演算子。「の住所を取得する」という意味。*ポインタ変数: ポインタが指すアドレスの値を読み書きする演算子。「その住所の家（メモリ）の中身を見る」という意味。NULLポインタ（何も指していない状態）に*を適用するとセグメンテーションフォールトが発生するため、*の前にNULLチェックが必要。

📚 用語解説

配列名とポインタの等価性：C言語では配列名（例: arr）はその配列の先頭要素（arr[0]）のアドレスを表す定数ポインタとして扱われる。ただし変数ではないためarrに別のアドレスを代入したり（arr = &x は不可）、arr++もできない。int *p = arr; と書くとpはarrと同じ先頭アドレスを指す変数ポインタになる（p++やp = &x は可能）。配列要素arr[i]へのアクセスはコンパイラが内部的に*(arr+i)に変換する。

#include 

int main(void) {
    int arr[5] = {10, 20, 30, 40, 50};
    int *p = arr;   // 先頭要素のアドレスをpに代入

    /* --- 3つの等価な書き方 --- */
    printf("%d\n", arr[2]);     // → 30（添え字記法）
    printf("%d\n", *(arr + 2)); // → 30（ポインタ演算）
    printf("%d\n", *(p + 2));   // → 30（ポインタ変数使用）
    printf("%d\n", p[2]);       // → 30（ポインタ変数への添え字）

    /* --- ポインタ変数はインクリメントできる --- */
    p = arr;      // 先頭に戻す
    printf("%d\n", *p);    // → 10
    p++;
    printf("%d\n", *p);    // → 20
    p++;
    printf("%d\n", *p);    // → 30

    /* --- ポインタで配列を逆順に出力 --- */
    p = &arr[4];  // 末尾を指す
    int i;
    for (i = 4; i >= 0; i--) {
        printf("%d ", *p);
        p--;
    }
    printf("\n");  // → 50 40 30 20 10

    return 0;
}

#include 

/* --- 値渡し（関数内の変更が呼び出し元に反映されない）--- */
void swap_wrong(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    /* ここで交換されるのはaとbのコピー。呼び出し元は変わらない */
}

/* --- ポインタ渡し（関数内から呼び出し元を変更できる）--- */
void swap_correct(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
    /* *a, *bは呼び出し元の変数を直接操作している */
}

int main(void) {
    int x = 10, y = 20;

    /* 値渡し（交換されない）*/
    swap_wrong(x, y);
    printf("値渡し後: x=%d, y=%d\n", x, y);  // → x=10, y=20（変わらない）

    /* ポインタ渡し（正しく交換される）*/
    swap_correct(&x, &y);   // アドレスを渡す
    printf("ポインタ渡し後: x=%d, y=%d\n", x, y);  // → x=20, y=10（交換された）

    return 0;
}

C言語の関数はreturnで1つの値しか返せません。複数の値を「返す」には①ポインタ引数で呼び出し元の変数を直接変更する（swap_correctパターン）②構造体を返す の2つが一般的です。例えば「最大値と最小値を同時に返す」関数は void minmax(int arr[], int n, int *min, int *max) のようにポインタ引数2つを受け取る形で実装します。

📚 用語解説

アロー演算子（->）：構造体ポインタのメンバへアクセスする演算子。ptr->memberと書くと(*ptr).memberと同じ意味になる。「まずポインタを間接参照して構造体にアクセスし、そのメンバを取得する」という2ステップを1つの演算子で表現する。(*ptr).memberは括弧が必要（.の優先順位が*より高いためドット演算子から先に評価されるのを防ぐため）。->のほうが読みやすいため実務ではほぼ->を使う。

#include 
#include 

typedef struct {
    char name[50];
    int age;
    double score;
} Student;

void print_student(Student *s) {
    /* アロー演算子でメンバにアクセス */
    printf("名前: %s\n", s->name);
    printf("年齢: %d\n", s->age);
    printf("スコア: %.1f\n", s->score);

    /* (*s).name と同じ意味（()が必要）*/
    /* printf("名前: %s\n", (*s).name); */
}

void update_score(Student *s, double new_score) {
    s->score = new_score;   /* 呼び出し元の構造体を直接変更 */
}

int main(void) {
    Student taro;
    strcpy(taro.name, "田中太郎");
    taro.age = 20;
    taro.score = 85.5;

    /* ポインタで関数に渡す（構造体全体のコピーを避けられる）*/
    print_student(&taro);
    update_score(&taro, 92.0);

    printf("更新後スコア: %.1f\n", taro.score);  /* → 92.0 */

    /* ポインタ変数を使う場合 */
    Student *sp = &taro;
    printf("spからアクセス: %s, %d歳\n", sp->name, sp->age);

    return 0;
}

📚 用語解説

ダブルポインタ（**ptr）：ポインタのアドレスを格納するポインタ。int **pp; と宣言するとppはint*型ポインタ変数のアドレスを保持する。*ppはポインタ変数（アドレス）、**ppはそのポインタが指す値にアクセスできる。主な使い所: ①関数内でポインタ変数自体を変更したい場合（関数引数でint **を受け取り*pp = 新しいアドレスとする）②2次元配列の動的確保 ③ポインタ配列（char *argv[]はchar **argvと等価）

#include 
#include 

/* 関数内でポインタを変更する（ダブルポインタが必要）*/
void allocate_buffer(int **pp, int size) {
    *pp = (int *)malloc(sizeof(int) * size);  /* *ppに新しいアドレスを代入 */
    if (*pp == NULL) {
        return;
    }
    int i;
    for (i = 0; i < size; i++) {
        (*pp)[i] = i * 10;  /* 0, 10, 20, ... */
    }
}

int main(void) {
    int x = 42;
    int *p = &x;    /* pはxを指す */
    int **pp = &p;  /* ppはpのアドレスを指す */

    printf("xの値: %d\n", x);      /* → 42 */
    printf("*p: %d\n", *p);         /* → 42 */
    printf("**pp: %d\n", **pp);     /* → 42 */

    /* **ppを通じてxの値を変更 */
    **pp = 99;
    printf("変更後x: %d\n", x);    /* → 99 */

    /* 動的メモリ確保（ダブルポインタで関数から返す）*/
    int *buf = NULL;
    allocate_buffer(&buf, 5);  /* &bufを渡してbuf自体を変更させる */

    if (buf != NULL) {
        int i;
        for (i = 0; i < 5; i++) {
            printf("%d ", buf[i]);   /* → 0 10 20 30 40 */
        }
        printf("\n");
        free(buf);   /* 動的確保したメモリは必ずfreeで解放 */
    }

    return 0;
}

①未初期化ポインタ（ゴミアドレス）への間接参照: int *p; *p = 10; ②NULLポインタへの間接参照: int *p = NULL; *p = 10; ③配列の範囲外アクセス: int arr[5]; arr[10] = 0; ④解放済みメモリへのアクセス（use-after-free）: free(p); *p = 10; これらはすべてプログラムが不正なメモリアドレスにアクセスしようとしているため、OSによって強制終了させられる。

#include 
#include 

int main(void) {

    /* --- NG例1: 未初期化ポインタ --- */
    /* int *p;            pはゴミアドレス（不定） */
    /* *p = 10;           → Segmentation fault */

    /* OK: 必ず初期化する */
    int x = 10;
    int *p = &x;      /* 有効なアドレスを代入 */
    *p = 20;          /* OK */

    /* --- NG例2: NULLポインタ参照 --- */
    /* int *q = NULL;     NULLは無効なアドレス（0番地）*/
    /* *q = 10;           → Segmentation fault */

    /* OK: NULLチェックをしてから使う */
    int *q = NULL;
    if (q != NULL) {
        *q = 10;
    } else {
        printf("qはNULLです\n");
    }

    /* --- NG例3: malloc失敗時 --- */
    int *buf = (int *)malloc(sizeof(int) * 1000000000);
    /* mallocが失敗するとNULLが返る */
    if (buf == NULL) {
        printf("メモリ確保失敗\n");
        return 1;   /* 異常終了 */
    }
    /* NULLチェック後にアクセスする */
    buf[0] = 42;
    free(buf);

    /* --- NG例4: 解放済みメモリへのアクセス --- */
    int *fp = (int *)malloc(sizeof(int));
    *fp = 100;
    free(fp);
    /* *fp = 200;  → use-after-free（未定義動作）*/
    fp = NULL;    /* freeの直後にNULLを代入する習慣 */

    return 0;
}

NEXT STEP

この記事の内容を、あなたのビジネスで
実践してみませんか？