„Wenn ein Arbeiter seine Arbeit gut machen will, muss er zuerst seine Werkzeuge schärfen.“ – Konfuzius, „Die Gespräche des Konfuzius. Lu Linggong“
Titelseite > Programmierung > Tipps für mobile Erfassung von Implementierung in C ++ Lambda

Tipps für mobile Erfassung von Implementierung in C ++ Lambda

Gepostet am 2025-04-12
Durchsuche:203

How to Implement Move Capture in C   Lambdas?

std :: Unique_ptr myPointer (new int); std :: function Beispiel = [std :: move (myPointer)] { *myPointer = 4; };

antworten:

verallgemeinerte Lambda -Erfassung in c 14
std::unique_ptr myPointer(new int);

std::function example = [std::move(myPointer)] {
   *myPointer = 4;
};

in c 14, generalisierte Lambda -Erfassung erlaubt die Verschaffung. Dieser Code ist jetzt gültig: Verwenden von Namespace std; auto u = make_unique (einige, Parameter); go.run ([u = move (u)] {do_something_with (u);});

, um Objekte von einer Lambda in eine andere Funktion zu bewegen, die Lambda mutable zu machen: go.run ([u = move (u)] mutable {do_Something_With (Std :: Move (u));}); 11

Eine Helferfunktion, make_rref, kann die Schaltungsfestigkeit erleichtern. Die Implementierung lautet wie folgt:
std::unique_ptr myPointer(new int);

std::function example = [std::move(myPointer)] {
   *myPointer = 4;
};
#include #Include #include Vorlage Struktur rref_impl { rref_impl () = delete; rref_impl (t && x): x {std :: move (x)} {} rref_impl (rref_impl & other) : x {std :: move (other.x)}, iscopied {true} { assert (andere.iscoopd == false); } rref_impl (rref_impl && andere) : x {std :: move (other.x)}, iscopied {std :: move (other.iscopied)} { } rref_impl & operator = (rref_impl other) = delete; T & Operator && () { return std :: move (x); } Privat: T x; bool iscopied = false; }; Vorlage rref_impl make_rref (t && x) { return rref_impl {std :: move (x)}; }

ein Testfall für make_rref:
std::unique_ptr myPointer(new int);

std::function example = [std::move(myPointer)] {
   *myPointer = 4;
};
int main () { std :: Unique_ptr p {new int (0)}; auto rref = make_rref (std :: move (p)); Auto Lambda = [rref] () Mutable -> std :: Unique_ptr {return rref.move (); }; Assert (lambda ()); Assert (! lambda ()); }

emulieren verallgemeinerte Lambda -Capture in c 11

Ein weiterer Workaround wird von der facting () function () function:
std::unique_ptr myPointer(new int);

std::function example = [std::move(myPointer)] {
   *myPointer = 4;
};
#include bereitgestellt #Include int main () { std :: Unique_ptr p {new int (0)}; Auto Lambda = Capture (std :: move (p), [] (std :: Unique_ptr & p) {return std :: move (p); }); Assert (lambda ()); Assert (! lambda ()); }

Die Erfassung wird wie folgt implementiert:
std::unique_ptr myPointer(new int);

std::function example = [std::move(myPointer)] {
   *myPointer = 4;
};
#include Vorlage Klasse capture_impl { T x; F f; öffentlich: capture_impl (t && x, f && f) : x {std :: vorwärts (x)}, f {std :: vorwärts (f)} {} Vorlage Auto Operator () (TS && ... Args) -> decentPe (f (x, std :: vorwärts (args) ...)) { return f (x, std :: vorne (args) ...); } Vorlage Auto Operator () (ts && ... args) const -> decentPe (f (x, std :: vorwärts (args) ...)) { return f (x, std :: vorne (args) ...); } }; Vorlage capture_impl capture (t && x, f && f) { return capture_impl ( std :: vorne (x), std :: vorwärts (f)); }

Diese Lösung verhindert das Kopieren der Lambda, wenn der erfasste Typ nicht kopiert werden kann, wobei die Laufzeitfehler vermieden werden.

Neuestes Tutorial Mehr>

Haftungsausschluss: Alle bereitgestellten Ressourcen stammen teilweise aus dem Internet. Wenn eine Verletzung Ihres Urheberrechts oder anderer Rechte und Interessen vorliegt, erläutern Sie bitte die detaillierten Gründe und legen Sie einen Nachweis des Urheberrechts oder Ihrer Rechte und Interessen vor und senden Sie ihn dann an die E-Mail-Adresse: [email protected] Wir werden die Angelegenheit so schnell wie möglich für Sie erledigen.

Copyright© 2022 湘ICP备2022001581号-3