C言語の関数パラメータ：値渡し、ポインタ、配列

仮引数（パラメータ）と実引数（アーギュメント）

混同されがちですが、分けておく価値のある2つの言葉です。

• **仮引数（パラメータ）**は関数の定義に書かれた変数です - int square(int n) の int n。
• **実引数（アーギュメント）**は呼び出し側で与える値です - square(4) の 4。

関数を呼び出すと、そのパラメータが新しいローカル変数として作られ、引数がそこへコピーされます。このコピーこそ、このページ全体の主題です。

C言語は常に値で渡す

これがルールであり、C言語に例外はありません。関数は引数のコピーを受け取ります。パラメータへの代入はコピーだけを変えます。

#include <stdio.h>

void tryToReset(int x) {
    printf("  関数内、変更前: x = %d\n", x);
    x = 0;
    printf("  関数内、変更後: x = %d\n", x);
}

int main(void) {
    int value = 42;
    printf("呼び出し前: value = %d\n", value);
    tryToReset(value);
    printf("呼び出し後: value = %d\n", value);
    return 0;
}

value は依然として 42 のままです。関数は x という名のコピーを受け取り、そのコピーをゼロにし、関数が戻るときにコピーは消えました。パラメータの名前を value に変えても何も変わりません - 名前が両者をつなぐわけではなく、それらは別々の変数です。

これはあらゆる型について当てはまります。int、double、char、ポインタ、そして構造体全体（フィールドごとにコピーされます）も同じです。Python、Java、JavaScript から来た人は、それらの言語がオブジェクトの参照を値渡ししているため、関数の中でオブジェクトを変更すると外からも見えることに注意してください。C言語にそれはありません - オブジェクトそのものをコピーします。

値渡しは制限ではなく、機能です。関数が誤って呼び出し側のデータを壊すことがないので、はるかに考えやすくなります。

古典的な失敗：swap

教科書的な実演は、2つの値を交換しようとする関数です。

#include <stdio.h>

