C言語を学び始めた際、多くのプログラミング初心者が直面する大きな壁の一つが「ポインタ」です。

そして、そのポインタを実用的な場面で活用する代表例が、関数における参照渡しの実装です。

C言語における関数の引数設計は、プログラムのパフォーマンスやメモリ効率、さらにはコードの可読性にまで大きな影響を及ぼします。

本記事では、C言語における参照渡しの概念から、ポインタを用いた具体的な実装方法、そして基本となる値渡しとの決定的な違いについて、技術的な視点から詳しく解説します。

最新の開発現場でも通用する「安全なポインタの扱い方」についても触れていきますので、基礎を固めたい方から応用力をつけたい方まで、ぜひ参考にしてください。

目次 [ close ]
  1. C言語における引数渡しの基本概念
    1. 値渡し (Call by Value) とは
    2. 参照渡し (Call by Reference / Address) とは
  2. 値渡しの挙動と限界
    1. 値渡しのメリット
    2. 値渡しのデメリット
  3. ポインタによる参照渡しの実装方法
  4. 値渡しと参照渡しの違いを比較する
    1. どちらを選択すべきか
  5. 構造体の受け渡しとアロー演算子
  6. 配列の受け渡し：暗黙の参照渡し
  7. 安全な参照渡しのための const 修飾子
  8. ポインタによる参照渡しの注意点と落とし穴
    1. NULLポインタのチェック
    2. ローカル変数のアドレスを返さない
    3. ポインタの型の一致
  9. C++の参照渡しとの違い
  10. まとめ

C言語における引数渡しの基本概念

C言語で関数を呼び出す際、引数としてデータを渡す方法は大きく分けて2種類存在します。

それが「値渡し」と、ポインタを利用した「参照渡し（ポインタ渡し）」です。

厳密に言えば、C言語の仕様にはC++のような「参照型」による参照渡しは存在せず、すべては「値（アドレスという数値）」を渡しているに過ぎませんが、慣習的にポインタを用いた手法を参照渡しと呼びます。

プログラムが実行される際、関数に渡されるデータはメモリ上の「スタック領域」と呼ばれる場所に一時的に格納されます。

このデータがどのように格納され、関数内でどのように扱われるかを理解することが、ポインタをマスターする第一歩となります。

値渡し (Call by Value) とは

値渡しは、関数を呼び出す際に実引数の値をコピーして仮引数に渡す方式です。

関数内部で引数の値を書き換えたとしても、それはコピーされた値を操作しているだけであるため、呼び出し元の元の変数には一切影響を与えません。

この方式は、データの独立性が保たれるというメリットがありますが、大きな構造体などを渡す場合には「コピーのコスト」が発生し、実行速度の低下やメモリ消費量の増大を招く可能性があります。

参照渡し (Call by Reference / Address) とは

C言語における参照渡し（ポインタ渡し）は、変数の値そのものではなく、その変数が格納されているメモリ上の住所（アドレス）を渡す方式です。

関数側では受け取ったアドレスを介して直接元のメモリ領域にアクセスするため、関数内での変更が呼び出し元の変数にそのまま反映されます。

これを「副作用」と呼ぶこともありますが、正しく利用することで効率的なデータ操作が可能になります。

値渡しの挙動と限界

まずは、値渡しの具体的な動作をコードで確認してみましょう。

以下のプログラムは、関数内で引数の値を変更しようと試みる例です。

C言語
#include <stdio.h>

/* 引数の値を10倍にする関数（値渡し） */
void multiplyByTen(int n) {
    n = n * 10;
    printf("関数内部のnの値: %d\n", n);
}

int main(void) {
    int num = 5;

    printf("呼び出し前のnumの値: %d\n", num);
    
    // 値渡しで関数を呼び出す
    multiplyByTen(num);

    printf("呼び出し後のnumの値: %d\n", num);

    return 0;
}
実行結果
呼び出し前のnumの値: 5
関数内部のnの値: 50
呼び出し後のnumの値: 5

この結果からわかる通り、関数 multiplyByTen の中で変数 n を50に書き換えても、呼び出し元の num は5のまま変化していません。

これは、num の「5」という値がコピーされ、別のメモリ領域にある n に代入されたためです。

値渡しのメリット

  • 安全性: 関数が元のデータを誤って書き換える心配がないため、バグの影響範囲を限定できます。
  • シンプルさ: ポインタ演算やアドレス操作を意識する必要がないため、ロジックが簡潔になります。

