【C++】値渡し・ポインタ渡し・参照渡しの違いとは？｜コピーの回数・書き換わるか・速さを実測して、使い分けを整理

▼4つの書き方
void byValue(int x);      // 値渡し
void byPointer(int* x);   // ポインタ渡し
void byRef(int& x);       // 参照渡し
void byConstRef(const int& x);  // const参照渡し(読むだけ)

▼e1_count.cpp
// 引数の渡し方ごとに、コピーが何回起きるかを数える
#include <cstdio>

struct Tracker
{
    int id;
    static int copies;
    explicit Tracker(int i) : id(i) {}
    Tracker(const Tracker& o) : id(o.id) { ++copies; }
};
int Tracker::copies = 0;

void byValue(Tracker t)           { (void)t; }
void byPointer(Tracker* t)        { (void)t; }
void byRef(Tracker& t)            { (void)t; }
void byConstRef(const Tracker& t) { (void)t; }

int main()
{
    Tracker a(1);

    Tracker::copies = 0;  byValue(a);      std::printf("値渡し        byValue(a)      : コピー %d 回\n", Tracker::copies);
    Tracker::copies = 0;  byPointer(&a);   std::printf("ポインタ渡し  byPointer(&a)   : コピー %d 回\n", Tracker::copies);
    Tracker::copies = 0;  byRef(a);        std::printf("参照渡し      byRef(a)        : コピー %d 回\n", Tracker::copies);
    Tracker::copies = 0;  byConstRef(a);   std::printf("const参照渡し byConstRef(a)   : コピー %d 回\n", Tracker::copies);
    return 0;
}

値渡し        byValue(a)      : コピー 1 回
ポインタ渡し  byPointer(&a)   : コピー 0 回
参照渡し      byRef(a)        : コピー 0 回
const参照渡し byConstRef(a)   : コピー 0 回

▼e2_modify.cpp
// 呼び出し側の変数は、書き換わるか。引数の「住所」は、元の変数と同じか
#include <cstdio>

const int* g_valueAddr = nullptr;

void addByValue(int x)    { x += 10;  g_valueAddr = &x; }
void addByPointer(int* x) { *x += 10; g_valueAddr = x;  }
void addByRef(int& x)     { x += 10;  g_valueAddr = &x; }

int main()
{
    int n = 1;

    n = 1; addByValue(n);
    std::printf("値渡し      : n = %2d   引数の住所は元の n と%s\n", n, g_valueAddr == &n ? "同じ" : "別");

    n = 1; addByPointer(&n);
    std::printf("ポインタ渡し: n = %2d   引数が指す先は元の n と%s\n", n, g_valueAddr == &n ? "同じ" : "別");

    n = 1; addByRef(n);
    std::printf("参照渡し    : n = %2d   引数の住所は元の n と%s\n", n, g_valueAddr == &n ? "同じ" : "別");
    return 0;
}

値渡し      : n =  1   引数の住所は元の n と別
ポインタ渡し: n = 11   引数が指す先は元の n と同じ
参照渡し    : n = 11   引数の住所は元の n と同じ

▼e3_reseat.cpp
// ポインタ渡しの「ポインタ自身」は、値渡しされている
#include <cstdio>

int g_other = 999;

void reseat(int* p)       { p = &g_other; }      // 関数の中のコピーだけが、向き先を変える
void reseatByRef(int*& p) { p = &g_other; }      // ポインタへの参照: 呼び出し側のポインタが変わる
void reseatByPP(int** pp) { *pp = &g_other; }    // ポインタのポインタ: 呼び出し側のポインタが変わる

int main()
{
    int mine = 1;

    int* p = &mine;
    reseat(p);
    std::printf("reseat(p)        のあと: *p = %3d\n", *p);

    p = &mine;
    reseatByRef(p);
    std::printf("reseatByRef(p)   のあと: *p = %3d\n", *p);

    p = &mine;
    reseatByPP(&p);
    std::printf("reseatByPP(&p)   のあと: *p = %3d\n", *p);
    return 0;
}

reseat(p)        のあと: *p =   1
reseatByRef(p)   のあと: *p = 999
reseatByPP(&p)   のあと: *p = 999

▼e4_null.cpp
// nullptr が入り込めるのは、ポインタだけか
#include <cstdio>
#include <cstring>

int readPtr(const int* p) { return *p; }
int readRef(const int& r) { return r; }
int readPtrSafe(const int* p) { return p ? *p : -1; }

int main(int argc, char** argv)
{
    std::setvbuf(stdout, nullptr, _IONBF, 0);
    int* np = nullptr;
    const char* mode = argc > 1 ? argv[1] : "safe";

    if (std::strcmp(mode, "safe") == 0)
    {
        std::printf("nullptrチェック付きのポインタ版: %d\n", readPtrSafe(np));
    }
    else if (std::strcmp(mode, "ptr") == 0)
    {
        std::printf("ポインタ版に nullptr を渡す\n");
        std::printf("%d\n", readPtr(np));
    }
    else if (std::strcmp(mode, "ref") == 0)
    {
        std::printf("参照版に *nullptr を渡す(コンパイルは通る)\n");
        std::printf("%d\n", readRef(*np));
    }
    return 0;
}

