🚀 go-pugleaf

Saggau Henning wrote:
>         return Element[1];
> }
> So in diesem Beispiel wird der Wert selber beim return angegeben.
> 
> foo& foo::operator=(const foo& f){
> .....
>         return *this;
> }
> hier wird der Pointer angegeben.

*this ist kein Pointer, sondern das Objekt selbst.
Die Bildung einer Referenz darauf ist implizit, d. h.
opaque.
-- 
*	Greetinx from Watson (sayegh@fokus.gmd.de)
	http://www.fokus.gmd.de/ovma/employees/sayegh/entry.html
	signal(SIGSEGV,SIG_IGN);

In article 
<Pine.A32.3.91.960205125307.49193A-100000@papin.HRZ.Uni-Marburg.DE>, 
saggauh@uni-marburg.de says...
>
>Also ich hab da mal ne Frage.
>In dem Buch von Lippman sind Beispiele angegeben, bei denen Jeweils der 
>Rueckgabewert eine Referenz ist.
>int& foo::operator[](int i){
>.....
>        return Element[1];
>}
>So in diesem Beispiel wird der Wert selber beim return angegeben.
>
>foo& foo::operator=(const foo& f){
>.....
>        return *this;
>}
>hier wird der Pointer angegeben.

Falsch - Der Pointer wird dereferenziert (durch den *), dadurch wird das
Objekt (bzw. dessen Referenz) zurueckgegeben.

>
>Wie entscheide ich nun, wenn ich eine Referenz zurueckgeben moechte, ob 
>ich den Pointer oder das Element zuueckgebe?

Gar nicht. Es wird immer das Objekt verwendet.

>
>Thanx
>Henning

	Joerg

Saggau Henning (saggauh@uni-marburg.de) wrote:
: Also ich hab da mal ne Frage.
: In dem Buch von Lippman sind Beispiele angegeben, bei denen Jeweils der 
: Rueckgabewert eine Referenz ist.
: int& foo::operator[](int i){
: .....
: 	return Element[1];
: }
: So in diesem Beispiel wird der Wert selber beim return angegeben.

: foo& foo::operator=(const foo& f){
: .....
: 	return *this;
: }
: hier wird der Pointer angegeben.

: Wie entscheide ich nun, wenn ich eine Referenz zurueckgeben moechte, ob 
: ich den Pointer oder das Element zuueckgebe?

: Thanx
: Henning

Hallo,
ob Du eine Referenz zur|ckbekommst oder einen Wert brauchst Du im wesentlichen
nicht entscheiden, Referenzen sind immer dann gut, wenn gro_e selbst geschaffene
Datentypen |bergeben werden m|ssen. referenzen auf Standardtypen sind 
normalerweise nicht erlaubt.

Im zweiten Beispiel wird nicht der Pointer, sondern das Objekt foo (also hier
eine Referenz auf das Objekt) zurueckgegeben. Damit entfaellt beim Rueck-
sprung der Aufruf des copy-constructors und des destructors.

Hoffentlich konnte ich Dir helfen :-)
wirbel@physik.tu-freiberg.de

frank

Hi,
Frank Wirbeleit (wirbel@orion.hrz.tu-freiberg.de) wrote:
: ob Du eine Referenz zur|ckbekommst oder einen Wert brauchst Du im wesentlichen
: nicht entscheiden, Referenzen sind immer dann gut, wenn gro_e selbst geschaffene
: Datentypen |bergeben werden m|ssen. referenzen auf Standardtypen sind 
: normalerweise nicht erlaubt.

Zwei Bemerkungen:
- die groesse der Objekte ist zwar schon interessant, wenn man
  entscheidet, ob man eine Referenz oder ein Objekt durchreicht.
  Allerdings sollte man beachten, dass man eine Referenz nur dann als
  Rueckgabewert benutzen kann, wenn das Objekt auf das man eine
  Referenz liefert nicht "automatic" (also auf dem Runtime-Stack
  angelegt) ist.

- Referenzen auf Built-in Typen (Standardtypen) sind
  selbstverstaendlich immer erlaubt und sogar gelegentlich noetig. Etwa
  der 'operator[]()' von einem 'bool'-Vektor liefert eine Referenz auf
  einen 'bool', damit man ein lvalue hat.
--
dietmar.kuehl@uni-konstanz.de
http://www.informatik.uni-konstanz.de/~kuehl
I am a realistic optimist - that's why I appear to be slightly pessimistic

wirbel@orion.hrz.tu-freiberg.de (Frank Wirbeleit) wrote:

>Saggau Henning (saggauh@uni-marburg.de) wrote:
>: Rueckgabewert eine Referenz ist.
>: int& foo::operator[](int i){
>: .....
>: 	return Element[1];
>: }
>: So in diesem Beispiel wird der Wert selber beim return angegeben.

>: foo& foo::operator=(const foo& f){
>: .....
>: 	return *this;
>: }
>: hier wird der Pointer angegeben.

>: Wie entscheide ich nun, wenn ich eine Referenz zurueckgeben moechte, ob 
>: ich den Pointer oder das Element zuueckgebe?

>nicht entscheiden, Referenzen sind immer dann gut, wenn gro_e selbst geschaffene
>Datentypen |bergeben werden m|ssen. referenzen auf Standardtypen sind 
>normalerweise nicht erlaubt.

Referenzen auf Standardtypen sind erlaubt ( oder wo steht das
Gegenteil und was hei\3t nromalerweise ? )
Wenn diese Aussage zutreffen w"urde, dann d"urfe doch folgendes auch
nicht gehen:

  int i = 5;
  int &j = i;
  j++;
  // i und j sind nun 6


Gruss
  J"org


-------------------------------------------------------------------------
Joerg P. Berger         
Hauptstrasse 111              66904 Bruecken                  
Fax:   ++49 6386-7802         EMail: jpb@guug.de
-------------------------------------------------------------------------