Frage an die C++ Profis

[Ricky Spanish]

Hab hier gerade nen kleines Test-Programm von nem Arbeitskollegen bekommen und wir rätseln über die Ausgabe.

Zunächst mal das Programm:

#include <cstdio>
#include <cstdlib>
#include <cstring>

class XYZ
{
	private:
		int n;

	public:

	XYZ()
	{
		n = 5;
		printf("Constructor: %d\n", n);
	}

	~XYZ()
	{
		printf("Destructor: %d\n", n);
	}

	void set(int n)
	{
		this->n = n;
	}

	int get()
	{
		return n;
	}
};

void f();
XYZ g();

int main()
{
	printf("BEFORE f()\n");
	f();
	printf("AFTER f()\n");
	return(0);
}

void f()
{
	printf("BEFORE g()\n");
	XYZ result = g();
	printf("AFTER g()\n");
	printf("Result: %d\n", result.get());
}

XYZ g()
{
	printf("BEFORE creation\n");
	XYZ x;
	printf("AFTER creation\n");
	x.set(11);
	printf("Changed value to: %d\n", x.get());
	return(x);
}

Die Ausgabe ist folgende:

BEFORE f()
BEFORE g()
BEFORE creation
Constructor: 5
AFTER creation
Changed value to: 11
AFTER g()
Result: 11
Destructor: 11
AFTER f()

Das ganze wurde auf Solaris mit dem SUN Workshop Compiler gebaut.

Ich hätte erwartet, dass VOR der Ausgabe von "AFTER g()" einmal der Destuktor für das Objekt x aufgerufen wird, welches innerhalb der Methode g() auf dem Stack angelegt wird. Dies ist aber scheinbar nicht der Fall. Zu Hülf mit einer guten Erklärung!

thx,
M

 

[Starfire]

wegen "XYZ result = g();"
wenn du willst, dass das objekt in der funktion g() am ende terminieren soll, müsstest du den =operator selbst überladen.
ansonsten kopiert der nur die referenz und initialisiert kein zweites objekt.

bzw.
versuch mal
XYZ result;
result = g();

da müsste die ausgabe dann anders sein.

 

[TealC]

Ich find das gerade spannend und habs gerade getestet (g++ auf ubuntu).

1. Die Ausgabe war bei mir gleich.

2.
XYZ result;
result = g();
bringt das erwartete Ergebnis, also er erzeugt und zerstoert das temporaere Objekt.

3.
Operator= zu overloaden aendert nichts, der operator= wird gar nicht gecalled.


Es scheint mir also, als wuerde der Compiler die Uebergabe per Value aus g() raus einfach zu ner Uebergabe per Referenz machen, wenn es sich aussen um ne Deklaration handelt. Ziemlich abgefahren. Weiss einer, ob das immer so ist, oder ob das ne Optimierung vom Compiler ist?

 

[Starfire]

3.
Operator= zu overloaden aendert nichts, der operator= wird gar nicht gecalled.

na kommt ja auch immer drauf an, was du in der methode dann machst.
und wenn dein überladener =operator gar nicht erst aufgerufen wird, dann hast was falsch gemacht und ihn nicht überladen.

 

[TealC]

Ne, ich bin mir ziemlich sicher nichts falsch gemacht zu haben. In dem Beispiel von Noxx wird der operator= nicht gecalled.

Die Zeile
XYZ result = g();
nimmt einfach nur die Referenz vom temporaeren Objekt und schreibt sie auf result. Insofern ist es auch egal, was man in den operator= reinschreibt.

Das passt auch dazu, dass es keinen zweiten Constructor/Destructor Call gibt.


Noch mein Code zu 3.: ich habe zu Noxx Code in der Class folgende Methode hinzugefuegt und der Output blieb unveraendert.

 XYZ& operator=(XYZ const &na)
  {
    cout << "operator=" << endl;
    n = na.n;
    return (*this);
  }

 

[voelkerballtier]

http://en.wikipedia.org/wiki/Return_value_optimization

 

[Starfire]

stimmt, hast recht, der operator= wird im ersten fall gar nicht verwendet.

der compiler macht aus:
XYZ result = g();
das hier:
XYZ result(g());

und wennde einen XYZ(const XYZ) constructor schreibst, wird dieser auch aufgerufen.

zb.
XYZ(const XYZ &na)
{
n = 5;
printf("anderer Constructor(): %d\n", n);
}

 

[Ricky Spanish]

Thx, für die Antworten. Insbesondere der Wiki-Link ist hilfreich!
Habe das ganze gerade hier zu Hause mal mit dem Visual Studio 2010 Compiler getestet. Der optimiert das nicht, d.h. hier wird der Destruktor 2x aufgerufen.

Damit wäre die Frage aber geklärt