暗黙的なムーブを簡略化 [P2266R3](C++23)

// 例示用のムーブ可能な型
struct Widget {
  Widget(Widget&&);
};

// Widgetの右辺値から構築可能な型
struct RRefTaker {
  RRefTaker(Widget&&);
};


auto example1(Widget w) -> RRefTaker {
  // ローカル変数の暗黙ムーブ
  return w;  // ok、C++11から
}

auto example2(Widget&& w) -> RRefTaker {
  // ローカル右辺値参照の暗黙ムーブ
  return w;  // ok、C++20から
}

auto example3(Widget&& w) -> Widget&& {
  // ローカル右辺値参照の暗黙ムーブ（戻り値型が参照型の場合）
  return w;  // C++20ではng、C++23からok
}

// 右辺値修飾変換演算子を持つ型
struct Jeff {
  operator int&() &&;
};

auto example4(Jeff x) -> int& {
  // ローカル変数の暗黙ムーブ（戻り値型が参照型の場合）
  return x;  // C++20ではng、C++23からok
}

auto f(int n) -> decltype(auto) {
  return (n);   // かっこに囲まれたid-expression、ムーブする資格がある式
}
// C++20 : 戻り値型はint&
// C++23 : 戻り値型はint&&

auto g(int n) -> auto&& {
  return n;     // id-expression、ムーブする資格がある式
}
// C++20 : 戻り値型はint&
// C++23 : 戻り値型はint&&

auto f1(int n) -> decltype(auto) {
  return n;
}
// C++20/23共に戻り値型はint

auto f2(int n) -> auto {
  return n;
}
// C++20/23共に戻り値型はint

auto f3(int n) -> auto& {
  return n;
}
// C++20/23共に戻り値型はint&
// ただし、後述のようにC++23ではエラー

auto f4(int n) -> const auto& {
  return n;
}
// C++20/23共に戻り値型はconst int&

auto f() -> int& {
  int n = 10;

  return n; // ng、nはムーブする資格のある式であり、その型と値カテゴリはint&&（戻り値型と一致しない）
}

auto g() -> std::reference_wrapper<int> {
  int n = 10;

  return n; // ng、nはムーブする資格のある式であり、その型と値カテゴリはint&&（reference_wrapperのコンストラクタで拒否される）
}

auto f() -> int& {
  int n = 10;
  int& r = n;

  return r; // ok、rはムーブする資格のある式ではなく、その型と値カテゴリはint&
}

auto f() -> int&& {
  int n = 10;

  return n; // C++20ではng
            // C++23ではok、nはムーブする資格のある式であり、その型と値カテゴリはint&&
}

struct Weird {
  Weird();
  Weird(Weird&);
};

auto g(bool b) -> Weird {
  static Weird w1;
  Weird w2;

  if (b) {
    return w1;  // ok、w1はムーブする資格のある式ではなく、Weird(Weird&)が呼ばれる
  } else {
    return w2;  // ng、w2はムーブする資格のある式であり、xvalue（Weird&&）となる
  }
}

// ムーブしないことを明示する関数、C++20までは使用可能
template<typename T>
auto unmove(T&& v) -> T& {
  return v; // C++23からng、vはxvalue
}

// C++23では次のように修正する必要がある
template<typename T>
auto unmove(T&& v) -> T& {
  return static_cast<T&>(v); // ok、キャスト式はムーブする資格のある式ではない
}

// 例示用のムーブ可能な型
struct Widget {
  Widget(Widget&&);
};

auto f1(Widget w) -> Widget {
  return w;  // ローカル変数の暗黙ムーブ、C++11から
}

// Widgetの右辺値から構築可能な型
struct RRefTaker {
  // Widgetの右辺値からの変換コンストラクタ
  RRefTaker(Widget&&);
};

auto f2(Widget w) -> RRefTaker {
  return w;  // 暗黙ムーブされて構築（変換）、C++11から
}

auto f3(Widget&& w) -> RRefTaker {
  return w;  // ローカル右辺値参照の暗黙ムーブ、C++20から
}

[[noreturn]]
void f4(Widget w) {
  throw w;  // throw式における暗黙ムーブ、C++20から
}

struct From {
  From(Widget const &);
  From(Widget&&);
};

auto f5() -> From {
  Widget w;
  return w;  // 暗黙ムーブ（コンストラクタによる変換）、C++11から
}

struct To {
  operator Widget() &&;
};

auto f6() -> Widget {
  To t;
  return t;  // 暗黙ムーブ（変換演算子による変換）、C++20から
}

struct V {
  V(Widget); // 値で受け取るコンストラクタ
};

auto f7() -> V {
  Widget w;
  return w;  // 暗黙ムーブ（コンストラクタ引数へのムーブ）、C++20から
}

// DerivedはBaseを公開継承しているとき
auto f8() -> Base {
  Derived result;
  return result;  // 暗黙ムーブ（基底クラスへの変換）、C++20から
}

auto f9(Widget&& w) -> Widget&& {
  return w;  // 戻り値型が参照型の場合の暗黙ムーブ、C++23から
}

struct J {
  operator Widget&() &&;
};

auto f10(J x) -> Widget& {
  return x;  // 戻り値型が参照型の場合の暗黙ムーブ（変換演算子による変換）、C++23から
}

// Widget, RRefTakerは上の例を参照
// どちらも、C++20の場合

auto f(Widget&& w) -> RRefTaker {
  return w;  // ok、wは右辺値として扱われる
}

auto g(Widget&& w) -> Widget&& {
  return w;  // ng、wは左辺値として扱われる
}