rvalue reference

Sone

Übrigens falsch ausgedrückt. Die verlängert die Lebenszeit einer Temporary.
Wenn du eine rvalue reference durch einen Cast bekommst und zuweist, wird nichts verlängert.

Du musst es so umbiegen:
Also ist eine namenlose rvalue-reference ein rvalue (genauer, ein xvalue).

Sone schrieb:

nur Ausdrücke können lvalues sein.

Hä? Ein Ausdruck hat doch keinen Namen.

Sone

out schrieb:

Sone schrieb:

nur Ausdrücke können lvalues sein.

Hä? Ein Ausdruck hat doch keinen Namen.

Weißt du überhaupt, was lvalue bedeutet? Es ist ein Ausdruckstyp.

int a;

Nun wo a deklariert ist, ist `a

` ein lvalue. Das heißt nicht, dass das Objekt mit dem Namen a ein lvalue ist, denn das wäre falsch. Der Ausdruck "a" ist ein lvalue, denn es bezeichnet/referenziert* ein benanntes Objekt.

*: Schwer zu übersetzen, im Standard heißt es designates...

Sone schrieb:

Ist dir bewusst, dass eine rvalue reference (genau wie eine const lvalue reference) die Lebenszeit eines rvalues verlängert?

Nicht immer.

int&& i = 0; // ok
int&& j = std::move(0); // ill-formed

Sone

Das ist nicht ill-formed, denn move nimmt auch rvalue Referenzen.

Sone schrieb:

Und das ist nicht ill-formed, denn move nimmt auch rvalue Referenzen.

Ok, nicht ill-formed, sondern UB. Das move ist in Ordnung, nur die Lebenszeitverlängerung nicht.

Sone

zjraw schrieb:

Sone schrieb:

Und das ist nicht ill-formed, denn move nimmt auch rvalue Referenzen.

Ok, nicht ill-formed, sondern UB.

Effektiv steht da

int&& j = static_cast<int&&>(0);

Und das ist wohldefiniertes Verhalten. Auch für Klassen. Auch hier wird die Lebenszeit verlängert.

Sone

Um das mit dem Standard zu erklären:

§8.5.3/5 schrieb:

Otherwise, [...] the reference shall be an rvalue reference.
If the initializer expression is an xvalue [...] and “cv1 T1” is referencecompatible with “cv2 T2” [...] then the reference is bound to the value of the initializer expression [...].

#include <iostream>

struct A
{
	A(){std::cout << "C";}
	~A(){std::cout << "D";}
};

int main()
{
	A&& i = static_cast<A&&>(A());
	std::cout << " hi ";
}

Sone schrieb:

Effektiv steht da
int&& j = static_cast<int&&>(0);

Nein, woher hast du den Blödsinn? std::move ist ein Funktionsaufruf und das ist wichtig.

int main()
{
  A&& i = std::move(A());
  std::cout << " hi ";
}

Gibt (richtigerweise) aus

CD hi

Btw

A&& i = static_cast<A&&>(A());

Gibt auf clang "CD hi" aus, mit gcc "C hi D".

Ich würde meinen clang liegt hier falsch, bin mir aber nicht sicher.

Sone

std::move ist ein Funktionsaufruf und das ist wichtig.

Jetzt bin ich verwirrt.

Es sind doch xvalues in beiden Fällen, oder etwa nicht? Der Wert des Ausdrucks ist in beiden Fällen dasselbe Objekt, was gebunden wird. Wieso darf move nicht "geinlined" werden?

Edit: Der Unterschied liegt wohl in "value of the expression". Das wird für einen Funktionsaufruf irgendwie anders sein...

Sone

§5.2.2/4 schrieb:

The value of a function call is the value returned by the called function

~~Macht Sinn~~
Das macht überhaupt keinen Sinn. Dann ist der value ja derselbe wie für static_cast<A&&>(A()) ! Und dmait müsste dasselbe Ergebnis rauskommen, so oder so.

Ich würde meinen clang liegt hier falsch, bin mir aber nicht sicher.

Hängt nun davon ab, was der "Wert" von einem static_cast<A&&>(A()) ist.

Dementsprechend:

Ich würde meinen clang liegt hier falsch, bin mir aber nicht sicher.