値渡しのデメリット

  • メモリ効率: 巨大な構造体や配列を渡す際、すべてのデータをスタックにコピーするため、スタックオーバーフローのリスクや処理遅延が発生します。
  • 単一の戻り値: C言語の関数は戻り値を一つしか返せません。複数の値を更新して呼び出し元に戻したい場合、値渡しでは対応できません。

ポインタによる参照渡しの実装方法

C言語で「呼び出し元の変数を直接書き換えたい」場合や「大きなデータを効率よく渡したい」場合には、ポインタを使用します。

実装には以下の3つのステップが必要です。

  1. 関数のプロトタイプ宣言で引数をポインタ型（型名 *変数名）にする。
  2. 関数を呼び出す際に、変数のアドレス（&変数名）を渡す。
  3. 関数内部で間接参照演算子（*）を使用して、アドレス先の値を操作する。

もっとも有名な例である「2つの変数の値を入れ替える（Swap）」処理を見てみましょう。

C言語
#include <stdio.h>

/* 2つの整数を入れ替える関数（参照渡し） */
void swap(int *a, int *b) {
    int temp;
    
    // アドレスaが指す場所の値を退避
    temp = *a;
    // アドレスbが指す場所の値をアドレスaの場所に代入
    *a = *b;
    // 退避しておいた値をアドレスbの場所に代入
    *b = temp;
}

int main(void) {
    int x = 100;
    int y = 200;

    printf("入れ替え前: x = %d, y = %d\n", x, y);

    // 変数xとyのアドレスを渡す
    swap(&x, &y);

    printf("入れ替え後: x = %d, y = %d\n", x, y);

    return 0;
}
実行結果
入れ替え前: x = 100, y = 200
入れ替え後: x = 200, y = 100

このプログラムでは、swap 関数に x と y のアドレスを渡しています。

関数内部では、a や b を通じてメイン関数のメモリ領域を直接操作しているため、関数終了後も値の変更が保持されます。

値渡しと参照渡しの違いを比較する

両者の違いをより深く理解するために、メモリの使われ方や用途の違いを表にまとめました。

比較項目値渡し (Call by Value)参照渡し (Call by Pointer)
渡されるもの変数の値そのもの（コピー）変数のメモリ番地（アドレス）
メモリ消費引数のサイズ分だけコピーが発生アドレス（通常4〜8バイト）のみ
元の変数への影響変化しない（安全）変化する（副作用がある）
主な用途数値計算、フラグの判定など大規模データ、複数値の更新、動的メモリ操作
記述方法（引数）int nint *p
呼び出し方func(val)func(&val)

どちらを選択すべきか

基本的な指針として、「変更の必要がなく、サイズが小さい基本データ型（int, char, double等）」であれば値渡しを選択します。

一方で、「関数内で値を書き換えたい場合」や「構造体などの大きなデータ」を扱う場合は、参照渡し（ポインタ渡し）を選択するのがC言語のセオリーです。

構造体の受け渡しとアロー演算子

C言語の実務において、参照渡しが最も威力を発揮するのが「構造体」の扱いです。

構造体は複数のメンバを持つため、サイズが大きくなりがちです。

これを値渡しすると、関数の呼び出しのたびに全てのメンバがコピーされ、パフォーマンスのボトルネックとなります。

構造体を参照渡しする場合、メンバへのアクセスには->（アロー演算子）を使用します。

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

typedef struct {
    char name[50];
    int age;
    double height;
} Player;

/* 構造体のポインタを受け取り、データを更新する */
void updatePlayer(Player *p, const char *newName, int newAge) {
    // アロー演算子を使用して実体にアクセス
    strncpy(p->name, newName, sizeof(p->name) - 1);
    p->age = newAge;
}

int main(void) {
    Player hero = {"戦士", 20, 175.5};

    printf("更新前: %s (%d歳)\n", hero.name, hero.age);

    // 構造体のアドレスを渡す
    updatePlayer(&hero, "勇者", 25);

    printf("更新後: %s (%d歳)\n", hero.name, hero.age);

    return 0;
}
実行結果
更新前: 戦士 (20歳)
更新後: 勇者 (25歳)

もし、この Player 構造体が数キロバイトのデータを持っていたとしても、ポインタ渡しであればアドレス情報（数バイト）の転送だけで済むため、非常に高速に処理できます。

配列の受け渡し：暗黙の参照渡し

C言語において特殊な挙動をするのが「配列」です。

関数に配列を渡す際、実は明示的にポインタを指定しなくても、自動的に先頭要素のアドレスが渡される仕組みになっています。

これを「配列のポインタへの退化（decay）」と呼びます。

C言語
#include <stdio.h>

