Erfassung durch universelle Referenz

Question

Wenn ein abgeleitetes Typ als r-Referenzwert vorbei erhalte ich universelle Funktionalität Referenz und kann perfekt Weiterleitung wie folgt archieve:

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

... aufgrund der Art und Weise T abgeleitet wird, und dem Standard des Regeln zum Kollabieren von Referenzen

Betrachten wir nun other_func ein Funktionsobjekt nimmt

template <typename T> 
void func(T&& t) { 
    other_func([](int v) { return t + v; }); // I chose addition for example purposes 
} 

Jetzt offensichtlich wird dies aufgrund t nicht erfasst wird, nicht kompilieren. Meine Frage ist: Wie erfasse ich es, so dass der erfasste Wert ist, was auch immer T abgeleitet wird?

Ist dies mit den neuen generischen Lambda-Captures möglich? Und wenn ... wie?

[t = std::forward<T>(t)] ? 

ich wirklich noch nicht, die Mechanik der neuen Capture initializers bekommen ...

Answer 1

Sie können "Capture durch Universal-Referenz" in C++ 11, da die Art der Template-Parameter T auf die Lambda-Funktion verfügbar ist (hideous live code example at Coliru):

template <typename T> 
void func(T&& t) { 
    other_func([&t](int v) { 
    return std::forward<T>(t) + v; 
    }); 
} 

Answer 2

Okay, lassen Sie uns dies versuchen. Leider habe ich keinen Compiler, der diese Funktion unterstützt, also vergib mir, wenn ich die Dinge falsch interpretiere.

Der Vorschlag hierzu lautet N3648.

Der interessante Teil ist, dass die Art der Variablen in den init-Capture abgeleitet wird, als ob auto mit:

Die Art dieses Elements entspricht den Typen einer hypothetischen Variablendeklaration des Formulars "automatische Init-Aufnahme;" [...].

So ist die Frage, was man von einem Capture-Liste erhalten, ist [c = std::forward<T>(t)] entspricht dem, was man von einer Erklärung auto c = std::forward<T>(t) bekommen.

Der abgeleitete Typ ist hier std::remove_reference<T>::type (Referenzqualifikatoren werden von auto gelöscht), so dass Sie hier immer mit einem neuen Wert enden. Wenn t eine Rvalue-Referenz ist, werden Sie den neuen Wert move-construct, andernfalls werden Sie (aufgrund des Rückgabewerts std::forward) kopieren.

Die gute Sache ist, dass dieser neue Wert im Besitz des Lambda ist. Also, egal was t Sie zunächst übergeben, ist es sicher std::move von der erfassten c. Auch wenn Sie den Typ der ursprünglichen t nicht mehr kennen, haben Sie auf dem Weg noch nichts verloren.

Answer 3

Um das gewünschte Verhalten zu erreichen mit Erfassung durch Bezugnahme eingeschlossen, keine generische Lambda Erfassung von 14 ++ C erforderlich ist (aber wie immer mit Fänger Bezug genommen wird, ist Vorsicht geboten keinen baumelnden Verweis zu erstellen):

template <typename T> 
void func(T&& t) { 
    other_func([&t](int v) { return std::forward<T>(t) + v; }); 
} 

im Gegenteil, wenn die Entscheidung gemacht zu verwenden c Apture nach Wert, sollte das Lambda als wandelbar markiert werden, die wirksam in Bewegung zu ermöglichen (weil ein const Qualifier implizit lambdas hinzugefügt wird):

template <typename T> 
void func(T&& t) { 
    other_func([t = std::forward<T>(t)](int v) mutable { return std::move(t) + v; }); 
}