Anscheinend hat Clang Recht, denn es hat dasselbe Ergebnis für den Cast und move.

Für std::move(A()):
A() wird an A&& von der std::move-Funktion gebunden und erhält full-expression lifetime
move gibt eine Referenz auf den Parameter A() zurück
A&& wird an die Referenz gebunden
A wird gelöscht, aber die Referenz lebt noch.

Beim static_cast wird so wie ich das sehe direkt zu A() gebunden, was die Lebenszeit von A() verlängert.

Sone

In beiden Fällen sind es xvalues. Sowohl move(...) ist ein xvalue als auch der Cast.

Das heißt in beiden Fällen trifft der selbe Standardabschnitt zu, und zwar der:

then the reference is bound to the value of the initializer expression

Nun kann der einzige Unterschied nur in value of the initializer expression liegen. Und der ist offensichtlich derselbe, da der Standard das für Funktionsaufrufe definiert.

Ok, sieht so aus, als wäre clang doch richtig

Otherwise, an expression e can be explicitly converted to a type T using a static_cast of the form static_-
cast<T>(e) if the declaration T t(e); is well-formed, for some invented temporary variable t (8.5). The
effect of such an explicit conversion is the same as performing the declaration and initialization and then
using the temporary variable as the result of the conversion. The expression e is used as a glvalue if and
only if the initialization uses it as a glvalue.

Also

A&& i = static_cast<A&&>(A()); // <=>
A&& i = { A&& a( A() ), t }; // A() wird am Ende dieser Zeile destructed, die Referenz überlebt

Sone schrieb:

In beiden Fällen sind es xvalues. Sowohl move(...) ist ein xvalue als auch der Cast.

Irrelevant.

Sone schrieb:

Das heißt in beiden Fällen trifft der selbe Standardabschnitt zu, und zwar der:

then the reference is bound to the value of the initializer expression

Ja, A&& ist die value. Die Lebenszeit von A&& wird verlängert, aber nicht die von dem A auf das referenziert wird.

Sone schrieb:

Nun kann der einzige Unterschied nur in value of the initializer expression liegen. Und der ist offensichtlich derselbe, da der Standard das für Funktionsaufrufe definiert.

static_cast ist kein Funktionsaufruf.

Sone

Irrelevant

Nein, relevant.

Ja, A&& ist die value. Die Lebenszeit von A&& wird verlängert, aber nicht die von dem A auf das referenziert wird.

Ja, das ist der Punkt wo ich haperte. Ich dachte der "Wert" kann nur ein Objekt sein.

static_cast ist kein Funktionsaufruf.

Nein, aber er Ausdruck mit static_cast ist der Rückgabewert von move . Und nun siehe den Standardabschnitt den ich zu Funktionsaufrufen gepostet habe.

Anscheinend hat Clang Recht, denn es hat dasselbe Ergebnis für den Cast und move.

Sone

A&& i = { A&& a( A() ), t };

Was bitte soll denn das sein?
Edit: Oh, tut mir Leid, das ist ja Pseudocode.

Sone schrieb:

Nein, aber static_cast ist der Rückgabewert von move .

Das spielt aber keine Rolle!!
Wäre static_cast<T&&>(x) definiert als "rvalue-referenz auf x" würde sich static_cast anders verhalten als std::move, weil std::move eine Funktion ist und static_cast nicht. Ich gebs auf mit dir zu diskutieren.

Sone

Wäre static_cast<T&&>(x) definiert als "rvalue-referenz auf x" würde sich static_cast anders verhalten als std::move, weil std::move eine Funktion ist und static_cast nicht.

---
Es verhält sich ja deswegen gleich, weil der Wert eines Funktionsaufrufs derselbe ist, wie der des zurückgegebenen Wertes. Und move ist genauso definiert, dass es static_cast<T&&>(t) zurückgibt.
Daher hat move in dieser Hinsicht immer denselben Effekt wie static_cast<T&&>(t) .

Und damit hatte ich völlig Recht:

Effektiv steht da
int&& j = static_cast<int&&>(0);

Ich gebs auf mit dir zu diskutieren.

Ich nicht, aber wenn du müde bist...

otze

Irgendwie zweifel ich an einem Sprachstandard, den man fast wortwörtlich auswendig lernen muss, dmait man das Verhalten der Sprache interpretieren kann.