Referenz- und Wertparameter?

full-nand

Hallo

Ich blicke den Unterschied zwischen Referenz und Wert Parameter nicht (innerhalb Funktionen). Ich weiß nicht genau wie ich mein Problem beschreiben soll...Also es geht um die Rückgabe eines solchen Werts...

Ich geb mal ein Bsp: (Wertparameter)

int Summe (int a, int b, int c) 
{ 
int erg; 
erg=a+b+c; 
return erg; 
}

Ich les überall immer nur, dass der Wert "erg" halt der Funktion zurückgeliefert wird, aber was genau heißt das? Wo wird der Wert gespeichert oder wie kann man damit weiterarbeiten?

2. Bsp: (Referenz Parameter)

void LiesKlein (char &b) 
{ 
cout << "Bitte Kleinbuchstaben eingeben:"; 
cin >> b; 
while ((b<'a')||(b>'z')) 
{ cout <<"Das war kein Kleinbuchstabe.Bitte wiederholen:"; 
cin >> b; 
}} // KEIN RETURN !!!??? (klar wegen void, aber wie kann ich jetzt damit weiterarbeiten?!)

Bitte helft mir!

Sir Gossi

Wenn ein Parameter as Wert übergeben wird (Call by Value) wird er kopiert. Innerhalb der Funktion wird also mit einer Kopie gearbeitet. Beim zurückgeben wird die Kopie erneut kopiert.
{cpp]
int neu, alt;
neu = funktion(alt);
[/cpp]

Bei der Übergabe mit Referenzen oder Zeigern (Call by Reference) wird die Adresse des Objekts koiert, das du übergibst, du arbeitest also mit dem ORIGINAL-Objekt.

int variable;
funktion(variable);
// variable wurde innerhalb der Funktion verändert und nicht kopiert.

destinator007

Du musst diese Funktionen ja irgendwo aufrufen!

zum Beispiel in der main-funktion (="Hauptteil des Programms"):

int main()
{
  int meineSumme;

  meineSumme=Summe( 1, 2, 3 );   //<--jetzt bekommt die Variable 
                                 //  "meineSumme" den Wert 6 von der 
                                 //  Funktion zugewiesen
}

int a, int b und int c heißen hier Werteparameter, weil die Variablen a, b und c selbst NICHT nach außen zurückgegeben werden. Sie "transportieren" nur die Zahlen 1,2 und 3 in die Funktion "Summe" hinein

..bei der 2. Funktion ist es genau umgekehrt.
Die Funktion selbst liefert keinen Wert zurück, wenn man sie im Hauptprogramm aufruft (wegen void). Aber ihr Parameter "b", den du ja beim Aufruf angeben musst, wird in ihr verändert und zurückgegeben:

int main()
{
  char meinBuchstabe;

  LiesKlein( meinBuchstabe );  //<-- "meinBuchstabe" bekommt jetzt einen Wert
                               //    von der Funktion zugewiesen!

}

desti

Mal ne Frage: Optimieren eigentlich gänge Compiler Konstrukte wie:

struct BigStruct foo(int bar)
{
    struct BigStruct bs;
    // (...)
    return bs;
}

zu

void foo(struct BigStruct * bs, int bar)
{
    // (...)
}

Bashar

Jep, das nennt sich (Named) Return Value Optimization.

full-nand

Ok, vielen Dank erstmal!
Ich hoffe ich habs jetzt verstanden. Muss mal ein bisschen damit "rumspielen". Wenn dann noch Probleme auftauchen meld ich mich wieder

@einer
Mach doch einen eigenen Thread auf und das passt auch überhaupt nicht zu meinem Thema!

Erhard Henkes

Damit du auch was zum Spielen hast:

#include <iostream>
#include <conio.h>
using std::cout;
using std::endl;

//globale Variablen
int a = 1; 
int b = 2;

void ausgabe()
{
    cout << &a << ": " << a << "\t " << &b << ": " << b  << endl << endl;
}

void erfolgloser_swap( int x, int y ) // by Value
{
  cout << "Kopien auf dem Stack: " << endl;
  cout << &x << ": " << x << "\t " << &y << ": " << y << endl;

  int temp = x;
  x = y;
  y = temp;

  cout << &x << ": " << x << "\t " << &y << ": " << y << endl;
  cout << "swap nur lokal erfolgreich." << endl;
}

void zeiger_swap( int * x, int * y ) // C-Lösung
{
  int temp = *x; // Inhalts-Operator // Dereferenzierungs-Operator
  *x = *y;
  *y = temp;
}

void referenzen_swap( int & x, int & y ) // C++-Lösung
{
  int temp = x;
  x = y;
  y = temp;
}

int main()
{ 
    cout << "Ausgangssituation: " << endl;
    ausgabe();

    cout << "Tausch mittels std::swap(x,y): " << endl;            
    std::swap(a,b); // Methode der Wahl aus der STL
    ausgabe();

    cout << "Tausch mittels Zeiger: " << endl;            
    zeiger_swap(&a, &b);
    ausgabe();

    cout << "Tausch mittels Referenzen: " << endl;            
    referenzen_swap(a,b);
    ausgabe();

    cout << "Erfolgloser Tausch, da nur lokale Kopien getauscht werden." << endl;            
    erfolgloser_swap(a,b);
    ausgabe();

    getch();
}