C++ 参照渡し vs ムーブセマンティクス

std::vector<int> twice_vec(std::vector<int> vec) {
  for (auto& e : vec) {
    e *= 2;
  }

  return std::move(vec);
}

このコードですがあきらかにmoveの誤用です。この場合単に

std::vector<int> twice_vec(std::vector<int> vec) {
  for (auto& e : vec) {
    e *= 2;
  }

  return vec;
}

とすればよいです。なぜならば戻り値でstd::moveをわざわざ書くと、コンパイラによるNRVOを阻害して動作を遅くするからです。return vecとただ書けば、NRVOによってコストは0です。(ついでにいうと、clangはstd::moveつけんな、と警告を出します。)

NRVOが働かなかった時代においては、確かに引数経由で返却する習慣がありましたが、今では代入演算子の分コスト的に不利です。何も考えずにそのまま戻り値で返しましょう。

ちなみにC++17以降ではRVOが義務化され、RVOになる場合copy/move ctorが削除されていても戻り値として返却できます。

move sematicsそのものについての理解が不十分なように思えるので
みんなlvalueとrvalueを難しく考えすぎちゃいないかい？
をお読みください。

追記:

あーわかったわかった、他の人の解答見てて視点漏れしてたので解説し直し。

void f(C& c);
C g(const C& c);

この２つのどちらを選ぶべきか、2つの用例を考えて比較します。

immutableにしたい、なにかを元にして新規に領域を確保するようなケースでは

void f(C& dest, const C& src);
C g(const C& c);
int main()
{
    C src;
    //do something
    C dest;
    f(src, dest);
}

と

C src;
//do something
C dest = g(src);

ではあきらかに後者を選ぶべきです。これは上で解説したようにNRVOが働くため2重copyにはならないから可読性の観点と、もしf/gの中でCのコンストラクタを呼んでいてそれを変更して返却するような場合ではコピー代入演算子のコスト分お得です。私の解答はここに主眼をおいていました。

mutableにできる場合はChironianさんの解答が該当ですね。

std::moveするのって

1) 関数の引数に渡して所有権を放棄するとき

ex.) std::vector::emplace_back

f(std::move(a));

この時関数の引数の型は

void f1(C c);
void f2(C&& c);//rvalue reference
template<typename CC>
void f3(CC&& c);//universal reference(forwarding reference)

でないとmove semanticsできない(=所有権の放棄を識別できない)

f1の場合は関数呼び出し時点でmove ctor呼び出し。内部で再度moveするなら避けるべき

f2の場合は関数の内部でmove semanticsできる。

f3はどちらかというとparfect forwarding

2) move ctorを呼び出す時

C c2 = std::move(c1);

が大半な気がします。

いずれにせよ場面毎に設計上の制約を把握した上で適切に判断する必要があるのでなかなか難しいですね。追記したのにうまくまとまらないし。

当方の認識では、パフォーマンス的に参照渡しで書いたコードが劣ることはないと理解しています。

正しい認識と思います。

この差は、ムーブで書いたほうが各変数がimmutableなように書いてあって分かりやすい以外に何かあるのでしょうか。

関数の“自然な”使い方は、必要な入力データを引数を介して渡し、出力データを戻り値を介して受け取るスタイルです。設計ポリシーや個人の好みはありますが、このような関数の性質（参照透過性）はプログラムの可読性や保守性といった観点から好ましいスタイルとされています。

古くからある「関数引数に参照型を用いた出力(out)引数の実現」は、実行時効率を優先したある種の"ハック"とみなせます。ムーブセマンティクスの導入により、実行時効率を犠牲にすることなく“自然な”スタイルを実現できるようになりました。

どういう時はどっちのほうが良い、などあるのでしょうか。
（極端な話、今までポインタや参照渡しで書かれていたコードは全てムーブセマンティクスで書いたほうが良いというような話なのでしょうか）

C++言語における コピー／ムーブ渡し(pass-by-value)・参照渡し(pass-by-reference)・ポインタ渡し の使い分けは、実行時効率まで考慮して最適なものを選ぼうとすると少々厄介です。実行時効率や利便性や安全性などの要素を考慮していくと、両スタイルを提供する関数オーバーロードが必要になるケースも出てきます。

網羅的な説明は難しいため、ここでは C++ Core Guidelines の紹介にとどめます。

パフォーマンスを気にしているようですので、取りあえず計ってみました。

ループ数を変えたり、コンパイラのバージョンを変えたり、最適化オプションを変えたりすると、あまり差が出なかったりします。ただ、twice_vecがtwince_vec2より明らかに速いというパターンは見つけられませんでした。書き方とか、詳しい解説は他の方にお任せします。(私には説明できないので)

