std:: forward

Когда t является forwarding reference (аргументом функции, объявленным как rvalue-ссылка на параметр шаблона функции без cv-квалификаторов), эта перегрузка перенаправляет аргумент в другую функцию с value category , которая была у него при передаче в вызывающую функцию.

Например, если используется в обёртке, как показано ниже, шаблон ведёт себя следующим образом:

template<class T>
void wrapper(T&& arg)
{
    // arg всегда является lvalue
    foo(std::forward<T>(arg)); // Передача как lvalue или как rvalue, в зависимости от T
}

• Если вызов wrapper() передает rvalue std::string , то T выводится как std::string (не std::string& , const std::string& или std::string&& ), и std::forward гарантирует, что в foo передается rvalue-ссылка.
• Если вызов wrapper() передает const lvalue std::string , то T выводится как const std::string& , и std::forward гарантирует, что в foo передается const lvalue-ссылка.
• Если вызов wrapper() передает неконстантный lvalue std::string , то T выводится как std::string& , и std::forward гарантирует, что в foo передается неконстантная lvalue-ссылка.

Эта перегрузка позволяет передать результат выражения (например, вызова функции), который может быть rvalue или lvalue, с сохранением исходной категории значения аргумента forwarding reference.

Например, если обёртка не просто передаёт свой аргумент, а вызывает метод у аргумента и передаёт его результат:

// transforming wrapper
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) с типом T ссылки на lvalue, является ошибкой времени компиляции.

Примечания

См. вывод аргументов шаблона для специальных правил, касающихся пересылающих ссылок ( T&& используемых в качестве параметра функции), и пересылающие ссылки для дополнительных деталей.

Параметры

Возвращаемое значение

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

Смотрите также