void brokenSwap(int a, int b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int main(void) {
    int x = 1, y = 2;
    brokenSwap(x, y);
    printf("x = %d, y = %d   (変わっていない！)\n", x, y);
    return 0;
}

ロジックは正しく、確かに a と b を交換しています。しかし a と b はコピーなので、関数が戻った瞬間にその成果は捨てられます。

ポインタで参照渡しを模倣する

関数に呼び出し側の変数を変えさせるには、値ではなくその変数のアドレスを渡します。そのアドレス自体は値渡しされ - ポインタがコピーされ - ますが、コピーも元のオブジェクトを指しているので、それを通して書き込めば呼び出し側のメモリに届きます。

#include <stdio.h>

void swap(int *a, int *b) {
    int tmp = *a;      /* ポインタ越しに読む */
    *a = *b;           /* ポインタ越しに書く */
    *b = tmp;
}

int main(void) {
    int x = 1, y = 2;
    printf("前: x = %d, y = %d\n", x, y);
    swap(&x, &y);      /* アドレスを渡す */
    printf("後: x = %d, y = %d\n", x, y);
    return 0;
}

3つの構文要素が、この考え全体を担っています。

• パラメータリストの int *a は、a を「int へのポインタ」として宣言します。
• 呼び出し側の &x は x のアドレスを生み出します。
• 関数内の *a は「a が指している int」という意味で、読むことも代入することもできます。

これがC言語プログラマの言う「参照渡し」ですが、正確に言う価値があります。これも依然として値渡しです。コピーされるのはポインタです。a 自体への代入（a = NULL;）はコピーだけを変え、*a への代入が呼び出し側の変数を変えます。ポインタがこのモデルを詳しく扱っています。

代償として、呼び出し箇所を見ても変数が変わりうるかどうか分からなくなります - だからこそ & が必須なのです。swap(x, y) はコンパイルできず、swap(&x, &y) と書かなければなりません。その & が、この呼び出しが x を変更しうるという目に見える印です。

複数の結果を返す

return が生み出す値は1つなので、追加の出力はポインタのパラメータを通って運ばれます。よくある形は、戻り値をステータスコードとし、本当の結果はポインタ越しに書き込むというものです。

#include <stdio.h>

/* 成功なら 1、除数がゼロなら 0 を返す */
int divide(int a, int b, int *quotient, int *remainder) {
    if (b == 0) {
        return 0;
    }
    *quotient = a / b;
    *remainder = a % b;
    return 1;
}

int main(void) {
    int q, r;

    if (divide(17, 5, &q, &r)) {
        printf("17 / 5 = %d 余り %d\n", q, r);
    }

    if (!divide(17, 0, &q, &r)) {
        printf("ゼロで割ることはできません\n");
    }

    return 0;
}

呼び出しが失敗したとき q と r は以前の値を保つ点に注意してください - 関数は何も書かずに戻ったからです。それが呼び出し側の守るべき契約であり、出力を使う前にステータスをチェックする理由です。

もう1つの手は、両方のフィールドを持つ構造体を返すことです。ポインタを完全に避けられますし、値が本当に一緒に属しているなら、そのほうが良い設計であることも多いです。

配列は別物

配列はコピーのルールに従わず、これがほとんど全員をつまずかせます。配列を渡すと、それは先頭要素へのポインタに**成り下がり（decay）**ます - つまり関数が受け取るのはアドレスであって、データのコピーではありません。

#include <stdio.h>

void doubleAll(int a[], int n) {
    for (int i = 0; i < n; i++) {
        a[i] *= 2;          /* これは呼び出し側の配列に届く */
    }
}

int main(void) {
    int data[] = {1, 2, 3, 4, 5};
    int n = sizeof(data) / sizeof(data[0]);

    doubleAll(data, n);

    for (int i = 0; i < n; i++) {
        printf("%d ", data[i]);
    }
    printf("\n");
    return 0;
}

呼び出し側の配列が本当に変わりました。しかもどこにも & はありません - この文脈では data がすでにアドレスであるからです。帰結が3つあります。

パラメータリストでは int a[] と int *a はまったく同じ意味です。 int a[100] ですらそうで、サイズは無視されます。int a[] と書くと意図は伝わりますが、「配列がコピーされている」と読んではいけません。

関数の中の sizeof は間違った答えを返します。 これがそのバグです。

#include <stdio.h>

void showSize(int a[]) {
    printf("  関数の中: sizeof(a) = %zu\n", sizeof(a));
    printf("  計算した長さ:  %zu  <-- 誤り\n", sizeof(a) / sizeof(a[0]));
}

int main(void) {
    int data[] = {1, 2, 3, 4, 5};
    printf("main の中: sizeof(data) = %zu\n", sizeof(data));
    printf("正しい長さ:            %zu\n", sizeof(data) / sizeof(data[0]));
    showSize(data);
    return 0;
}

main では sizeof(data) は20バイトで、長さは5と出ます。関数の中では sizeof(a) はポインタのサイズ - 64ビットシステムなら8 - なので、「長さ」は2になります。配列のサイズは、そこでは単に手に入らないのです。長さは必ず別の引数として渡しましょう。 最近のコンパイラは -Wall でこれを警告してくれます。

書き込まないなら const を使いましょう。 const int a[] は関数が読むだけだと宣言し、コンパイラがそれを強制し、読み手はそれを信頼できます。

int sum(const int a[], int n);        /* 配列を変更しないと約束する */

文字列も配列なので同じことが当てはまります。void greet(const char *name) は、文字列を変更せずに読む関数の標準的なシグネチャです。

コストはどうなのか

大きな構造体を値で渡すと、呼び出しのたびに全バイトがコピーされます。フィールドがいくつかの構造体ならそれで問題なく、ポインタが加える間接参照より速いことすらあります。大きなものにはポインタを渡し、関数が読むだけならそれを const と印しましょう。

struct Config { char name[64]; int flags[32]; double weights[128]; };

void applyConfig(const struct Config *cfg);   /* 呼び出しごとの512バイトのコピーがない */

const struct Config *cfg は「変更しない Config へのポインタ」という意味で、ポインタの効率とコピーの安全性を兼ね備えます。

よくある間違い

• 素のパラメータが呼び出し側の変数を変えると期待すること。 変えられません。ポインタを渡しましょう。
• 呼び出し側で & を忘れること。 ポインタを求める swap に対する swap(x, y) は型エラーです。コンパイラが捕まえてくれますが、プロトタイプがスコープにある場合だけです。
• 関数の中で * を忘れること。 2つのポインタパラメータに対する a = b; は、値ではなくローカルのコピーを入れ替えます。書きたいのは *a = *b; です。
• 配列パラメータに sizeof を使うこと。 常に誤りです。長さを渡しましょう。
• ローカル変数へのポインタを返すこと。 関数が戻るとローカルは死ぬので、呼び出し側は宙ぶらりんのポインタを持つことになり、未定義動作です。値で返すか、呼び出し側が用意したバッファに書き込むか、malloc で確保しましょう。
• ポインタのパラメータを NULL かチェックしないこと。 渡されたものを何でもデリファレンスする関数は、ヌルの引数でクラッシュします。