Frage zu Rückgabewerten von Funktionen (C/C++)

[Vedek Bareil]

Ich hätte mal folgende Frage:
Wenn eine Funktion einen Wert zurückgibt, etwa so (T sei ein beliebiger Datentyp):

T func(/*...*/)
{
T y;
//..
return y;
}

//...

T x = func(/*...*/);

Wird dann der Inhalt von y direkt in x kopiert? Oder wird er erst als Rückgabewert von func zwischengespeichert und dann erst x zugewiesen, so daß zwei aufeinanderfolgende Kopiervorgänge anfallen?

Die Frage ist wichtig im Hinblick auf den Fall, daß T eine große Datenstruktur oder Klasse ist, die viel Speicherplatz benötigt und deren Kopieren merklich viel Zeit in Anspruch nimmt.
Würde es nach obiger Konstruktion tatsächlich zwei Kopiervorgänge geben, so wäre es dann performancemäßig ja besser, die Zuweisung folgendermaßen mittels Pointern zu realisieren:

void func(/*...*/, T *x)
{
T y;
//...
*x = y;
}

T x;
func(/*...*/, x);

[ScottManDeath]

keine ahnung ob das irgendwie im standard festgelegt wurde

ich denke das das 2 kopien gibt, einmal in ein anonymes objekt, und dann in das zielobjekt, ein gute compiler dürfte das aber z.b. im release build wegoptimieren

schreibe doch ein kleines programm welches in den (kopier)konstruktoren textausgaben macht. dann weisst du wenigstenms genau wie das dein compiler macht.

[micki]

es wird ein Temporäres objekt angelegt und dann kopiert, weil zwischen dem schreiben in die variable und dem return (sofern anweisungen dazwischen sind) eine exception auftretten könnte, bei der man dann ohne ein return zurückspringt und somit die variable unverändert sein müßte.
natürlich kann das ein kompiler in deinem beispielfall optimieren, dann würde er auch die funktion inlinen.

MfG
micki

[Stichwort]

(N)RVO

[Gast]

(Named) return value optimization

[frage]

unterschied zwischen nrvo und rvo????

[Helferchen]

Original geschrieben von Gast
(Named) return value optimization

ja !

[liquid]

Link (http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=Optimize)

[Xmas]

Original geschrieben von Vedek Bareil

T func(/*...*/)
{
T y;
//..
return y;
}

//...

T x = func(/*...*/);


Lustigerweise hast du dir gerade den Fall ausgesucht in dem nicht zweimal kopiert wird ;)

Denn du hast hier mit
T x = func(/*...*/);
eine Initialisierung, keine Zuweisung! Hier wird auch nicht operator= aufgerufen.

Genau passiert folgendes:

T y; // erzeugt eine T-Instanz mit Default Constructor
return y; // erzeugt eine temporäre T-Instanz mit Copy Constructor,
// dann Aufruf des Destructor für y

T x = func(/*...*/) // "übernimmt" die temporäre T-Instanz auf der rechten Seite als x
// es wird *nicht* kopiert

ganz anders dagegen:

T x; // erzeugt eine T-Instanz mit Default Constructor
x = func(/*...*/) // kopiert die temporäre Instanz mit operator= nach x
// dann Aufruf des Destructor für temporäre Instanz