std::forward

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека метапрограммирования (C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Библиотека утилит

Языковая поддержка Поддержка типов (базовые типы, RTTI) Макросы тестирования функциональности библиотеки (C++20)     Управление динамической памятью Программные утилиты Поддержка сопрограмм (C++20) Вариативные функции is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Трёхстороннее сравнение (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)     is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

Общие утилиты Дата и время Функциональные объекты Библиотека форматирования (C++20) bitset hash (C++11) Операторы отношения (устарело в C++20) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= Целочисленные функции сравнения cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)     cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Операции обмена и типа swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Общие лексические типы pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23) Элементарные преобразования строк to_chars (C++17) from_chars (C++17) chars_format (C++17) to_chars_result (C++17) from_chars_result (C++17)

 

<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>

Определено в заголовочном файле <utility>
	(1)
template< class T > T&& forward( typename std::remove_reference<T>::type& t ) noexcept;			(начиная с C++11) (до C++14)
template< class T > constexpr T&& forward( std::remove_reference_t<T>& t ) noexcept;			(начиная с C++14)
		(2)
template< class T > T&& forward( typename std::remove_reference<T>::type&& t ) noexcept;				(начиная с C++11) (до C++14)
template< class T > constexpr T&& forward( std::remove_reference_t<T>&& t ) noexcept;				(начиная с C++14)

1) Пересылает левостороннее значение либо как левостороннее значение, либо как правостороннее значение, в зависимости от T

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

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

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

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

2) Пересылает правостороннее значение как правостороннее значение и запрещает пересылку правостороннего значения как левостороннего.

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

Например, если оболочка не просто пересылает свой аргумент, а вызывает функцию-элемент для аргумента и пересылает её результат:

// обертка-трансформер
template<class T>
void wrapper(T&& arg)
{
    foo(forward<decltype(forward<T>(arg).get())>(forward<T>(arg).get()));
}

где тип аргумента может быть

struct Arg
{
    int i = 1;
    int  get() && { return i; } // вызов этой перегрузки это правостороннее значение
    int& get() &  { return i; } // вызов этой перегрузки это левостороннее значение
};

Попытка передать правостороннее значение как левостороннее, например, путём создания экземпляра формы (2) с левосторонней ссылкой типа T, является ошибкой времени компиляции.

Примечание

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

Параметры

t

—

объект, который нужно переслать

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

static_cast<T&&>(t)

Сложность

Константная

Пример

Этот пример демонстрирует идеальную передачу параметра(ов) аргументу конструктора класса T. Также демонстрируется идеальная пересылка пакетов параметров.

Запустить этот код

#include <iostream>
#include <memory>
#include <utility>

struct A
{
    A(int&& n) { std::cout << "перегрузка rvalue, n=" << n << '\n'; }
    A(int& n)  { std::cout << "перегрузка lvalue, 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) // начиная с 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, n=2
перегрузка lvalue, n=1
B
перегрузка rvalue, n=2
перегрузка lvalue, n=1
перегрузка rvalue, n=3
make_B
перегрузка rvalue, n=4
перегрузка lvalue, n=1
перегрузка rvalue, n=5

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

move (C++11)	получает ссылку на rvalue (шаблон функции)
move_if_noexcept (C++11)	получает ссылку rvalue, если конструктор перемещения не генерирует исключение (шаблон функции)