erfassen member-variable durch den Wert

Wie würde ich fangen eine member-variable durch den Wert bei der Verwendung von C++11 lambda-Ausdrücke?

Mithilfe der [my_member] syntax scheint nicht zu funktionieren, und der impliziten capture verwendet die this Zeiger. Was wird brauchen, ist ein Weg, um explizit anzugeben, capture-Typ von member-Variablen. Ist das möglich?

Meine Abhilfe für jetzt ist:

void member_function()
{
    std::shared_ptr<my_member_class> my_member_copy = my_member; //this shouldn't be necessary
    std::async([=]{ std::cout << *my_member_copy; });
    //std::async([=]{ std::cout << *my_member_; }); //wrong, my member could be potentially out of scope
}
InformationsquelleAutor ronag | 2010-09-15
  1. 7

    Ich glaube nicht, dass Sie erfassen kann ein Mitglied durch den Wert, den Sie erfassen können this aber da das Mitglied ist Teil this werden Sie mit einem shared-member und nicht eine neue variable.

    Nicht zu wissen, welche Art Ihr Mitglied ist so etwas wie dies funktionieren sollte:

    auto copy = my_member;
std::async([copy]{ std::cout << copy; });

    Ich verstehe nicht, warum man mit einem shared_ptr in deinem Beispiel, wenn Sie aufnehmen möchten, indem Sie den Wert sicherlich shared_ptr ist die Letzte Sache, die Sie berücksichtigen sollten.

    • Ich brauche, um zu erfassen, durch den Wert inorder für den shared_ptr-ref-Anzahl erhöht werden. Andernfalls wird das Objekt zerstört werden, wenn das parent-Objekt zerstört wird, wodurch eine mögliche Zugriffsverletzung in der asynchronen operation. (vergessen * in die lambda-Wert). Ich sehe nicht, wie Sie Beispiel unterscheidet sich von meinem.
    • "Nicht zu wissen, welche Art Ihr Mitglied ist so etwas wie dies funktionieren sollte:" der Grund, warum ich schrieb, std::shared_ptr statt auto wurde explizit über die Art der "my_member", das ist shared_ptr<my_member_class>.
    InformationsquelleAutor Motti
  2. 5

    Leider, ich glaube nicht, dass es ein straight-forward Weg, dies zu tun, aber ich denke, der kann ein paar Möglichkeiten, zu erfassen, Mitglied, ohne dass eine zusätzliche Kopie.

    Die erste option ist ähnlich wie dein Beispiel verwendet aber eine Referenz für die lokale variable:

    void member_function()
{
   std::shared_ptr<my_member_class> &my_member_ref = my_member;
   //Copied by the lambda capture
   std::async([my_member_ref]{ std::cout << *my_member_ref; });
}

    Beachten Sie, dass es ein bug in der pre 4.6.2 Versionen von GCC, die verursachen, dass der Wert nicht kopiert werden. Sehen Erfassung von Referenz-Variablen kopieren in C++0x-lambda.

    Ein zweiter Ansatz wäre die Verwendung von bind zu machen, die Kopie:

    void member_function()
{
   //Copied by std::bind
   std::async(std::bind([](const shared_ptr<my_member_class>& my_member){
      std::cout << *my_member; }, my_member));
}

    In diesem Beispiel, binden seine eigene Kopie my_member, und diese Kopie wird dann an den lambda-Ausdruck durch einen Verweis.

    • Keine der beiden Beispiele unterscheiden sich von meinem Beispiel.
    • Der wesentliche Unterschied zwischen meinem Beispiel und deinem workaround ist, dass meine Beispiele nicht machen Sie eine Kopie von my_member. Meinem ersten Beispiel nur bindet, die Mitglied einer lokalen Referenz, so dass es eingefangen werden, indem der Wert in der lambda-capture, ohne zuerst kopiert. Mein zweites Beispiel war ein Weg, um zu vermeiden die Notwendigkeit für die Verwendung einer lokalen variable, die alle zusammen, mit binden zu erfassen my_member Wert-statt der lambda-capture.
    • rkjnsn Recht hat, seinem Beispiel speichert die Inkrement - /Dekrement - /pointer-Kopie beim Bau my_member_copy und sollte damit auch schneller. Warum würden Sie downvote seine Antwort?
    • Ich kann mir nicht vorstellen, alle modernen compiler, der würde nicht entfernen Sie die unnötige Kopie.
    • Sind Sie sicher? shared_ptr ist nicht so einfach, seine Kopie-Konstruktor hat den Nebeneffekt das Inkrementieren eines Zählers in eine thread-sichere Art und Weise implementiert wird, die auf die meisten (alle?) Plattformen mit atomics. Ich würde nicht Wetten, die optimiert werden können entfernt.
    • Ja, ich bin sicher. Der compiler erlaubt, führen Sie copy-elision auf jeder Kopie, die Zuordnung/Bau Betrieb, unabhängig von seiner Umsetzung, z.B. auch wenn Sie eine printf-Anweisung (oder eine andere Seite-Effekt) in der Kopie der Implementierung durch den compiler durchführen, copy-elision.
    • Siehe §12.8 .31 in n3337: "Wenn bestimmte Kriterien erfüllt sind, ist eine implementation erlaubt das weglassen der kopieren/verschieben-Bau ein class-Objekt, , selbst wenn der copy/move-Konstruktor und/oder Destruktor für das Objekt Nebenwirkungen haben. In solchen Fällen wird die Umsetzung behandelt, die Quelle und das Ziel der ausgelassenen kopieren/verschieben-Vorgang einfach als zwei verschiedene Arten, auf dasselbe Objekt verweisen, und die Vernichtung des Objekts, tritt in den späteren Zeiten, wenn die beiden Objekte wäre zerstört gewesen, ohne den-Optimierung".
    • Ja, ich weiß, über copy elision, aber deren Kriterien nicht erfüllt sind, in diesem Fall, da die Quellen der beiden Kopien sind keine Provisorien: 1) my_member ist nicht eine vorübergehende, wenn Bau my_member_copy 2) my_member_copy ist nicht eine vorübergehende bei der Konstruktion der lambda.

    InformationsquelleAutor rkjnsn
  3. 4

    Da Ihre Frage über C++11 ist das nicht wirklich eine Antwort, aber in C++14, die Sie tun können, wie diese:

    void member_function()
{
    std::async([my_member=my_member]{ std::cout << *my_member; });
}

    Es tut die gleiche Sache wie Sie Ihre eigene "work-around" (wenn my_member ist ein shared_ptr).

    InformationsquelleAutor Jakob Schou Jensen
  4. 1
    auto& copy = my_member;
