Зачем std::forward иметь две сигнатуры и явно указывать тип?

Question

[Max Goncharenko]

В стандарте std::forward имеет две сигнатуры (для lvalue и rvalue) и требует от пользователя явно указанного типа:

template <class T> T&& forward (typename remove_reference<T>::type& arg) noexcept;
template <class T> T&& forward (typename remove_reference<T>::type&& arg) noexcept;

В то время, когда тип можно вывести и реализовать всего лишь одну сигнатуру. В static_cast сработает сворачивание ссылок и результат будет эквивалентным стандартной функции.

template <typename T>
decltype(auto) my_forward(T&& arg) // universal reference (can be rvalue- or lvalue-reference)
{
    return static_cast<T&&>(arg);
    // T&& can be expanded to:
    // Foo& && - gives us Foo&
    // const Foo& && - give us const Foo&
    // Foo && - gives us Foo&&
    // const Foo && - gives us const Foo&&
}

Сравнение использования:

template <typename T>
func (T&& foo1, T&& foo2)
{
    f(std::forward<Foo>(foo1), my_forward(foo2));
}

Comments

[Евгений Шатунов]

Max Goncharenko , а ты вот эту статью читал?
Пересказывать содержимое статьи в ответ на твой вопрос не будет хорошим решением.

[Max Goncharenko]

Евгений Шатунов, пиши в ответ, отмечу правильным

Однако, эта функция позволяет вывести T& t в ситуации, когда этот тип не может быть выведен (согласно стандарту С++, 14.8.2.5), поэтому необходимо явно указывать параметры шаблона при вызове std::forward.

Приведи еще пример, когда тип нельзя вывести, плиз

Answer 1

[Евгений Шатунов]

Думаю, вот эта статья даст ответы на твои вопросы.

Если максимально точечно, то это раздел "Реализация идеальной передачи с использованием std::forward" и цитата в нем.

Еще один момент, который нужно отметить: использование std::remove_reference. На самом деле forward может быть реализован и без использования этой функции. Сжатие ссылок выполнит всю работу, таким образом, применение std::remove_reference для этого избыточно. Однако, эта функция позволяет вывести T& t в ситуации, когда этот тип не может быть выведен (согласно стандарту С++, 14.8.2.5), поэтому необходимо явно указывать параметры шаблона при вызове std::forward.

Answer 2

[Алексей Макареня]

Попытка №2, в первой был бред:
Основной проблемой является то, что внутри метода все параметры имеют тип l-value. То есть модификатор параметра && - это лишь требование, чтобы на место этого аргумента вызывающий код передал r-value (а для шаблонов даже этого не требует, благодаря склейки ссылок). И раз так, то ваш метод my_forward переделает вернёт l-value ссылки вообще для всех аргументов.

Отсюда берётся необходимость явно указывать тип аргумента - чтобы использовался именно выведенный тип, а не l-value на этот тип. Ну и почему 2 специализации: если указать явно тип аргумента и явно специализировать функцию каким-нибудь r-value, то my_forward будет ожидать строго r-value, и являющееся l-value значение параметра туда не подойдёт.

В объяснение моих мыслей, код

#include <iostream>

template<typename T>
decltype(auto) my_forward(T&& arg)
{
    return static_cast<T&&>(arg);
}

template <typename T, typename K>
void forward(T&& t, K&& k)
{
    std::cout << std::is_same<int&&, decltype(my_forward(t))>::value << std::endl;
    std::cout << std::is_same<int&, decltype(my_forward(k))>::value << std::endl;
    std::cout << std::is_same<int&&, decltype(std::forward<T>(t))>::value << std::endl;
    std::cout << std::is_same<int&, decltype(std::forward<K>(t))>::value << std::endl;
}

int main()
{
    int lval = 10;
    forward(10, lval);
    return 0;
}

вернёт
0
1
1
1

То есть предположение что my_forward вернуло int&& для первого параметра - не верно!

Comments

[Евгений Шатунов]

И вот r-value на этот самый type и используется для инстанцирования вызовов с переданным к-value значением, а версия с l-value ссылкой на этот type используется для инстанцирования с l-value значением.