/* 配列を引数に取る関数（実態はポインタ渡し） */
void modifyArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2; // 元の配列を直接書き換える
    }
}

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

    modifyArray(data, size); // &data[0] を渡しているのと同じ

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

    return 0;
}
実行結果
2 4 6 8 10

このように、配列を引数にした場合は常に参照渡しのような挙動になります。

関数内で配列の要素を書き換えると、呼び出し元の配列も変更されるため注意が必要です。

また、関数側では配列のサイズを知ることができないため、要素数（size）も一緒に渡すのが一般的な作法です。

安全な参照渡しのための const 修飾子

参照渡しには「効率が良い」というメリットがある反面、「意図しない場所で値が書き換えられる」というリスクが伴います。

このリスクを回避し、読み取り専用としてポインタを渡すために使用するのが const 修飾子です。

特に、大規模な構造体を引数に取る際、「メモリ節約のためにポインタで渡したいが、関数内では値を変更させたくない」というケースで多用されます。

C言語
#include <stdio.h>

typedef struct {
    int id;
    int score;
} Result;

/* constを付けることで、関数内での書き換えを禁止する */
void printResult(const Result *r) {
    // r->score = 100; // このような記述はコンパイルエラーになる
    printf("ID: %d, Score: %d\n", r->id, r->score);
}

int main(void) {
    Result myRes = {101, 85};
    printResult(&myRes);
    return 0;
}

const を活用することで、コンパイラが不正な書き込みをチェックしてくれるようになり、プログラムの堅牢性が飛躍的に向上します。

プロの現場では、書き換える必要のないポインタ引数には必ず const を付けることが推奨されています。

ポインタによる参照渡しの注意点と落とし穴

参照渡しは強力な道具ですが、誤った使い方をすると致命的なバグ（セグメンテーションフォールトなど）の原因になります。

以下の点に注意してください。

NULLポインタのチェック

関数がアドレスを受け取る際、そのアドレスが「どこも指していない（NULL）」可能性があります。

NULLポインタに対してアクセス（デリファレンス）しようとすると、プログラムは即座に異常終了します。

C言語
void safeUpdate(int *p) {
    if (p == NULL) {
        return; // 何もしない
    }
    *p = 10;
}

ローカル変数のアドレスを返さない

関数内で定義したローカル変数は、関数終了とともにメモリから消滅します。

そのアドレスを戻り値として返したり、外部のポインタに保持させたりしてはいけません。

ポインタの型の一致

int 型の変数には int * 型のポインタを使用しなければなりません。

型が一致しないポインタを無理やりキャストして使用すると、メモリの境界を越えてデータを破壊する恐れがあります。

C++の参照渡しとの違い

C言語を学んでいると、後継言語であるC++の「参照（Reference）」についても耳にすることがあるでしょう。

混同を避けるために、主な違いを整理しておきます。

C++の参照渡し（例：void func(int &n)）は、ポインタのようなアドレス操作を隠蔽し、あたかも普通の変数のように扱える仕組みです。

  • C言語（ポインタ渡し）: 呼び出し側で & が必要。関数内で * が必要。NULLを許容できる。
  • C++（参照渡し）: 呼び出し側は普通に渡すだけ。関数内でも普通に使うだけ。原則NULLにならず、初期化が必須。

C言語にはこの「参照型」がないため、すべてをポインタで制御する必要があります。

これは一見不便に思えますが、「どの関数が値を書き換える可能性があるか」が呼び出し側の & を見るだけで一目でわかるという明示的なメリットにも繋がっています。

まとめ

C言語における参照渡しは、ポインタという仕組みを利用して変数のアドレスを渡すことで実現されます。

値渡しがデータの「コピー」であるのに対し、参照渡しはデータの「共有」であると言い換えることができます。

本記事で解説した重要なポイントを振り返ります。

  • 値渡しは安全だが、大きなデータの転送には不向きであり、呼び出し元の変数を変更できない。
  • 参照渡し（ポインタ渡し）は、アドレスを渡すことでメモリ効率を最大化し、複数の値を更新することが可能になる。
  • 構造体や配列などの大規模データを扱う際は、ポインタによる受け渡しが標準的な手法である。
  • const 修飾子を適切に使用することで、参照渡しのメリットを享受しつつ、意図しないデータ破壊を防ぐことができる。
  • NULLチェックなど、ポインタ特有の安全性への配慮が不可欠である。

ポインタと参照渡しの理解は、C言語の習得において避けては通れない道です。

しかし、一度その仕組みを体得してしまえば、コンピュータのメモリを自由自在に操る強力な武器となります。

今回紹介したサンプルコードを実際に自分で入力・実行し、メモリの中で数値がどのように動いているかをイメージしながら、さらなるスキルアップを目指してください。