▼e5_speed.cpp
// 値渡しと const 参照渡しの速さを、サイズ別に測る
#include <chrono>
#include <cstdio>
#include <cstring>
#include <string>

template <int N> struct Blob { char data[N]; };

// 呼び出しが消えないように、インライン展開を禁止する
template <int N> __declspec(noinline) int sumByValue(Blob<N> b)          { return b.data[0] + b.data[N - 1]; }
template <int N> __declspec(noinline) int sumByRef(const Blob<N>& b)     { return b.data[0] + b.data[N - 1]; }

__declspec(noinline) int lenByValue(std::string s)        { return (int)s.size(); }
__declspec(noinline) int lenByRef(const std::string& s)   { return (int)s.size(); }

static volatile int g_sink = 0;

template <class F> double measure(F f, int calls)
{
    auto t0 = std::chrono::steady_clock::now();
    f(calls);
    auto t1 = std::chrono::steady_clock::now();
    return std::chrono::duration<double, std::nano>(t1 - t0).count() / calls;
}

template <int N> void runBlob()
{
    Blob<N> b;
    std::memset(b.data, 1, N);
    const int calls = 20000000;
    double v = measure([&](int n) { int s = 0; for (int i = 0; i < n; ++i) { b.data[0] = (char)i; s += sumByValue<N>(b); } g_sink = s; }, calls);
    double r = measure([&](int n) { int s = 0; for (int i = 0; i < n; ++i) { b.data[0] = (char)i; s += sumByRef<N>(b); } g_sink = s; }, calls);
    std::printf("%5d バイトの構造体 : 値渡し %6.2f ns/回   const参照渡し %6.2f ns/回   (値渡しは %.1f 倍)\n", N, v, r, v / r);
}

int main()
{
    runBlob<4>();
    runBlob<16>();
    runBlob<64>();
    runBlob<256>();
    runBlob<1024>();
    runBlob<4096>();

    std::string small = "hello";
    std::string big(200, 'x');
    const int calls = 5000000;
    double sv = measure([&](int n) { int s = 0; for (int i = 0; i < n; ++i) s += lenByValue(small); g_sink = s; }, calls);
    double sr = measure([&](int n) { int s = 0; for (int i = 0; i < n; ++i) s += lenByRef(small); g_sink = s; }, calls);
    std::printf("std::string(5文字)   : 値渡し %6.2f ns/回   const参照渡し %6.2f ns/回   (値渡しは %.1f 倍)\n", sv, sr, sv / sr);
    double bv = measure([&](int n) { int s = 0; for (int i = 0; i < n; ++i) s += lenByValue(big); g_sink = s; }, calls);
    double br = measure([&](int n) { int s = 0; for (int i = 0; i < n; ++i) s += lenByRef(big); g_sink = s; }, calls);
    std::printf("std::string(200文字) : 値渡し %6.2f ns/回   const参照渡し %6.2f ns/回   (値渡しは %.1f 倍)\n", bv, br, bv / br);
    return 0;
}

    4 バイトの構造体 : 値渡し   1.29 ns/回   const参照渡し   0.64 ns/回   (値渡しは 2.0 倍)
   16 バイトの構造体 : 値渡し   7.61 ns/回   const参照渡し   0.63 ns/回   (値渡しは 12.1 倍)
   64 バイトの構造体 : 値渡し   7.68 ns/回   const参照渡し   0.63 ns/回   (値渡しは 12.1 倍)
  256 バイトの構造体 : 値渡し   8.93 ns/回   const参照渡し   0.63 ns/回   (値渡しは 14.1 倍)
 1024 バイトの構造体 : 値渡し  16.58 ns/回   const参照渡し   0.64 ns/回   (値渡しは 26.0 倍)
 4096 バイトの構造体 : 値渡し  32.85 ns/回   const参照渡し   0.64 ns/回   (値渡しは 51.5 倍)
std::string(5文字)   : 値渡し   2.41 ns/回   const参照渡し   0.38 ns/回   (値渡しは 6.4 倍)
std::string(200文字) : 値渡し  41.14 ns/回   const参照渡し   0.40 ns/回   (値渡しは 101.8 倍)

▼e6_rvalue_bad.cpp
// 参照渡しに、一時的な値(リテラル)を渡すとどうなるか
void setByRef(int& x)            { x = 1; }
void readByConstRef(const int& x) { (void)x; }

int main()
{
    setByRef(5);          // 非const参照に、リテラルは渡せない
    readByConstRef(5);    // const参照なら、渡せる
    return 0;
}

e6_rvalue_bad.cpp
e6_rvalue_bad.cpp(7): error C2664: 'void setByRef(int &)': 引数 1 を 'int' から 'int &' へ変換できません。
e6_rvalue_bad.cpp(7): note: 非定数の参照は左辺値へのみバインドされます。
e6_rvalue_bad.cpp(2): note: 'setByRef' の宣言を確認してください
e6_rvalue_bad.cpp(7): note: 引数リスト '(int)' を一致させようとしているとき