Il mio modello generico dovrebbe usare T o T &&?

Question

Sto lavorando in un file che ha una determinata funzione con molti sovraccarichi, in questo modo:

inline X f(ScriptWrappable* impl, Y y, Z z) { ... } 
inline X f(Node* impl, Y y, Z z) { ... } 
inline X f(RawPtr<T> impl, Y y, Z z) { ... } 
inline X f(const RefPtr<T>& impl, Y y, Z z) { ... } 
inline X f(ScriptWrappable* impl, Y y, Z z) { ... } 
inline X f(const String& impl, Y y, Z z) { ... } 
inline X f(int64_t impl, Y y, Z z) { ... } 
template<typename T, size_t capacity> inline X f(const Vector<T, capacity>& impl, Y y, Z z) { ... } 

Sto cercando di aggiungere un nuovo sovraccarico che richiede solo un parametro, in questo modo:

template<typename T> inline X f(T impl, W w) { 
    return f(impl, w->getY(), w->getZ()); 
} 

Uso i modelli in modo che tutte le varianti sopra descritte funzionino automaticamente con la mia nuova versione a due parametri.

Tuttavia, durante la revisione del codice mi è stato chiesto, "È T&& migliore per evitare la copia?". Cioè, dovrei invece fare

template<typename T> inline X f(T&& impl, W w) { 
    return f(impl, w->getY(), w->getZ()); 
} 

Non so davvero la risposta a questa domanda. Pensavo di aver capito riferimenti universali, ma non mi è familiare quando sono una buona idea o no. Quali sarebbero le conseguenze nella mia situazione di scegliere l'una rispetto all'altra?

Se dovessi tirare a indovinare, direi che dal momento che i tipi originali che T può sostituire sono tutti semplici da copiare (primitive, riferimenti, o puntatori) T & & non darà molto beneficio. Ma sono ancora curioso se ad es. qualsiasi tipo potrebbe essere passato alla versione T & & che non è stato possibile passare alla versione T o viceversa.

Answer 1

si dovrebbe scrivere il funzione come questa:

template<typename T> inline X f(T&& impl, W w) { 
    return f(std::forward<T>(impl), w->getY(), w->getZ()); 
} 

Questo si chiama l'inoltro perfetto. Il tipo di impl sarà esattamente lo stesso come se avessi chiamato direttamente f. Sarà non necessariamente un riferimento di valore r.

Answer 2

La risposta è un po 'complessa perché richiede una certa comprensione delle regole del compilatore relative ai modelli.

Nella seguente dichiarazione:

template<class T> void func(T&& t); 

T viene valutata in dedotta contesto e di conseguenza saranno trattati dal compilatore sia come riferimento r-valore o un riferimento l-value, qualunque sia il caso. Accoppiato con l'uso di std::forward (nota: in questo caso nonstd::move) ciò si traduce in un perfetto inoltro ed è ottimamente efficiente.

Tuttavia, questo non è stato valutato in context dedotta:

template<class T> 
struct X { 
    void foo(T&& t); 
}; 

In questo caso, foo è infatti chiedere un riferimento r-value.

Né è questo contesto dedotto:

template<class T> 
void foo(std::vector<T>&& v); 

In questi due casi, è necessario utilizzare std::move.