Это не так. std::remove_reference применяется только к параметру std::forward и нужен для реализации одного конкретного случая. Тип результата у std::forward все так же выводится с помощью reference collapse rule.

https://github.com/llvm-mirror/libcxx/blob/master/...

[Max Goncharenko]

Вы думаете что возвращаемый ей результат является r-value, но это не так, она возвращает l-value!

Когда my_forward инстанцируется с помощью rvalue - то будет возвращен rvalue, то же самое и для lvalue
Пруф:

template <typename T>
decltype(auto) my_forward(T&& arg) // universal reference (can be rvalue- or lvalue-reference)
{
    return static_cast<T&&>(arg);
}

template <typename T>
func (T&& foo)
{
    auto&&  foo1 = my_forward(foo); //lvalue
    auto&&  foo2 = my_forward(T()); // rvalue

    // type of foo1 is Foo&
    // type of foo2 is Foo&&
}

Происходит это из-за сворачивания ссылок. decltype(auto) выведет rvalue-ссылку, есди ему передать rvalue-ссылку. Передает ему rvalue ссылку static_cast, который кастует параметр к T&&.

Когда передали rvalue, то T вывелся как Foo. Coответственно static_cast<T&&> = static_cast<Foo&&> - каст к rvalue-ссылке. Тогда и тип возращаемого значения функции выведется как rvalue reference.

Когда передали lvalue, то T выведен как Foo&, тогда static_cast<T&&> = static_cast<Foo& &&> и по правилу сворачивания ссылок = static_cast<Foo&> - каст к lvalue ссылке.

[Max Goncharenko]

При таком вот инстанцировании:

int my_value = 10;
int&& result = my_forward(my_value);

Превратиться в:

int& my_forward(int& arg)
{
return static_cast(arg);
}

Так это же ожидаемое поведение

[Алексей Макареня]

И сам ответ тоже не блистал, теперь расписал всё правильно!

Answer 3

[Mercury13]

std::forward предназначен для использования в шаблонах; без шаблона можно использовать старый добрый std::move.
Кроме того, std::forward налажен таким образом, что шаблонный параметр надо указывать явно.

Задача std::forward — передать далее простую или временную ссылку в зависимости от того, какую ссылку передаёт пользователь.

Comments

[Max Goncharenko]

Эм. Я не считаю это ответом.
std::move используется для rvalue-ссылок, а std::forward для универсальных - это и так понятно.

Что значит "налажен"? Я смотрел реализацию std::forward в стандартной библиотеке gcc и MSVC2017, их реализация ничем не отличается от моей, кроме того, что моя более общая.

Жду еще ответов.

[Mercury13]

Max Goncharenko, Это служит для того, чтобы расшаблонивание застряло, если не удастся указать тип T явно.

[Mercury13]

Плюс Си++14.

[Mercury13]

Плюс тут у вас ошибка!

#include <iostream>
#include <algorithm>

void alpha(int& x)
{
    std::cout << "Normal ref " << x << std::endl;
}

void alpha(int&& x)
{
    std::cout << "Temp ref " << x << std::endl;
}

template <typename T>
decltype(auto) my_forward(T&& arg) // universal reference (can be rvalue- or lvalue-reference)
{
    return static_cast<T&&>(arg);
}

template <class T>
void bravo(T&& x)
{
    alpha(my_forward(x));
}

int main()
{
    bravo(42);
    int many = 100500;
    bravo(many);
    return 0;
}

Выводит оба раза Normal ref!
std::forward (и static_cast), как и полагается, выводит Temp ref / Normal ref.

[Mercury13]

Ваше не работает, потому что decltype(auto) не станет временной ссылкой! Оно будет только простой ссылкой.

[Max Goncharenko]

Mercury13, оно не работает не из-за decltype, а из-за того, что в alpha(my_forward(x)); х - это lvalue, так как у него есть имя. Если вызвать my_forward для rvalue - все заработает.

Согласен, моя версия не работает когда ей передать rvalue ccылку, которая является lvalue :)