Domanda Posso tipicamente / usare sempre std :: forward invece di std :: move?


Ho guardato Scott Meyers ' parlare di riferimenti universali dalla conferenza C ++ e Beyond 2012, e tutto ha un senso fino ad ora. Tuttavia, un membro del pubblico pone una domanda a circa 50 minuti in cui mi stavo anche chiedendo. Meyers dice che non gli interessa la risposta perché è non idiomatica e sarebbe stupida nella sua mente, ma io sono ancora interessato.

Il codice presentato è il seguente:

// Typical function bodies with overloading:
void doWork(const Widget& param)   // copy
{
  // ops and exprs using param
}
void doWork(Widget&& param)        // move
{
  // ops and exprs using std::move(param)
}

// Typical function implementations with universal reference:
template <typename T>
void doWork(T&& param)             // forward => copy and move
{
  // ops and exprs using std::forward<T>(param)
}

Il punto è che quando prendiamo un riferimento di rvalue, sappiamo che abbiamo un valore, quindi dovremmo std::move per preservare il fatto che è un valore. Quando prendiamo un riferimento universale (T&&, dove T è un tipo dedotto), vogliamo std::forward per preservare il fatto che potrebbe essere stato un lvalue o un valore.

Quindi la domanda è: da allora std::forward preserva se il valore passato nella funzione era o un lvalue o un valore di rvalore, e std::move semplicemente getta la sua argomentazione su un valore, potremmo semplicemente usarla std::forward ovunque? Voluto std::forward comportarsi come std::move in tutti i casi in cui dovremmo usare std::moveo ci sono delle differenze importanti nel comportamento che sono state ignorate dalla generalizzazione della Meyers?

Non sto suggerendo che qualcuno dovrebbe farlo perché, come dice correttamente Meyers, è completamente non idiomatico, ma è anche il seguente uso valido di std::move:

void doWork(Widget&& param)         // move
{
  // ops and exprs using std::forward<Widget>(param)
}

61
2017-11-04 14:40


origine


risposte:


I due sono molto diversi e complementare utensili.

  • std::move  deduce l'argomento e crea incondizionatamente un'espressione di valore. Questo ha senso applicare a un oggetto o una variabile reale.

  • std::forward prende un argomento template obbligatorio (devi specificarlo!) e crea magicamente un riferimento lvalue o un'espressione rvalue a seconda del tipo (in virtù dell'aggiunta && e le regole collassanti). Questo ha senso solo applicare a un argomento di funzione dedotto, basato su modelli.

Forse i seguenti esempi illustrano questo un po 'meglio:

#include <utility>
#include <memory>
#include <vector>
#include "foo.hpp"

std::vector<std::unique_ptr<Foo>> v;

template <typename T, typename ...Args>
std::unique_ptr<T> make_unique(Args &&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));  // #1
}

int main()
{
    {
        std::unique_ptr<Foo> p(new Foo('a', true, Bar(1,2,3)));
        v.push_back(std::move(p));                                  // #2
    }

    {
        v.push_back(make_unique<Foo>('b', false, Bar(5,6,7)));      // #3
    }

    {
        Bar b(4,5,6);
        char c = 'x';
        v.push_back(make_unique<Foo>(c, b.ready(), b));             // #4
    }
}

Nella situazione n. 2, abbiamo un oggetto concreto esistente pe vogliamo spostarci da esso, incondizionatamente. Solo std::move ha senso. Non c'è niente da "inoltrare" qui. Abbiamo una variabile con nome e vogliamo spostarci da essa.

D'altra parte, la situazione # 1 accetta un elenco di qualsiasi tipo di argomenti, e ogni argomento deve essere inoltrato come la stessa categoria di valore che aveva nella chiamata originale. Ad esempio, in # 3 gli argomenti sono espressioni temporanee e quindi verranno inoltrati come valori rvalori. Ma potremmo anche averli mescolati in oggetti con nome nella chiamata del costruttore, come nella situazione # 4, e quindi abbiamo bisogno di inoltro come lvalue.


67
2017-11-04 14:55



Si se param è un Widget&&, quindi le tre espressioni seguenti sono equivalenti (supponendo che Widget non è un tipo di riferimento):

std::move(param)
std::forward<Widget>(param)
static_cast<Widget&&>(param)

In generale (quando Widget può essere un riferimento), std::move(param) è equivalente a entrambe le seguenti espressioni:

std::forward<std::remove_reference<Widget>::type>(param)
static_cast<std::remove_reference<Widget>::type&&>(param)

Nota quanto è più bello std::move è per spostare le cose. Il punto di std::forwardè che si mescola bene con le regole di deduzione del tipo di modello:

template<typename T>
void foo(T&& t) {
    std::forward<T>(t);
    std::move(t);
}

int main() {
    int a{};
    int const b{};
               //Deduced T   Signature    Result of `forward<T>` Result of `move`
    foo(a);    //int&        foo(int&)       lvalue int          xvalue int
    foo(b);    //int const&  foo(int const&) lvalue int const    xvalue int const
    foo(int{});//int         foo(int&&)      xvalue int          xvalue int
}

14
2017-11-04 14:55