C++の関数パラメータ：値渡し・参照渡し・const参照

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

関数の**仮引数（パラメータ）**は定義に書かれた名前付きの変数で、**実引数（アーギュメント）**は呼び出すときに実際に渡す値です。前のページでは関数の定義と呼び出し方を説明しました。このページでは、それらの値が実際にどのように中へ渡されるかを扱います。C++にはいくつかの渡し方があり、その選択は正しさと速度の両方に影響するからです。

C++のデフォルトは値渡しで、関数はコピーを受け取ります。

#include <iostream>
using namespace std;

void addTen(int n) {   // n は渡したもののコピー
    n = n + 10;
    cout << "inside: " << n << endl;
}

int main() {
    int score = 5;
    addTen(score);
    cout << "outside: " << score << endl;   // まだ 5
    return 0;
}

addTen の中の n は、score から初期化された別個の変数です。n への再代入はそのコピーにしか影響しないので、main に戻ったときの score は変わりません。これは安全で予測しやすく、関数が誤ってデータを壊すことがありません。だからこそデフォルトになっているのです。

参照渡し：関数に呼び出し側を変更させる

ときには、関数に呼び出し側の変数を変更してほしいこともあります。パラメータの型に & を付けると、それは参照、つまりコピーではなく元の変数の別名になります。

#include <iostream>
using namespace std;

void addTen(int& n) {   // n は呼び出し側の変数を指す
    n = n + 10;
}

int main() {
    int score = 5;
    addTen(score);
    cout << score << endl;   // 15 - 元の変数が変わった
    return 0;
}

最初の例との唯一の違いは & ですが、いまや n と score は同じオブジェクトです。これは複数の値を「返す」、あるいは何かをその場で更新するための標準的な方法です。典型的な使い方は2つの変数の入れ替えです。

#include <iostream>
using namespace std;

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

int main() {
    int x = 1, y = 2;
    swapValues(x, y);
    cout << x << " " << y << endl;   // 2 1
    return 0;
}

& がなければ、swapValues は2つのコピーを入れ替えるだけで、main には何の変化も見えません - 初心者が非常によくやるバグです。

const参照：安価で読み取り専用のアクセス

値渡しは引数をコピーします。int ならコストはゼロですが、大きな string や vector を呼び出しのたびにコピーするのは、実際の無駄な作業です。その解決策が const 参照（const T&）です。参照の速さ（コピーなし）に加えて、引数を変更しないというコンパイラが保証する約束が得られます。

#include <iostream>
#include <string>
using namespace std;

// string のコピーは作られず、誤って変更することもできない
void greet(const string& name) {
    cout << "Hello, " << name << "!" << endl;
    // name = "x";   // コンパイルエラーになる - name は const
}

int main() {
    string visitor = "Ada";
    greet(visitor);
    greet("temporary");   // const& は一時オブジェクトにも束縛できる
    return 0;
}

便利な目安として、小さな組み込み型（int、double、char、bool、ポインタ）は値渡しで、読み取るだけの大きなオブジェクトは const 参照で渡します。const でない素の T& は、呼び出し側のオブジェクトを本当に変更したい場合のために取っておきます。

微妙な落とし穴：素の int& n は一時オブジェクトやリテラルに束縛できません。最初の例の addTen(5) は、パラメータが int& だったらコンパイルできません。5 は別名を付けられる変数ではないからです。一方 const int& は 5 に束縛できます。これも const 参照が広く使われる理由の一つです。

デフォルト引数

パラメータに代わりの値を与えておけば、呼び出し側はそれを省略できます。引数がなければデフォルト値が使われます。

#include <iostream>
#include <string>
using namespace std;

void connect(const string& host, int port = 8080, bool secure = false) {
    cout << (secure ? "https" : "http") << "://"
         << host << ":" << port << endl;
}

int main() {
    connect("example.com");              // port=8080, secure=false
    connect("example.com", 443);         // secure=false
    connect("example.com", 443, true);   // 3つすべて指定
    return 0;
}

人がつまずく規則が2つあります。1つ目、デフォルト値は末尾でなければならない - あるパラメータがデフォルト値を持つと、それ以降のすべてのパラメータもデフォルト値を持たなければなりません。void f(int a = 1, int b) とは書けません。a を飛ばして b だけを渡す方法がないからです。2つ目、関数をヘッダで宣言し別の場所で定義する場合、デフォルト値は宣言にだけ書き、定義では決して繰り返してはいけません - 繰り返すとコンパイルエラーになります。

配列とベクタを渡す

生の配列は渡されるときにポインタへと成り下がるため、関数はそのサイズを見失います - ほとんどの場合、長さを一緒に渡します。

#include <iostream>
using namespace std;

int sum(const int arr[], int size) {   // ここでは arr は実際には int*
    int total = 0;
    for (int i = 0; i < size; i++) total += arr[i];
    return total;
}

int main() {
    int nums[] = {4, 8, 15, 16};
    cout << sum(nums, 4) << endl;   // 43
    return 0;
}

配列がポインタになったため、sum の中での sizeof(arr) は配列ではなくポインタのサイズを返します - 有名なバグです。モダンC++では、自分自身のサイズを保持する std::vector（C++20では std::span）を const 参照で渡すことを推奨します。

#include <iostream>
#include <vector>
using namespace std;

int sum(const vector<int>& v) {   // コピーなし、自分のサイズを知っている
    int total = 0;
    for (int x : v) total += x;
    return total;
}

int main() {
    vector<int> nums = {4, 8, 15, 16};
    cout << sum(nums) << endl;   // 43
    return 0;
}

const& に注目してください。これを外すと呼び出しのたびにベクタ全体がコピーされます。要素が4つのベクタなら無害ですが、100万要素なら見えない性能の落とし穴になります。

ポインタパラメータ

ポインタ（T*）を渡すこともできます。参照と同じく、これによって関数は呼び出し側のデータに手を伸ばせますが、ポインタは付け替えられたりヌルになったりします - つまり「値なし」が正当な選択肢である場合に適したツールです。

#include <iostream>
using namespace std;

// 結果を書き込む場所がないときは false を返す
bool tryParseDouble(const char* text, double* out) {
    if (out == nullptr) return false;   // ヌルに対するガード
    *out = 0.0;
    for (const char* p = text; *p >= '0' && *p <= '9'; ++p) {
        *out = *out * 10 + (*p - '0');
    }
    return true;
}

int main() {
    double value;
    if (tryParseDouble("123", &value)) {
        cout << "parsed: " << value << endl;
    }
    return 0;
}

呼び出し側はアドレスを共有するために &value を渡し、関数は *out を通じて書き込みます。参照との重要な違いは、ポインタは nullptr になりうることです。そのため、ポインタを受け取る関数はデリファレンスする前にチェックすべきです - このガードを飛ばしてヌルポインタをデリファレンスするのは未定義動作で、たいていはクラッシュします。「値なし」がまったく意味を成さないなら、そもそもヌルになりえない参照のほうがすっきりします。

次へ：参照

パラメータは参照がその真価を発揮する場所ですが、参照はそれ自体が一つの機能です - 関数のシグネチャの中だけでなく、任意の変数に対して作れる別名なのです。次のページでは参照そのものの仕組みを掘り下げます。宣言の仕方、なぜ即座に初期化しなければならないのか、lvalue参照と const 参照の違い、そして参照がどのようにして宙ぶらりん（dangling）になりうるかという微妙な点を見ていきます。