void func1( int&& ); // #1
void func2( int& );  // #2

Vorallem beim ersten bin ich mir nicht im Klaren, was dies genau bedeutet.
Das zweite sollte klar sein

MfG

MfG

Foo&& i = Foo(10);
Foo j = i;

Der Default-Konstruktor von Foo wird in der ersten Zeile aufgerufen, der Move-Konstruktor in der zweiten Zeile.

MfG

Es ist eine Art Optimierung, die laestiges Kopieren verringern soll und jetzt von der Sprache direkt unterstuetzt wird. An deinen zwei Funktionssignaturen wirst du das nicht verstehen koennen.

int&& i = getInt( );

Ist also eine Referenz auf das Return Value des Calls. Es wird nichts kopiert.
Aber wie merkt er sich das?

MfG

BTW: Wäre es nicht das selbe wie das hier?

#include <iostream>

int* get( )
{
	return new int( 19 );
}

int main( int argc, char* argv[ ] )
{
int i = *get( );
return 0;
}

BTW: Wäre es nicht das selbe wie das hier?

Nein. Bei deinem Beispiel wird der in get() am Heap angeforderte int nach i kopiert und bleibt seinerseits als Speicherlöchli übrig.

MfG

Die Begriffe sind eigentlich selbsterklärend: && ist eine Referenz auf ein rvalue, also in etwa

Foo&& i = Foo(10);
Foo j = i;

Der Default-Konstruktor von Foo wird in der ersten Zeile aufgerufen, der Move-Konstruktor in der zweiten Zeile.

Ich hab es zwar nicht getestet, aber da i einen Namen hat, wird denke ich der normale Copy-Contruktor aufgerufen...

Zudem meine ich mich zu erinnern, dass man einen Rückgabewert (hier halt der Konstruktor) nicht als rvalue-Referenz speichert.

Du möchtest wohl eher etwas wie:

Foo i(10);
Foo j = std::nove(i);

Gruß,
XSpille

Wenn ich völlig falsche liege, korrigiert mich bitte...

#include <string>
#include <iostream>

struct Foo{
	Foo(int v) : i(new int(v)){
	}

	Foo(Foo&& foo) : i(foo.i) {
		foo.i = 0;
		std::cout << "move" << std::endl;
	}
	Foo(const Foo& foo) : i(new int(*foo.i)) {
		std::cout << "copy" << std::endl;
	}
	~Foo(){
		delete i;
	}
	int* i;
};

int main(){
	Foo&& i = Foo(10); // <-- Hier
	Foo j = i;
	Foo i2 = Foo(10); 
	Foo j2 = std::move(i2);
}

copy
move

Wie Kellerautomat gemeint hat: sobald er einen Namen hat, ist es wieder ein lvalue...

Aber vielleicht bestätigt mir noch jemand, dass man die markierte Zeile ebenfalls nicht so verwenden sollte...

void fill_stack(int i){
	if(i<1000){
		std::cout << i <<std::endl;
		fill_stack(++i);
	}
}

Foo f(){
	return Foo(10);
}

int main(){
	Foo&& i = f();
	std::cout << *i.i << std::endl;
	fill_stack(0);
	Foo j = i;
	std::cout << *j.i << std::endl;
}

Also Foo(10) liegt auf dem Stack und danach wird der Stack durch den Funktionsaufruf überschrieben...
Und eine rvalue-Referenz, ist ja auch nur eine Referenz...

Ich vermute es liegt nur an 'Optimierungen' des Compilers?

So funktionieren RValue Referenzen aber nicht. Die Lebenszeit des temporaeren Objektes wird bis zum Scopeende verlaengert, genau wie wenn du eine LValue Referenz auf const verwendet haettest.

Stimmt... Hab ich auch schonmal gehört!!! THX

Ist es richtig, dass std::move einfach nur ein typecast ausführt? Sowas in der Art?

reinterpret_cast< Type&& >( x );

MfG

@cooky451: Ja das mit den Basistypen habe ich jetz verstanden. Trotzdem vielen Dank für die Erklärung.

Ist es richtig, dass std::move einfach nur ein typecast ausführt? Sowas in der Art?

reinterpret_cast< Type&& >( x );

MfG

Es ist ein cast, allerdings kein reinterpret_cast, sondern etwas normales (static_cast). Wieso wird eigentlich bei Fragen immer gleich reinterpret_cast ausgepackt?

Sieht also ungefähr so aus:

template <typename T>
auto move(T&& x) noexcept -> typename std::remove_reference<T>::type&&
{
    return static_cast<typename std::remove_reference<T>::type&&>( x );
}

MfG

Edit: Weiß ich nicht

template <typename T>
T&& move(T& x)
{
    return static_cast<T&&>(x):
}

Dass es dann mit RValues nicht funktioniert, interessiert doch keinen.

Warum definiert man move nicht eigentlich einfach so?

template <typename T>
T&& move(T& x)
{
    return static_cast<T&&>(x):
}

Dass es dann mit RValues nicht funktioniert, interessiert doch keinen.

Dann geht aber doch z.B. das hier nicht mehr, oder?

string str = "123";
int z;
istringstream(str) >> z;

Warum definiert man move nicht eigentlich einfach so?

template <typename T>
T&& move(T& x)
{
    return static_cast<T&&>(x):
}

Dass es dann mit RValues nicht funktioniert, interessiert doch keinen.

Das hatte ich mich auch mal gefragt; denn es ist ja sogar eher schädlich, move auf einem Rvalue aufzurufen, da dadurch copy elision unterdrückt wird. Aber ich kann mir vorstellen, dass man in manch generischem Code nicht immer weiß, ob ein Funktionsaufruf (z.B. eine Iterator-Dereferenzierung) ein Lvalue oder Rvalue-Ausdruck ist. Man würde ein Lvalue erwarten, aber es gibt ja auch Iteratoren von "lazy sequences" die den Wert erst dann ausrechnen, wenn man ihn haben will und das ist dann ggf. ein temporäres Objekt...