std:: forward

t が forwarding reference （CV修飾されていない関数テンプレートパラメータへの右辺値参照として宣言された関数引数）である場合、このオーバーロードは引数を呼び出し元関数に渡された時の value category を維持した状態で他の関数へ転送します。

例えば、以下のようなラッパーで使用した場合、テンプレートは以下のように動作します：

template<class T>
void wrapper(T&& arg)
{
    // argは常に左辺値
    foo(std::forward<T>(arg)); // Tに応じて左辺値または右辺値として転送
}

• wrapper() の呼び出しでrvalueの std::string が渡された場合、 T は std::string （ std::string& 、 const std::string& 、または std::string&& ではない）と推論され、 std::forward によってrvalue参照が foo に渡されることが保証されます。
• wrapper() の呼び出しでconst lvalueの std::string が渡された場合、 T は const std::string& と推論され、 std::forward によってconst lvalue参照が foo に渡されることが保証されます。
• wrapper() の呼び出しで非const lvalueの std::string が渡された場合、 T は std::string& と推論され、 std::forward によって非const lvalue参照が foo に渡されることが保証されます。

このオーバーロードは、式（関数呼び出しなど）の結果を、転送参照引数の元の値カテゴリとして、右辺値または左辺値のいずれかとして転送することを可能にします。

例えば、ラッパーが単に引数を転送するのではなく、引数のメンバー関数を呼び出し、その結果を転送する場合：

// 変換ラッパー
template<class T>
void wrapper(T&& arg)
{
    foo(forward<decltype(forward<T>(arg).get())>(forward<T>(arg).get()));
}

argの型は以下の通りです

struct Arg
{
    int i = 1;
    int  get() && { return i; } // このオーバーロードの呼び出しはrvalue
    int& get() &  { return i; } // このオーバーロードの呼び出しはlvalue
};

rvalueをlvalueとして転送しようとすること、例えば形式 (2) をlvalue参照型Tでインスタンス化することは、コンパイル時エラーとなります。

注記

転送参照（関数パラメータとして使用される T&& ）の背後にある特別な規則については template argument deduction を、その他の詳細については forwarding references を参照してください。

パラメータ

戻り値

static_cast < T && > ( t )

計算量

定数。

例

#include <iostream>
#include <memory>
#include <utility>
struct A
{
    A(int&& n) { std::cout << "rvalue overload, n=" << n << '\n'; }
    A(int& n)  { std::cout << "lvalue overload, n=" << n << '\n'; }
};
class B
{
public:
    template<class T1, class T2, class T3>
    B(T1&& t1, T2&& t2, T3&& t3) :
        a1_{std::forward<T1>(t1)},
        a2_{std::forward<T2>(t2)},
        a3_{std::forward<T3>(t3)}
    {}
private:
    A a1_, a2_, a3_;
};
template<class T, class U>
std::unique_ptr<T> make_unique1(U&& u)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)));
}
template<class T, class... U>
std::unique_ptr<T> make_unique2(U&&... u)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)...));
}
auto make_B(auto&&... args) // since C++20
{
    return B(std::forward<decltype(args)>(args)...);
}
int main()
{
    auto p1 = make_unique1<A>(2); // rvalue
    int i = 1;
    auto p2 = make_unique1<A>(i); // lvalue
    std::cout << "B\n";
    auto t = make_unique2<B>(2, i, 3);
    std::cout << "make_B\n";
    [[maybe_unused]] B b = make_B(4, i, 5);
}

rvalue overload, n=2
lvalue overload, n=1
B
rvalue overload, n=2
lvalue overload, n=1
rvalue overload, n=3
make_B
rvalue overload, n=4
lvalue overload, n=1
rvalue overload, n=5

関連項目