std::async([copy]{ std::cout << copy; });

    auto& (oben) funktioniert auch und beugt kopieren zweimal. Obwohl dieser Ansatz ist mehr syntax als vorbei [diese], es entfällt die übergabe in die Schließung einer Abhängigkeit, die auf das Objekt [das] Punkte zu.

    • Dies funktioniert tatsächlich und ich doppelt überprüft es nicht wirklich erfassen, durch kopieren und nicht durch Referenz. Danke!
    InformationsquelleAutor c4augustus
  5. -1

    Rechts nun, ich Stand vor dem gleichen problem und löste es selbst:

    1. Erfassen die this Zeiger.
    2. dann schreiben this->member syntax innerhalb der lambda:

    Ist,

     std::async([this]{ std::cout << this->my_member_; } ); 
 //         ^^^^                ^^^^^^ use this syntax
 //          | 
 //          ^
 //          capture `this` as well

    Es funktioniert für mich. Ich hoffe, es sollte auch für Sie arbeiten. Allerdings bin ich nicht ganz zufrieden mit dieser Erkenntnis. Nach meiner Arbeit werde ich für den Grund, warum diese syntax erforderlich ist, oder es ist ein compiler-bug. Ich bin mit GCC 4.5.0 (MinGW).

    Gut, fand ich das folgende Thema, das sagt this Zeiger sollten erfasst werden, um die member der Klasse.

    • Aber dieser fängt "das" nicht das eigentliche member-variable ist, also wenn "das" gelöscht wird, dann wird es zu undefiniertem Verhalten.
    InformationsquelleAutor Nawaz
Schreibe einen Kommentar