🚀 go-pugleaf

Dirk Brenckmann wrote:
> 
> Hallo, ich bin 25 und habe ein Problem... *grins*
> 
> Im Ernst. Speziell beim Ueberladen von + und - operatoren in Klassen
> ergibt sich das Problem, dass ich innerhalb der Methoden neue Instanzen
> schaffen muss, um die per return wieder zuruck zu geben.
> Erzeuge ich solche Instanzen mit "new" stellt sich die Frage, von wem
> und wann sie vernichtet werden. (Meistens gar nicht mehr. Das wird bei
> megalangen Listen ganz schnell zum Speicherproblem) .
> Instanziere ich ohne "new" laueft der Gueltigkeitsbereich der Variable
> von der Instanzierung, bis zum "return", indem der Destruktor der
> Klasse aufgerufen wird. -> D.H. ich "returne" einen wieder freigegebenen
> Speicherplatz :((( Bei kleinen Klassen funktioniert das. Listen jedoch
> gehen zumeist verloren.
> Da das meiner Einschaetzung nach ein elementares Problem der objektorien-
> tierten Programmierung ist, sollte es da auch eine saubere Loesung geben.
> Nur - wer kennt sie??? Bitte Mailen, da dringend ... danke.
> 

Ich sehe keinen Grund keine Instanz zurueckzugeben, solange sich 
Objekte Deiner Klasse beim Kopieren bzw. Zuweisen korrekt verhalten.

	Enno

Dirk Brenckmann (brenck@iib.bauwesen.th-darmstadt.de) wrote:

: Im Ernst. Speziell beim Ueberladen von + und - operatoren in Klassen
: ergibt sich das Problem, dass ich innerhalb der Methoden neue Instanzen
: schaffen muss, um die per return wieder zuruck zu geben.

Das folgende Beispiel sollte zeigen, wie es geht:

/* Der Operator = ermöglicht Zuweisungen von Vektoren.*/

template<class T> Vector<T>& Vector<T>::operator=(const Vector& v)
{
        unsigned int    i;
        
        if (this == &v)
           return( *this);        

        for (i=0; i<dim; i++)
           data[i] = v.data[i];

          return (*this);
}

/* Die Operatoren + und - erlauben Vektoraddition und -subtraktion. */          

template<class T> Vector<T> Vector<T>::operator+(const Vector& v) const
{
         unsigned int    i;
         Vector result(dim);
          
          for (i=0; i<dim; i++)
                  result.data[i] = data[i] + v.data[i];
                  
          return(result);
}          

Berechnet man jetzt a = b + c, so umfaßt die Lebensdauer des neuen, von
+() erzeugten Objekts, die Zeit, während der der operator=() aktiv ist.

Andreas

--
Andreas Zierdt,    Institut fuer Phonetik und sprachliche Kommunikation
                   Universitaet Muenchen, Schellingstr. 3
                   80799 Muenchen, Germany

E-mail: andi@sun1.phonetik.uni-muenchen.de                   

In <4fspll$j05@rs18.hrz.th-darmstadt.de> brenck@iib.bauwesen.th-darmstadt.de (Dirk Brenckmann) writes:
>Nur - wer kennt sie??? Bitte Mailen, da dringend ... danke.

Nicht mailen sondern posten bitte! Es interessiert auch andere.

Gruesse, Benni
-- 
http://www.uni-frankfurt.de/~benni/hello.html
"1024 Byte bilden ein Megabyte"
	aus einer Schrift des Bundesministerums fuer Wirtschaft zur
	"Informationsgesellschaft" 

brenck@iib.bauwesen.th-darmstadt.de (Dirk Brenckmann) writes:

>Hallo, ich bin 25 und habe ein Problem... *grins*
Warte erstmal ab, bis Du 30 bist...;-)

>Im Ernst. Speziell beim Ueberladen von + und - operatoren in Klassen
>ergibt sich das Problem, dass ich innerhalb der Methoden neue Instanzen
>schaffen muss, um die per return wieder zuruck zu geben.
>Erzeuge ich solche Instanzen mit "new" stellt sich die Frage, von wem
>und wann sie vernichtet werden. (Meistens gar nicht mehr. Das wird bei
>megalangen Listen ganz schnell zum Speicherproblem) .

Also mit 'new' zu erzeugen ist keine gute Idee, denn die Zuweisung an
das Ergebnisobjekt erfolgt per Value oder per Reference und ist
darueberhinaus nicht Pflicht, sodass Du im unguenstigsten Falle bei der
spaeteren Verwendung keinen Zeiger auf das dynamisch angelegte Objekt mehr hast
oder (im guenstigsten Fall) erst die Adresse ermitteln musst.

>Instanziere ich ohne "new" laueft der Gueltigkeitsbereich der Variable
>von der Instanzierung, bis zum "return", indem der Destruktor der
>Klasse aufgerufen wird. -> D.H. ich "returne" einen wieder freigegebenen
>Speicherplatz :((( Bei kleinen Klassen funktioniert das. Listen jedoch
>gehen zumeist verloren.
>Da das meiner Einschaetzung nach ein elementares Problem der objektorien-
>tierten Programmierung ist, sollte es da auch eine saubere Loesung geben.
>Nur - wer kennt sie??? Bitte Mailen, da dringend ... danke.

Nanana. Da schaue Dir doch nochmal an, wie ein return funktioniert.
Der Wert des return-Ausdruckes wird in den aufrufenden Kontext der
Funktion zurueckgeliefert. Und zwar mittels Kopie! Damit wird auch klar,
warum das bei Deinen Listen nicht funktioniert. Du brauchst einen
Copy-Konstruktor, der Dir sauber ein temporaeres Objekt aus Deinem
Return-Wert erzeugen kann. Dann brauchst Du auch noch einen
Zuweisungsoperator, um die Elemente des temporaeren Objektes in die
Deiner Ergebnisvariable zu kopieren. Alles in allem eine fuer die
Laufzeit zu aufwendige Loesung. Zuerst Erzeugung des automatischen
Objektes im Kontext der Operator-Funktion, dann Berechnung der
Operation, dann Erzeugung des temporaeren Objektes mittels Kopie, dann
Zuweisung des letztgenannten an das Ergebnis-Objekt mittels
Zuweisungsoperator. Intelligente Compiler sparen bei einem Statement wie
ListenTyp ErgListe = Liste1 + Liste2;
das temporaere Objekt ein; das wird dann gleich in der Ergebnisvariable
initialisiert. Aber fuer die Verwendung bei z.B. Listen trotzdem zu
aufwendig. Bei Listen werden deshalb eigentlich keine solcher + -
Operatoren geschrieben. Das Anhaengen etc. wird bei Listen und anderen
Containern deshalb ueber Memberfunktionen gemacht, wie z.B. 
void <T>DLList::join(<T>DLList& b)
(Quelle: GNU C++ Gen-Lib)

Viel Spass noch,

Karsten
--
(  Email: Karsten.Baensch@hrz.tu-chemnitz.de                                ( 
 ) WWW:   http://www.tu-chemnitz.de/~kba/baensch.html                        )
(  Phone: (+49-) 0371/531-1252                                              ( 
 ) Mail:  Technical University, Computing Services, 09107 Chemnitz, Germany  )

andi@linux8.phonetik.uni-muenchen.de (Andreas Zierdt) writes:

>Dirk Brenckmann (brenck@iib.bauwesen.th-darmstadt.de) wrote:

>: Im Ernst. Speziell beim Ueberladen von + und - operatoren in Klassen
>: ergibt sich das Problem, dass ich innerhalb der Methoden neue Instanzen
>: schaffen muss, um die per return wieder zuruck zu geben.

>Das folgende Beispiel sollte zeigen, wie es geht:

>/* Der Operator = ermöglicht Zuweisungen von Vektoren.*/

>template<class T> Vector<T>& Vector<T>::operator=(const Vector& v)
>{
>        unsigned int    i;
>        
>        if (this == &v)
>           return( *this);        

>        for (i=0; i<dim; i++)
>           data[i] = v.data[i];

>          return (*this);
>}

>/* Die Operatoren + und - erlauben Vektoraddition und -subtraktion. */          

>template<class T> Vector<T> Vector<T>::operator+(const Vector& v) const
>{
>         unsigned int    i;
>         Vector result(dim);
>          
>          for (i=0; i<dim; i++)
>                  result.data[i] = data[i] + v.data[i];
>                  
>          return(result);
>}          

>Berechnet man jetzt a = b + c, so umfaßt die Lebensdauer des neuen, von
>+() erzeugten Objekts, die Zeit, während der der operator=() aktiv ist.

Wenn er zusaetzlich noch einen korrekten Copykonstruktor fuer Vector<T> 
definiert, dann funktionierts. Denn das innerhalb von 
'template<class T> Vector<T> Vector<T>::operator+(const Vector& v) const'
mit Vector 'result(dim);' erzeugte automatische Objekt ist zur Zeit der
Ausfuehrung von 'operator=()' nicht mehr am Leben! Wenn obige Aussage so
gemeint war, dann ist sie meiner Meinung nach falsch. Korrigiert mich,
wenn ich mich irre.
Wenn es so waere, dann koennte 'operator+' auch eine Referenz auf 'result'
zurueckliefern, um diese dann an 'operator=(const Vector& v)' zu
uebergeben. Das wuerde vieles einfacher machen. Geht aber nicht.

Erst durch 'return(result);' wird im Kontext der
aufrufenden Funktion ein temoraeres Objekt erzeugt und mit 'result'
initialisiert. Fuer eben diese Initialisierung braucht man den
Copykonstruktor.

Karsten
--
(  Email: Karsten.Baensch@hrz.tu-chemnitz.de                                ( 
 ) WWW:   http://www.tu-chemnitz.de/~kba/baensch.html                        )
(  Phone: (+49-) 0371/531-1252                                              ( 
 ) Mail:  Technical University, Computing Services, 09107 Chemnitz, Germany  )

Karsten Baensch (kba@hrz.tu-chemnitz.de) wrote:

: Wenn er zusaetzlich noch einen korrekten Copykonstruktor fuer Vector<T> 
: definiert, dann funktionierts. Denn das innerhalb von 
: 'template<class T> Vector<T> Vector<T>::operator+(const Vector& v) const'
: mit Vector 'result(dim);' erzeugte automatische Objekt ist zur Zeit der
: Ausfuehrung von 'operator=()' nicht mehr am Leben! Wenn obige Aussage so
: gemeint war, dann ist sie meiner Meinung nach falsch. Korrigiert mich,
: wenn ich mich irre.
: Wenn es so waere, dann koennte 'operator+' auch eine Referenz auf 'result'
: zurueckliefern, um diese dann an 'operator=(const Vector& v)' zu
: uebergeben. Das wuerde vieles einfacher machen. Geht aber nicht.

: Erst durch 'return(result);' wird im Kontext der
: aufrufenden Funktion ein temoraeres Objekt erzeugt und mit 'result'
: initialisiert. Fuer eben diese Initialisierung braucht man den
: Copykonstruktor.

Stimmt natürlich, den Copykonstruktor habe ich unterschlagen. Das wäre
dann also noch:

template<class T> Vector<T>::Vector(const Vector& v)
{
        unsigned int    i;
        dim = v.dim;
        
        for (i=0; i<dim; i++)
            data[i] = v.data[i];
}                                             

Hielt ich für offensichtlich, war es aber nicht.  :-)

Andreas
--
Andreas Zierdt,    Institut fuer Phonetik und sprachliche Kommunikation
                   Universitaet Muenchen, Schellingstr. 3
                   80799 Muenchen, Germany

E-mail: andi@sun1.phonetik.uni-muenchen.de