Dies scheint die aktuellste Frage zu sein, die bereits gestellt wurde.

Was ist der Unterschied zwischen std :: move und std :: forward

Aber jede Antwort ist anders und trifft zu und sagt etwas andere Dinge. Also bin ich verwirrt.

Ich habe die folgende Situation.

Element in Container kopieren
The Copy item is C ++ 03, also verstehe ich das ganz gut.Element in Container konstruieren
Das Element in Container konstruieren verwendet meiner Meinung nach die perfekte Weiterleitung, um die Argumente über zwei Funktionen an den Konstruktor von T in @ weiterzuleiteemplaceBackInternal() (Bitte sagen Sie etwas anderes, wenn ich falsch liege). Artikel in Container verschieben
Mein Problem scheint zu verstehen, wie ein Gegenstand in den Container verschoben wird.

Der Code

template<typename T>
class Container
{
    std::size_t length;
    T*          buffer;

public:
    void push_back(T const& value)
    {
         resizeIfRequired();
         pushBackInternal(value);
    }
    template<typename... Args>
    void emplace_back(Args&&... args)
    {
         resizeIfRequired();
         emplaceBackInternal(std::forward<T>(arg)...);
    }
    void push_back(T&& value)
    {
         resizeIfRequired();
         // Is this forward correct or should it be move
         moveBackInternal(std::forward<T>(value));
    }
private:
    void pushBackInternal(T const& value)
    {
         // Copy construct object into buffer;
         new (buffer + length) T(value);
         ++length;
    }
    template<typename... Args)
    void emplaceBackInternal(Args&&... args)
    {
         // Construct object into buffer using arguments;
         new (buffer + length) T(std::forward<T>(args)...);
         ++length;
    }
    void moveBackInternal(T&& value)
    {
         // Move construct object into buffer;
         // Is this forward correct or should it be move
         new (buffer + length) T(std::forward<T>(value));
         ++length;
    }
};

Ich beziehe alle drei hier ein, um die drei Funktionen mit den Antworten in der oben genannten Antwort zu vergleichen. Der Hauptgrund ist, dassmove undconstruct sieht so ähnlich aus, dass es sich anfühlt, als müssten sie gleich sein.

Answer @Potatoswatter Score 67

std :: forward hat einen einzigen Anwendungsfall: das Wirken einestemplated Funktionsparameter

urch diese Definition sollte ich @ verwendstd::move Innerhalbpush_back(T&& value) undmoveBackInternal(T&& value), da der Wert kein Vorlagenparameter für die Funktion ist.

Answer @Howard Hinnant Punktzahl 38

Wenn Y eine lWert-Referenz ist, ist das Ergebnis ein lWert-Ausdruck.Wenn Y keine lWertreferenz ist, ist das Ergebnis ein rWert (xvalue um genau zu sein) Ausdruck.

Scheint nach dieser Definition kann ich entwederstd::move oderstd::forward.

Answer @Bo Persson Punktzahl 11

it @std :: forward wird ein Parameter genau so weitergeleitet, wie er an eine Funktion übergeben wurde.

Scheint zu sagen, dassstd::forward ist akzeptabel (wenn ich dem Link in der Antwort folge, werden in allen Beispielen Vorlagenfunktionen verwendet).