Есть ли варианты использования std::forward с prvalue?

Хорошо, поскольку @vsoftco запросил краткий вариант использования, вот усовершенствованная версия (используя его идею наличия «my_forward», чтобы фактически увидеть, какая перегрузка вызывается).

Я интерпретирую «вариант использования», предоставляя пример кода, который без prvalue не компилируется или ведет себя по-другому (независимо от того, было бы это действительно полезно или нет).

У нас есть 2 перегрузки для std::forward

#include <iostream>

template <class T>
inline T&& my_forward(typename std::remove_reference<T>::type& t) noexcept
{
    std::cout<<"overload 1"<<std::endl;
    return static_cast<T&&>(t);
}

template <class T>
inline T&& my_forward(typename std::remove_reference<T>::type&& t) noexcept
{
    std::cout<<"overload 2"<<std::endl;
    static_assert(!std::is_lvalue_reference<T>::value,
              "Can not forward an rvalue as an lvalue.");
    return static_cast<T&&>(t);
}

И у нас есть 4 возможных варианта использования

Сценарий 1

#include <vector>
using namespace std;

class Library
{
    vector<int> b;
public:
    // &&
    Library( vector<int>&& a):b(std::move(a)){

    }
};

int main() 
{
    vector<int> v;
    v.push_back(1);
    Library a( my_forward<vector<int>>(v)); // &
    return 0;
}

Сценарий 2

#include <vector>
using namespace std;

class Library
{
    vector<int> b;
public:
    // &&
    Library( vector<int>&& a):b(std::move(a)){

    }
};

int main() 
{
    vector<int> v;
    v.push_back(1);
    Library a( my_forward<vector<int>>(std::move(v))); //&&
    return 0;
}

Сценарий 3

#include <vector>
using namespace std;

class Library
{
    vector<int> b;
public:
    // &
    Library( vector<int> a):b(a){

    }
};

int main() 
{
    vector<int> v;
    v.push_back(1);
    Library a( my_forward<vector<int>>(v)); // &
    return 0;
}

Сценарий 4

#include <vector>
using namespace std;

class Library
{
    vector<int> b;
public:
    // &
    Library( vector<int> a):b(a){

    }
};

int main() 
{
    vector<int> v;
    v.push_back(1);
    Library a( my_forward<vector<int>>(std::move(v))); //&&
    return 0;
}

Вот резюме

1. Используется перегрузка 1, без нее вы получите ошибку компиляции
2. Используется перегрузка 2, без нее вы получите ошибку компиляции
3. Используется перегрузка 1, без нее вы получите ошибку компиляции
4. Используется перегрузка 2, без нее вы получите ошибку компиляции

Обратите внимание, что если мы не используем переадресацию

Library a( std::move(v));
//and
Library a( v);

ты получаешь:

1. Ошибка компиляции
2. Скомпилировать
3. Компиляция
4. Скомпилировать

Как видите, если вы используете только одну из двух перегрузок forward, вы в основном заставляете не компилировать 2 случая из 4, а если вы вообще не используете forward, вы можете скомпилировать только 3 случая из 4.

Этот ответ предназначен для ответа на комментарий @vsoftco

@DarioOO спасибо за ссылку. Можешь написать краткий ответ? Из вашего примера мне до сих пор не ясно, почему std::forward также должен быть определен для значений rvalue

Вкратце:

Потому что без специализации rvalue следующий код не скомпилировался бы

#include <utility>
#include <vector>
using namespace std;

class Library
{
    vector<int> b;
public:
    // hi! only rvalue here :)
    Library( vector<int>&& a):b(std::move(a)){

    }
};

int main() 
{
    vector<int> v;
    v.push_back(1);
    A a( forward<vector<int>>(v));
    return 0;
}

однако я не могу не напечатать больше, так что вот также не краткая версия ответа.

Длинная версия:

Вам нужно переместить v, потому что класс Library не имеет конструктора, принимающего к нему lvalue, а только ссылку на rvalue. Без идеальной переадресации мы оказались бы в нежелательном поведении:

функции-обертки могут привести к снижению производительности при передаче тяжелых объектов.

с семантикой перемещения мы гарантируем, что конструктор перемещения используется, ЕСЛИ ВОЗМОЖНО. В приведенном выше примере, если мы удалим std::forward, код не скомпилируется.

Так что же на самом деле делает forward? перемещение элемента без нашего согласия? Неа!

Он просто создает копию вектора и перемещает ее. Как мы можем быть в этом уверены? Просто попробуйте получить доступ к элементу.

vector<int> v;
v.push_back(1);
A a( forward<vector<int>>(v)); //what happens here? make a copy and move
std::cout<<v[0];     // OK! std::forward just "adapted" our vector

если вы вместо этого переместите этот элемент

vector<int> v;
v.push_back(1);
A a( std::move(v)); //what happens here? just moved
std::cout<<v[0];  // OUCH! out of bounds exception

Таким образом, эта перегрузка необходима, чтобы сделать возможным неявное преобразование, которое по-прежнему безопасно, но невозможно без перегрузки.

На самом деле следующий код просто не скомпилируется:

vector<int> v;
v.push_back(1);
A a( v); //try to copy, but not find a lvalue constructor

Реальный вариант использования:

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

template< typename Impl, typename... SmartPointers>
static std::shared_ptr<void> 
    instancesFactoryFunction( priv::Context * ctx){
        return std::static_pointer_cast<void>( std::make_shared<Impl>(

                std::forward< typename SmartPointers::pointerType>( 
            SmartPointers::resolve(ctx))... 
            )           );
}

Код был взят из моего фреймворка (строка 80): Infectorpp 2

Я смотрел на этот вопрос раньше, читал ссылку Говарда Хиннанта, не мог полностью понять ее после часа размышлений. Сейчас поискал и через пять минут получил ответ. (Редактировать: получил ответ слишком щедр, так как в ссылке Хиннанта был ответ. Я имел в виду, что понял и смог объяснить это более простым способом, который, надеюсь, кому-то покажется полезным).

По сути, это позволяет вам быть универсальным в определенных ситуациях в зависимости от переданного типа. Рассмотрим этот код:

#include <utility>
#include <vector>
#include <iostream>
using namespace std;

class GoodBye
{
  double b;
 public:
  GoodBye( double&& a):b(std::move(a)){ std::cerr << "move"; }
  GoodBye( const double& a):b(a){ std::cerr << "copy"; }
};

struct Hello {
  double m_x;

  double & get()  { return m_x; }
};

int main()
{
  Hello h;
  GoodBye a(std::forward<double>(std::move(h).get()));
  return 0;
}

Этот код печатает «перемещение». Что интересно, если я удалю std::forward, он напечатает копию. Для меня это трудно осознать, но давайте примем это и будем двигаться дальше. (Редактировать: я полагаю, это происходит потому, что get вернет ссылку lvalue на rvalue. Такой объект распадается на lvalue, но std::forward преобразует его в rvalue, как и при обычном использовании forward. Все еще кажется неинтуитивным хоть).

Теперь давайте представим другой класс:

struct Hello2 {
  double m_x;

  double & get() & { return m_x; }
  double && get() && { return std::move(m_x); }
};

Предположим, что в коде main h был экземпляром Hello2. Теперь нам больше не нужен std::forward, потому что вызов std::move(h).get() возвращает rvalue. Однако предположим, что код является общим:

template <class T>
void func(T && h) {
  GoodBye a(std::forward<double>(std::forward<T>(h).get()));
}

Теперь, когда мы вызываем func, мы хотим, чтобы он правильно работал как с Hello, так и с Hello2, то есть мы хотели бы инициировать перемещение. Это происходит только для rvalue Hello, если мы включаем внешнее std::forward, поэтому оно нам нужно. Но... Мы добрались до кульминации. Когда мы передаем rvalue Hello2 этой функции, перегрузка rvalue функции get() уже вернет rvalue double, поэтому std::forward фактически принимает rvalue. Поэтому, если бы это было не так, вы не смогли бы написать полностью общий код, как указано выше.

Проклятие.