Warum ist "std::move` mit dem Namen `std::move"?

Es ist richtig, dass std::move(x) ist nur ein cast auf rvalue - genauer gesagt zu einer xvalue, im Gegensatz zu einer prvalue. Und es ist auch wahr, dass ein Darsteller namens move Leute manchmal verwirrt. Aber der Sinn dieser Benennung ist nicht zu verwechseln, aber eher, um Ihren code lesbarer zu gestalten.

Die Geschichte der move stammt die ursprüngliche bewegen Vorschlag 2002. Dieses Papier stellt zunächst die rvalue-Referenz und zeigt dann, wie zu schreiben, ein effizienter std::swap:

template <class T>
void
swap(T& a, T& b)
{
    T tmp(static_cast<T&&>(a));
    a = static_cast<T&&>(b);
    b = static_cast<T&&>(tmp);
}

Muss man daran erinnern, dass an diesem Punkt in der Geschichte, das einzige, was "&&" könnte möglicherweise bedeuten, war logische und. Niemand war vertraut mit rvalue-Referenzen, noch die Auswirkungen von casting-ein lvalue auf einen rvalue (die zwar nicht, eine Kopie als static_cast<T>(t) tun würde). Damit die Leser dieser code würde natürlich denken:

Weiß ich, wie swap funktionieren soll (Kopie vorübergehend und dann tauschen die Werte), aber was ist der Zweck dieser hässliche casts?!

Beachten Sie auch, dass swap ist eigentlich nur ein stand-in für alle Arten von permutations-algorithmen ändern. Diese Diskussion ist viel, viel größer als swap.

Dann der Vorschlag syntax-Zucker ersetzt static_cast<T&&> mit etwas mehr lesbar vermittelt nicht das genaue was, sondern die warum:

template <class T>
void
swap(T& a, T& b)
{
    T tmp(move(a));
    a = move(b);
    b = move(tmp);
}

I. e. move ist nur syntax sugar für static_cast<T&&>, und nun der code ist ziemlich suggestiv, warum diese Modelle gibt es: damit die move-Semantik!

Muss man verstehen, dass im Kontext von Geschichte, die nur wenige Menschen zu diesem Zeitpunkt wirklich verstanden, die intime Verbindung zwischen rvalues und move-Semantik (obwohl das Papier versucht zu erklären, dass, wie auch):

Move-Semantik wird automatisch ins Spiel kommen, wenn gegeben rvalue
Argumente. Dies ist vollkommen sicher, da das verschieben von Ressourcen von einem
rvalue kann nicht wahrgenommen werden, der rest des Programms (die sonst niemand hat
ein Verweis auf die rvalue um zu erkennen ob ein Unterschied).

Wenn zu der Zeit swap war stattdessen stellte wie diese:

template <class T>
void
swap(T& a, T& b)
{
    T tmp(cast_to_rvalue(a));
    a = cast_to_rvalue(b);
    b = cast_to_rvalue(tmp);
}

Dann müssten die Leute angeschaut und gesagt:

Aber warum sind Sie Gießen zu rvalue?

---

Der wichtigste Punkt:

Wie es war, mit move, niemand hat jemals gefragt:

Aber warum bewegen Sie sich?

---

Als die Jahre ging auf und der Vorschlag wurde verfeinert, die Vorstellungen von lvalue und rvalue wurde verfeinert, in die Wert Kategorien, die wir heute haben:

(Bild schamlos geklaut von dirkgently)

Und so auch heute, wenn wir wollten swap genau sagen was es tut, anstatt warum, es sollte Aussehen wie:

template <class T>
void
swap(T& a, T& b)
{
    T tmp(set_value_category_to_xvalue(a));
    a = set_value_category_to_xvalue(b);
    b = set_value_category_to_xvalue(tmp);
}

Und die Frage sollte jeder sich Fragen wird, wenn der obige code ist mehr oder weniger lesbar als:

template <class T>
void
swap(T& a, T& b)
{
    T tmp(move(a));
    a = move(b);
    b = move(tmp);
}

Oder sogar das original:

template <class T>
void
swap(T& a, T& b)
{
    T tmp(static_cast<T&&>(a));
    a = static_cast<T&&>(b);
    b = static_cast<T&&>(tmp);
}

