Ich habe das Problem, dass zurückgegebene Objekte bei verschachtelten Aufrufen scheinbar ihre Gültigkeit verlieren. Im folgenden ein Codebeispiel (ich habe den ursprünglichen nicht funktionierenden Code sehr gekürzt und zusammengefasst - ich habe alles gelöscht, was mit dem Problem nichts zu tun hat und alle Klassenelemente public deklariert - so ist der Code nun einfacher zu lesen, wenn auch kein sauberer C++-Code mehr):

Eine Klasse 'zahl' beinhaltet ein double-Feld 'wert' und zwei Operatoren +=,*= :

#ifndef __GLEICHUNGEN__ZAHL_H__
#define __GLEICHUNGEN__ZAHL_H__

class zahl
{
	public:
		zahl(double value):wert(value) {}
		double wert;

		//Rechenoperatoren
		zahl &operator+=(const zahl &rvalue);
		zahl &operator*=(const zahl &rvalue);
};

inline zahl &zahl::operator+=(const zahl &rvalue)
{
	wert+=rvalue.wert;
	return *this;
}
inline zahl &zahl::operator*=(const zahl &rvalue)
{
	wert*=rvalue.wert;
	return *this;
}

#endif

main: Die Funktion main() definiert 3 Instanzen der Klasse zahl und will z1*(z2+z3) mittels der +=,*= - Operatoren ausrechnen.

#include <iostream>

#include "zahl.h"

using std::cout;

const zahl &addition(zahl *_links,zahl *_rechts)
{
	return zahl(_links->wert)+=*_rechts;
}

const zahl &f1(zahl *z1,zahl *z2,zahl *z3)
{
	return zahl(z1->wert)*=addition(z2,z3);
}

int main()
{
	zahl z1(3),z2(5),z3(6);

	//z1*(z2+z3)
	std::cout << f1(&z1,&z2,&z3).wert;
}

Leider erhalte ich nicht das erwartete Ergebnis 3*(5+6)=33, sondern das Programm gibt eine Zahl mit einer Zehnerpotenz von etwa -300 aus. Vermutlich werden die in den Funktionen f1 bzw addition zurückgegebenen Objekte ungültig.
Wenn ich bei den Konstruktoren in zB f1() das = wegnehme und nur zahl(z1->wert) zurückgebe, gibt der Compiler einen Fehler aus, dass ein temporäres Objekt zurückgegeben wird. Wieso funktioniert das ganze dann mit dem Operator=?
Und warum funktioniert es nicht? Ich habe mal gelesen, dass man bei Funktionen, welche Objekte zurückgeben, const-Referenzen als Rückgabewert und einen Konstruktor als return-Statement nehmen soll. War das eine Falschinformation?

Gruß,
Heinzi

(da ist es besser, neben den bisherigen Operatoren auch + und * zu überladen - dann brauchst du deine Funktionen überhaupt nicht mehr:

zahl operator +(zahl r, zahl l)
{ return r+=l; }
zahl operator *(zahl r, zahl l)
{ return r*=l; }

...
cout<<z1*(z2+z3)<<endl;

das Beispiel ist nur Unsinn, weil ich es so gekürzt habe. Die Zeiger brauche ich, da es im eigentlichen Programm Zeiger auf eine Basisklasse sind. Ich habe im Programm auch die Operatoren +,* definiert, welche folgendermaßen aussehen:

template<class T>
   const T operator+(const T& lhsObj,const T& rhsObj)
   {
      return T(lhsObj) += rhsObj; //return von Konstruktor
   }

Dieses Codebeispiel ist aus "Notizen zu C++" von Peter Thömmes (Version: 09. August 2003) Seite 196/197: http://www.astro.uni-wuerzburg.de/~asmaier/usefulthings/c++.pdf
Hier funktioniert es mit der Rückgabe der Referenzen. Soweit ich weiß, heißt die Technik return value optimization und ist eine Compilererweiterung, welche dafür sorgt, dass in Funktionen, welche lokale Objekte zurückgeben müssen, diese nicht zuerst in der Funktion und dann nochmal bei der Rückgabe neu konstruiert werden.
Da ich mit dem GCC compiliere und dieser die entsprechende Compilererweiterung normalerweise hat, dürfte es kein Problem geben.
Das Problem entsteht irgendwie erst, wenn ich die zurückgegebenen Objekte gleich weiter an Funktionen übergebe.

Gruß,
Heinzi

Gruß,
Heinzi