Frage zu Rückgabewerten von Funktionen

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

code:
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:

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

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

Shade Of Mine

hier darf der Compiler (N)RVO ((Named) return value optimization) betreiben.

das bedeutet, dass es keine zusaetzliche kopie gibt. allerdings koennen das nicht alle compiler (aber die meisten schon)

Deine zweite Version geht übrigens nicht.
y ist lokales Objekt.

Jockel

Quatsch, hab mich verguckt.

Hallo,

code:
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