そもそも、パフォーマンス以前として、twice_vec()の方はstd::move(a)しているので、この後のコードで、aを参照するとコア吐いて死にます。上のコードを書くときに、値が書き換わっているかの確認とかしているとコアダンプで落ちまくるなー、なんでやー、って10分も悩みました。こういうことが起きるので、私は、よっぽどの理由が無い限りstd::moveを使わないヘタレプログラマーで生きていこうと思います。

参照が適さないケースとして
圧縮されたデータを展開するシナリオを考えます。

std::vector<byte> inflate1(const std::vector<byte>& zipped){
  size_t len = *(size_t*)zipped.data();
  std::vector<byte> result(len);

  // なんらかのデータ展開処理

  return result;
}

void inflate2(const std::vector<byte> &zipped, std::vector<byte> &result){
  size_t len = *(size_t*)zipped.data();
  result.swap(std::vecor<byte>(len));

  // なんらかのデータ展開処理
}

int main(){
  std::vector<byte> zip{100,0,0,0,0xff,0xff};
  {
    std::vector<byte> result = inflate1(zip);
  }
  {
    std::vector<byte> result;
    inflate2(zip, result);
  }
}

この場合、NRVOを用いたinflate1の方がわかりやすく、効率もよいでしょう。
inflate2は、呼ばれた時点でresultに何が入っているのか・どういう状況なのかがわかりません。
そのため、解放および初期化が必要になります。

上ではムーブセマンティクスを使いませんでした。
というのも、現状のムーブセマンティクスには欠陥があり必要でないなら使わない方がパフォーマンス上よい
と私は思っているからです。
その欠陥は、ムーブした後の残骸であろうとデストラクタが呼び出される事です。

逆に使う必要がある時というのは限られています。
それは、

• コピー代入が使えないとき
• 参照が使えないとき

です。

思いつくのは・・・

#include <iostream>
#include <memory>
#include <cstdlib>

int main(){
    using namespace std;
    unique_ptr<char> t = make_unique<char>('Q');
    for(int i=38;i<100;i++){
        unique_ptr<char> s = make_unique<char>(i);

        // 適当な条件式
        if(rand() % 100 > 93){
            t = std::move(s);
            break;
        }
    }
    if(t) cout << *t << endl;
}

こんな感じでしょうか

こんにちは。

当方の認識では、パフォーマンス的に参照渡しで書いたコードが劣ることはないと理解しています。

微差ですが、参照渡しの方がオーバーヘッドは少ないと思います。
ムーブといっても移動できるものは「所有権≒解放する義務」に過ぎません。所有権を移動できないようなリソースは普通にコピーされます。例えば、std::vectorの場合、「要素数」や「要素を獲得した領域へのポインタ」等は移動できないので普通にコピーされます。ムーブ（所有権を移動）されるのは要素の値を保持しているメモリ（一般にヒープ・メモリ）だけです。

この差は、ムーブで書いたほうが各変数がimmutableなように書いてあって分かりやすい以外に何かあるのでしょうか。

std::moveを指定するということはmmutable許可ですよ。こっそりムーブされるstd::auto_ptrの反省からこっそりムーブされると困る時はムーブ許可を明示することになったというもので、呼び出し先での変更を許可するという意味も込められています。

また、正直、「右辺値参照」を理解することの難易度は高いと思います。
更に、std::moveの必要性を理解せずにstd::vector<int> b = twice_vec(a);と書かれると泣きたくなるかも。

従って、下記３つの理由で左辺値参照を使った方が好ましいと感じます。

1. より知識が浅い人でも理解できるし書くこともできる
2. パフォーマンス的に微差とは言え有利
3. 右辺値参照版はstd::moveを書き忘れるとstd::vectorのコピーが発生するので悲しい

なお、下記のように定義すれば、上記の3.を回避できます。

std::vector<int> twice_vec(std::vector<int>&& vec) {
  for (auto& e : vec) {
    e *= 2;
  }

  return std::move(vec);
}

このケースでは、returnのstd::moveは書いた方がいいような気がします。
NRVOは機能できない筈ですし、構文的にはコピーになる筈です。コンパイラがstd::moveなしでも左辺値をムーブしてくれればよいのですが。

↓右辺値参照は左辺値です。わけわからんですね。
https://cpprefjp.github.io/lang/cpp11/rvalue_ref_and_move_semantics.html

右辺値参照で宣言された変数は右辺値ではなく、左辺値である。