referenz/zeiger als rückgabewert

[janomerico]

edit: im untersten post wurde meine frage deutlicher gestellt

 

[Thomas Kuse]

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]

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]

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]

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;
}