eine Frage, wenn ich ein Objekt einer selbst erstellten Klasse wie gewohnt per value zurückgebe wie z.B. hier

class A {...}

A foo()
{
  A a;

  return a;
}

wird dann die zurückgegebene Kopie von a dann mit Hilfe des Kopierkonstruktors meiner Klasse A erstellt, d.h. falls keiner angegeben ist per default Kopierkonstruktor, was einer shallow-copy entspricht und falls ein eigener Kopierkonstruktor definiert wird, halt mit dessen Hilfe (wie auch immer das im Einzelfall dann auch aussieht) ?

Gruß

Hätte ich dann in der Klasse A irgendwelche Speicherallokationen, dann würde (falls gut programmiert wurde) nach Beenden von "foo()" alles an allokiertem Speicher in dem Objekt "a" freigegeben werden und in der zurückgegebenen Kopie von a nicht mehr zur Verfügung stehen oder?

Gruß

Als Beispiel folgender Code:

class Foo
{
public:
	int* i;
	Foo()
		: i( new int(10) )
	{}

	~Foo()
	{
		delete i;
	}
};

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

int main() 
{ 
	Foo cpy = foo();
	cout << *cpy.i << endl; // Undefined behavior
}

Hier hast du das Problem, dass beim Verlassen der Funktion foo() das f kopiert wird und dann zerstoert. Dabei wird der Destruktor von f aufgerufen und delete auf i aufgerufen. Die Kopie ist eine Shallow-Copy, das heisst die Kopie, die zurueckgegeben wird, zeigt nun auf geloeschten Speicher. Das Dereferenzieren in Zeile 24 erzeugt dann undefiniertes Verhalten.

*Edit
Die Loesung waere dann natuerlich einen Copy-Constructor einzufuehren, der eine Deep Copy erstellt:

Foo( const Foo& f )
		: i( new int(*f.i) )
	{}

Oder besser: Gleich RAII verwenden oder gar nicht erst new brauchen.

Könnte man das Problem mit Smart-Pointern lösen?
Wenn ich das richtig verstanden habe löschen diese sich selbst, sobald keine Referenz mehr auf den entsprechenden Speicher existiert, was in unserem Fall bedeuten würde, dass nach verlassen von foo() der Speicher auf die 10 ints nicht freigegeben wird, da der Rückgabewert von foo() noch eine Referenz auf diesen beinhaltet.

Gruß

Es gibt allerdings ganz verschiedene Smart Pointer. Es funktionieren nicht alle ueber Reference Count. Ich denke fuer diesen Fall waere ein shared_ptr angebracht.

Hier werden ein paar Smart Pointer aus der boost library erklaert. shared_ptr ist im namespace tr1 und wird von den modernen Compilern unterstuezt.

Ich meinte bzgl. der smart Pointer jetzt nur Erstellen/Zerstören der Speicherbereiche und nicht die Modifikation, habe ich vergessen beizuschreiben

Gruß

Kann man es denn irgendwie bewerkstelligen, dass bei der return-Anweisung gemoved wird anstatt kopiert, d.h. dass der move-Konstruktor verwendet wird anstatt der copy-Konstruktor?

Gruß

Vielen Dank

#include <iostream>

class A
{
public:
    A()
    {
        std::cout << "default" << std::endl;
    }
    A( const A& )
    {
        std::cout << "copy" << std::endl;
    }
    A( A&& )
    {
        std::cout << "move" << std::endl;
    }
    ~A()
    {
        std::cout << "destruction" << std::endl;
    }
};

A foo()
{
    A a;
    return a;
}

int main()
{
    A a = foo();
}

Ist bei mir beispielsweise nur

default
destruction

Der compiler konstruiert das A aus foo direkt dorthin, wo es nach der Funktion gebraucht wird, d.h. es wird nie kopiert. Stattdessen übergibt main() foo() implizit einen return_ptr (oder wie man das auch nennen will), wohin das Objekt konstruiert werden soll, d.h. auf den Stackbereich von main(). Dadurch kann foo() einfach returnen und braucht a gar nicht zu kopieren oder zu moven.
Hier ist sowas nicht möglich, da je nach Pfad ein anderes Objekt returned werden kann (zumindest moved mein gcc hier):

A foo()
{
    A a;
    A b;
    if( true )
        return a;
    else
        return b;
}

Ich meine diese Optimierung heißt 'return value optimization', danach kannst du mal googlen. Es gibt auch einige gute Tutorials zum Thema move, z.B. 'moving forward'.

default
destruction

#include <cstdlib>
#include <iostream>

struct A {
  A()           { std::cout << "default"     << std::endl; }
  A(A const &)  { std::cout << "copy"        << std::endl; }
  A(A &&)       { std::cout << "move"        << std::endl; }
  ~A()          { std::cout << "destruction" << std::endl; }
};

A foo()
{
  A a, b;

  // RVO verhindern.
  return std::rand() % 2 == 0 ? a : b;
}

int main()
{
  A a = foo();
}

gibt bei mir

default
default
copy
destruction
destruction
destruction

Move gibt's mit

return std::move(std::rand() % 2 == 0 ? a : b);

a in main wird allerdings von gcc nach wie vor direkt initialisiert. Grundlage ist g++ 4.7.0 mit -std=c++11.

Der Debug-Modus wird beim GCC mit -g eingeleitet oder? Bei mir ändert sich da nichts an der Ausgabe

-g erzeugt nur Debug-Symbole.
-O0 setzt die Optimierungen auf 0, also Debug-Build. -O1, -O2, -O2.5, -Os und -O3 erzeugen Realese-Builds.