# referenz/zeiger als rückgabewert



## janomerico (15. Oktober 2003)

edit: im untersten post wurde meine frage deutlicher gestellt


----------



## Thomas Kuse (15. Oktober 2003)

Du kannst z.B. sowas auch schreiben:


```
void name(int& zahl){
  zahl+=1;
}

main(){
  int nummer=1;

  name(nummer);
}
```

Das ist der richtige referenz-Funktions-Aufruf.


----------



## janomerico (15. Oktober 2003)

ich glaube das hast du falsch verstanden. Hmm...vielleicht versteht ihr es so:


```
1 int normal(int);
2 int& mirreferenz(int);
3
4 int main()
5 {
6 int argument = 3;
7
8 int ergebnis;
9
10 ergebnis = normal(argument);
11
12 ergebnis = mitreferenz(argument);
13 }
14
int normal(int p)
{
return 2*p
}

int& mitreferenz(int p)
{
return 3+p
}
```

Und nun zur Anweisung in Zeile 10:


```
ergebnis = normal(argument);
```

der RWert kann man auswerten, das ergibt dann


```
ergebnis = 2*argument;
```

weil die Funktion ja genau das zurückgibt.

Wie aber wertet man den RWert in dieser Anweisung aus? (Zeile 12)


```
ergebnis = mitreferenz(argument);
```

Hoffe das ist jetzt deutlicher


----------



## XChris (16. Oktober 2003)

*Tip*

Um die Übergabewerte bzw. Rückgabewerte zu schützen sollte man, wenn es sinnvoll ist das Wörtchen CONST  benutzen.

Genau zu dieser Fragetselltung gab es HIER   schon mal eine Diskussion.

Chris


----------



## janomerico (16. Oktober 2003)

danke aber das oben war nur um die Frage deutlicher zu machen, also nur schnell hingeschrieben, die leider immer noch unbeantwortet ist.

Und ich habe eine neue Frage, hier nochmal alles zusammengefasst:

wann gibt man in einer Funktion eine Referenz zurück? Und wie wird der Aufruf in einer Anweisung ausgewertet ?

hier mal z.b. ein Listing aus dem Buch C++ in 21 Tagen:


```
4:      #include <iostream.h>
5:
6:      class CAT
7:      {
8:          public:
9:               CAT();                         // Standardkonstruktor
10:    // Aus Platzgruenden auf Kopierkonstruktor und Destruktor verzichtet!
11:               int GetAge() const { return *itsAge; }
12:               int GetWeight() const { return *itsWeight; }
13:               void SetAge(int age) { *itsAge = age; }
14:               CAT & operator=(const CAT &);
15:
16:          private:
17:               int *itsAge;
18:               int *itsWeight;
19:     };
20:
21:     CAT::CAT()
22:     {
23:          itsAge = new int;
24:       itsWeight = new int;
25:       *itsAge = 5;
26:       *itsWeight = 9;
27:  }
28:
29:
30: CAT & CAT::operator=(const CAT & rhs)
31: {
32:    if (this == &rhs)
33:       return *this;
34:    *itsAge = rhs.GetAge();
35:    *itsWeight = rhs.GetWeight();
36:    return *this;
37: }
38:
39:
40:     int main()
41:     {
42:          CAT frisky;
43:          cout << "Alter von Frisky: " << frisky.GetAge() << endl;
44:          cout << "Alter von Frisky auf 6 setzen...\n";
45:          frisky.SetAge(6);
46:          CAT whiskers;
47:          cout << "Alter von Whiskers: " << whiskers.GetAge() << endl;
48:          cout << "Frisky in Whiskers kopieren...\n";
49:          whiskers = frisky;
50:          cout << "Alter von Whiskers: " << whiskers.GetAge() << endl;
51:          return 0;
52:     }
```

nun zur Funktion die eine Referenz zurückgibt: (Zeile 30)


```
30: CAT & CAT::operator=(const CAT & rhs)
31: {
32:    if (this == &rhs)
33:       return *this;
34:    *itsAge = rhs.GetAge();
35:    *itsWeight = rhs.GetWeight();
36:    return *this;
37: }
```

Und wenn wir gerade dabei sind: wenn man einen dereferenzierten Zeiger zurückgibt, muss man den Rückgabewert dann auch als Zeiger angeben?

Wieso wird bei der obigen Funktion der Rückgabewert als Referenz definiert, wenn man doch einen dereferenzierten Zeiger zurückgibt?

Und noch eine Frage, wenn man in einer Funktion eine lokale Referenz definiert, und diese dann zurückgibt, wie muss der rückgabetyp lauten?

also z.b. hier:


```
// int& funktion()
// oder
// int funktion()
{
int b = 5;
int &ref = b;
return ref;
}
```


----------

