Има ли случаи на употреба за 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. Използва се Overload 1, без него получавате грешка при компилация
2. Използва се Overload 2, без него получавате грешка при компилиране
3. Използва се Overload 1, без него получавате грешка при компилация
4. Използва се Overload 2, без него получавате грешка при компилиране

Имайте предвид, че ако не използваме напред

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

Вие получавате:

1. Грешка при компилиране
2. Компилиране
3. Компилирайте
4. Компилиране

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

Този отговор е за отговор на коментар от @vsoftco

@DarioOO благодаря за връзката. Може ли да напишете кратък отговор? От вашия пример все още не ми е ясно защо std::forward също трябва да бъде дефиниран за rvalues

Накратко:

Тъй като без специализация на 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

В този случай аргументите се препращат от извикване на функция. Върнатите стойности на SmartPointers::resolve се преместват правилно, независимо от факта, че конструкторът на Impl приема rvalue или lvalue (така че няма грешки при компилиране и те така или иначе се преместват).

По принцип можете да използвате std::foward във всеки случай, в който искате да направите кода по-прост и по-четлив, но трябва да имате предвид 2 точки

• допълнително време за компилиране (не толкова много в действителност)
• може да причини нежелани копия (когато не преместите изрично нещо в нещо, което изисква rvalue)

Ако се използва внимателно, е мощен инструмент.

Взирах се в този въпрос преди, прочетох връзката на Хауърд Хинант, не можах да го разбера напълно след час мислене. Сега търсих и получих отговора след пет минути. (Редактиране: полученият отговор е твърде щедър, тъй като връзката на Hinnant съдържаше отговора. Исках да кажа, че разбрах и успях да го обясня по по-прост начин, който се надявам някой да намери за полезен).

По принцип това ви позволява да бъдете общи в определени видове ситуации в зависимост от въведеното, което е предадено. Помислете за този код:

#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. Така че, ако не беше, нямаше да можете да напишете напълно общ код, както по-горе.

по дяволите