In jedem Fall, der Geselle C++ - Programmierer sollten wissen, dass unter der Haube von move nichts mehr Los ist, als eine Besetzung. Für Anfänger in C++ - Programmierer, zumindest mit move werden darüber informiert, dass das Absicht ist, um bewegen aus der RS, im Gegensatz zu kopieren von RS, auch wenn Sie nicht genau verstehen wie das erreicht ist.

Zusätzlich, wenn ein Programmierer dies wünscht Funktionalität unter einem anderen Namen, std::move besitzt kein Monopol auf diese Funktionalität, und es gibt keine nicht-portable Sprache mit Magie zu tun in der Umsetzung. Zum Beispiel, wenn man wollte, um code set_value_category_to_xvalue, und verwenden Sie stattdessen, ist es trivial zu tun:

template <class T>
inline
constexpr
typename std::remove_reference<T>::type&&
set_value_category_to_xvalue(T&& t) noexcept
{
    return static_cast<typename std::remove_reference<T>::type&&>(t);
}

In C++14 wird es sogar noch präziser:

template <class T>
inline
constexpr
auto&&
set_value_category_to_xvalue(T&& t) noexcept
{
    return static_cast<std::remove_reference_t<T>&&>(t);
}

Also, wenn Sie so geneigt sind, schmücken Sie Ihre static_cast<T&&> aber Sie denken am besten, und vielleicht werden Sie am Ende der Entwicklung eine neue best-practice-C++ wird ständig weiterentwickelt).

So was tut move tun in Bezug auf erzeugte Objekt-code?

Betrachten Sie diese test:

void
test(int& i, int& j)
{
    i = j;
}

Zusammengestellt clang++ -std=c++14 test.cpp -O3 -S ergibt sich dieses Objekt code:

__Z4testRiS_:                           ## @_Z4testRiS_
    .cfi_startproc
## BB#0:
    pushq   %rbp
Ltmp0:
    .cfi_def_cfa_offset 16
Ltmp1:
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
Ltmp2:
    .cfi_def_cfa_register %rbp
    movl    (%rsi), %eax
    movl    %eax, (%rdi)
    popq    %rbp
    retq
    .cfi_endproc

Nun, wenn der test geändert:

void
test(int& i, int& j)
{
    i = std::move(j);
}

Es ist absolut überhaupt keine Veränderung im Objekt-code. Man kann verallgemeinern das Ergebnis: Für trivial beweglichen Objekte std::move hat keine Auswirkungen.

Betrachten wir nun das Beispiel:

struct X
{
    X& operator=(const X&);
};

void
test(X& i, X& j)
{
    i = j;
}

Diesem generiert:

__Z4testR1XS0_:                         ## @_Z4testR1XS0_
    .cfi_startproc
## BB#0:
    pushq   %rbp
Ltmp0:
    .cfi_def_cfa_offset 16
Ltmp1:
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
Ltmp2:
    .cfi_def_cfa_register %rbp
    popq    %rbp
    jmp __ZN1XaSERKS_           ## TAILCALL
    .cfi_endproc

Wenn Sie __ZN1XaSERKS_ durch c++filt es produziert: X::operator=(X const&). Keine überraschung hier. Nun, wenn der test geändert:

void
test(X& i, X& j)
{
    i = std::move(j);
}

Dann gibt es noch keinerlei Veränderung in die generierte Objekt-code. std::move hat nichts getan, aber gewirkt j zu einem rvalue, und dann, dass rvalue X bindet an die copy-Zuweisungsoperator von X.

Nun fügen Sie einen move-Zuweisungs-operator zu X:

struct X
{
    X& operator=(const X&);
    X& operator=(X&&);
};

Nun den Objekt-code hat ändern:

__Z4testR1XS0_:                         ## @_Z4testR1XS0_
    .cfi_startproc
## BB#0:
    pushq   %rbp
Ltmp0:
    .cfi_def_cfa_offset 16
Ltmp1:
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
Ltmp2:
    .cfi_def_cfa_register %rbp
    popq    %rbp
    jmp __ZN1XaSEOS_            ## TAILCALL
    .cfi_endproc

Läuft __ZN1XaSEOS_ durch c++filt zeigt, dass X::operator=(X&&) genannt wird, statt X::operator=(X const&).

Und das ist alles dort ist zu std::move! Es verschwindet vollständig bei der Laufzeit. Ihre einzige Auswirkung ist zur compile-Zeit, wo es könnte verändern, was überladung aufgerufen wird.

InformationsquelleAutor Howard Hinnant