Local varible (Stack) zurückgegeben als Funktion Rückgabewert

Question

Hier ist ein Beispiel für Friend-Funktionen im Internet gefunden:

#include <iostream> 
using namespace std; 

class Rectangle { 
    int width, height; 
    public: 
    Rectangle() {} 
    Rectangle(const Rectangle &r) { 
     width = r.width; 
     height = r.height; 
     cout << "copy\n"; 
    } 
    Rectangle (int x, int y) : width(x), height(y) {} 
    int area() {return width * height;} 
    friend Rectangle duplicate (const Rectangle&); 
}; 

Rectangle duplicate (const Rectangle& param) 
{ 
    Rectangle res; 
    res.width = param.width*2; 
    res.height = param.height*2; 
    return res; 
} 

int main() { 
    Rectangle foo; 
    Rectangle bar (2,3); 
    foo = duplicate (bar); 
    cout << foo.area() << '\n'; 
    return 0; 
} 

Ausgang:

24 

Beachten Sie, dass der Freund "Duplikat" Funktion erstellt eine lokale Variable und gibt als Rückgabewert an den Aufrufer zurück. Soll das nicht eine lokale Variable sein und wird auf diesem Stack vergeben? Sollte es nicht zerstört werden, sobald "duplicate" die Ausführung beendet hat? Ist dieses Beispiel gut?

Danke.

Answer 1

Man denke nur an regelmäßigen Typen:

int getInt(void) { 
    int a = 5: 
    return a; 
} 

Die Funktion kehrt nicht wirklich den lokalen Variable a. Stattdessen gibt es eine Kopie von a zurück. In ähnlicher Weise wird res von der Funktion nicht zurückgegeben, sondern ihre Kopie.

In der Praxis erkennt der Compiler wahrscheinlich Ihre Funktion und optimiert die Funktion, indem das Kopieren Rectangle vermieden wird.

die Konstruktoraufrufe beobachten, kompiliert es mit

g++ -fno-elide-constructors foo.cpp -o foo 

Sie müssen disable return value optimization for g++ (-fno-elide-constructors), die eine sehr einfache Optimierung ist, dass auch bei -O0 eingeschaltet würde.

Answer 2

Ihre Funktion gibt Rechteck nach Wert zurück, also sollte es in Ordnung sein.

Das zurückgegebene Objekt befindet sich nicht im selben Speicher. Es ist nicht das gleiche Objekt, das von der lokalen Variablen vom abstrakten Sprachlevel deklariert wird. De-facto, wie Justin sagt, kann der Compiler die Erzeugung temporaler Objekte optimieren.

würden Sie in rot, wenn man

Rectangle& duplicate (const Rectangle& param) 

erklärt

dann würde Funktion versuchen, einen Verweis auf lokale Variable zurückzukehren.

Wie Code geschrieben wird, ist es ein Äquivalent von Ausdruck.

return Rectangle(param.width*2, param.height*2); 

Copykonstruktor:

Rectangle(const Rectangle &r) { 
    width = r.width; 
    height = r.height; 
} 

sollte proprly als

geschrieben werden

Rectangle(const Rectangle &r): width(r.width), height(r.height) 
{ 
} 

Die ouput Linie ist ein Nebeneffekt, dass durch Kopie elision weggelassen werden könnten.