Perché non usare sempre std :: forward?

Question

La distinzione tra std::move e std::forward è ben nota, usiamo quest'ultima per conservare la categoria di valore di un oggetto inoltrato e la prima per eseguire il cast di riferimento di rvalue per abilitare la semantica del movimento.

In efficace moderna C++, esiste una linea guida che gli Stati

uso std::move su riferimenti rvalue, std::forward su riferimenti universali.

Eppure, nello scenario seguente (e scenari in cui non vogliamo cambiare categoria valore),

template <class T> 
void f(vector<T>&& a) 
{ 
    some_func(std::move(a)); 
} 

dove a non è un riferimento di inoltro, ma un semplice riferimento rvalue, wouldn' t essere esattamente lo stesso per fare quanto segue?

template <class T> 
void f(vector<T>&& a) 
{ 
    some_func(std::forward<decltype(a)>(a)); 
} 

Da questa può essere facilmente incapsulata in una macro come questa,

#define FWD(arg) std::forward<decltype(arg)>(arg) 

non è conveniente utilizzare sempre questa macro definizione in questo modo?

void f(vector<T>&& a) 
{ 
    some_func(FWD(a)); 
} 

Non sono i due modi di scrivere questo esattamente equivalente?

Answer 1

Eh. Discutibile. Nel tuo particolare esempio è equivalente. Ma non vorrei diventare un'abitudine. Una ragione è perché vuoi una distinzione semantica tra l'inoltro e lo spostamento. Un altro motivo è che per avere un'API coerente dovresti avere MOV oltre a FWD, e che sembra davvero male e non fa nulla. Ancora più importante, però, è che il tuo codice può fallire in modo imprevisto.

Si consideri il seguente codice:

#include <iostream> 

using namespace std; 

#define FWD(arg) std::forward<decltype(arg)>(arg) 

struct S { 
    S() { cout << "S()\n"; } 
    S(const S&) { cout << "S(const S&)\n"; } 
    S(S&&) { cout << "S(S&&)\n"; } 
}; 

void some_func(S) {} 

void f(S&& s) 
{ 
    some_func(FWD(s)); 
} 

int main() 
{ 
    f(S{}); 
} 

Questo stampa

S()
S (S & &)

Tuttavia, se mi limito a cambiare il FWD linea per avere un'altra coppia (apparentemente opzionale) di parent eses, in questo modo:

void f(S&& s) 
{ 
    some_func(FWD((s))); 
} 

Ora arriviamo

S()
S (const S &)

E questo perché ora stiamo usando decltype su un espressione, che valuta un riferimento lvalue.