C++: Verwirrung über Weiterleitung Referenz

Question

Ich lese this (unglaublich gut geschrieben) Artikel über Forwarding Referenz in C++ 11 von Scott Meyers.

Nun konzentrieren sich auf diesem Teil des Artikels:

template <class... Args> 
void emplace_back(Args&&... args); // deduced parameter types ⇒ type deduction; 
...        // && ≡ universal references 

Also, im Gegensatz zu anderen Fällen, die Ellipsen machen nicht die && rvalue Referenz, aber es ist noch universal Referenzen.

Von dem, was ich verstanden habe, wenn wir universelle Referenzen haben wir die Funktion sowohl rvalue anrufen und lvalues ​​vorbei (wow, so cool)

Jetzt habe ich diese Funktion implementiert:

template <typename ReturnType, typename... Args> 
ReturnType callFunction(MemFunc<ReturnType, Args...> memFunc, Args&& ... args) { ... 

Also (&&) (die gleiche Logik des vorherigen Beispiels verwendend) bedeutet Weiterleitungsreferenzen.

Aber wenn ich versuche, diesen Anruf zu machen:

typedef vector<double> vecD; 
vecD vec; 
mem.callFunction<vecD, vecD>(sortFunc, vec); 

Der Compiler mit You cannot bind an lvalue to an rvalue reference

beschweren wird, warum dies geschieht?

der gesamte Code:

#include <functional> 
#include <vector> 

using namespace std; 
struct MultiMemoizator { 
    template <typename ReturnType, typename... Args> 
    ReturnType callFunction(std::function<ReturnType(Args...)> memFunc, Args&&... args) { 

    } 
}; 

typedef vector<double> vecD; 

vecD sort_vec (vecD const& vec) { 
    return vec; 
} 

int main() 
{ 
    vecD vec; 
    std::function<vecD(vecD)> sortFunc(sort_vec); 
    MultiMemoizator mem; 
    mem.callFunction<vecD, vecD>(sortFunc, vec); 
} 

Answer 1

Also zunächst einmal, bitte auf die "Forwarding Referenz" anstelle von "Universal-Referenz" verwenden. Es repräsentiert besser, was es ist und was es beabsichtigt ist.

Das erste, was zu beachten ist, dass nicht jede && eine Weiterleitungsreferenz ist. Es kann auch eine rvalue-Referenz sein.

Vereinfachen T&& ist eine Speditions Referenz, wenn und nur wenn:

• T ist eine einfache (einfach wie unten gezeigt) geben (so zum Beispiel vector<int>&& oder vector<T>&& ist nicht eine Weiterleitung Referenz).
• und T wird abgeleitet.

In Ihrem Beispiel Args ist nicht abgeleitet.Das ist, weil Sie explizit die Funktion Template-Argument Args angeben, wenn Sie es nennen:

mem.callFunction<vecD, vecD>(sortFunc, vec); 
         ^~~~ 

---

Lassen Sie uns die Arbeit mit etwas einfacher, besser zu verstehen:

Lässt die Szene ein:

struct X {}; 

template <class T> 
auto foo(T&& p) {} 

In den nächsten 2 Aufrufen haben wir Forwarding-Referenzen:

X x; 
foo(x); 

foo(X{}); 

Im ersten T wird als X& und durch Kollabieren Regeln abgeleitet werden: X& &&X& wird, deshalb haben wir eine lvalue Referenz. Wie Sie es erwarten würden.

Im zweiten T wird als X und durch Kollabieren Regeln abgeleitet werden X &&X&& wird, deshalb haben wir eine rvalue Referenz.

Aber wenn man es so nennen:

foo<X>(x); 

T nicht mehr abgeleitet. Du sagst grundsätzlich T sei X. Also, wenn T ist X dann T && ist X&&, und Sie haben den Fehler: dessen Typ ist jetzt X&& kann nicht an einen Lvalue binden.

---

Holt auch hinzugefügt:

Also note that because of the declaration of sortFunc, this would not work even if you did not specify the function template arguments explicitely.

Ich neige dazu, mit ihm einverstanden, aber ich müsste weiter untersuchen sicher davon sein.