Was ist der Unterschied zwischen der Übergabe per Referenz und der Übergabe per Wert?

Question

Was ist der Unterschied zwischen

1. ein als Referenz übergebener Parameter
2. einen als Wert übergebenen Parameter?

Könnten Sie mir bitte einige Beispiele nennen?

Answer 1

1. Pass By Value / Call By Value

   void printvalue(int x) 
   {
       x = x + 1 ;
       cout << x ;  // 6
   }

   int x = 5;
   printvalue(x);
   cout << x;    // 5

Wenn Sie beim Aufruf nach Wert einen Wert an printvalue(x) d.h. das Argument, das 5 wird sie kopiert nach void printvalue(int x) . Jetzt haben wir zwei verschiedene Werte 5 und der kopierte Wert 5 und diese beiden Werte werden an verschiedenen Speicherplätzen gespeichert. Wenn Sie also eine Änderung innerhalb von void printvalue(int x) wird es nicht auf das Argument zurückfallen.

2. Übergabe durch Verweis/Aufruf durch Verweis

   void printvalue(int &x) 
   {
      x = x + 1 ;
      cout << x ; // 6
   }

   int x = 5;
   printvalue(x);
   cout << x;   // 6

Beim Call by Reference gibt es nur einen Unterschied. Wir verwenden & d.h. der Adressoperator. Dadurch
void printvalue(int &x) beziehen wir uns auf die Adresse von x was uns sagt, dass sich beide auf denselben Ort beziehen. Daher werden alle Änderungen, die innerhalb der Funktion vorgenommen werden, auch außerhalb wiedergegeben.

Jetzt, wo Sie hier sind, sollten Sie auch wissen, dass ...

3. Pass By Pointer/ Call By Address

   void printvalue(int* x) 
   {
      *x = *x + 1 ;
      cout << *x ; // 6
   }

   int x = 5;
   printvalue(&x);
   cout << x;   // 6

Bei der Adressübergabe wird der Zeiger int* x enthält die ihm übergebene Adresse printvalue(&x) . Daher spiegeln sich alle Änderungen, die innerhalb der Funktion vorgenommen werden, auch außerhalb wider.

Answer 2

Hier ist ein Beispiel, das die Unterschiede zwischen Übergabe nach Wert - Zeigerwert - Referenz :

void swap_by_value(int a, int b){
    int temp;

    temp = a;
    a = b;
    b = temp;
}   
void swap_by_pointer(int *a, int *b){
    int temp;

    temp = *a;
    *a = *b;
    *b = temp;
}    
void swap_by_reference(int &a, int &b){
    int temp;

    temp = a;
    a = b;
    b = temp;
}

int main(void){
    int arg1 = 1, arg2 = 2;

    swap_by_value(arg1, arg2);
    cout << arg1 << " " << arg2 << endl;    //prints 1 2

    swap_by_pointer(&arg1, &arg2);
    cout << arg1 << " " << arg2 << endl;    //prints 2 1

    arg1 = 1;                               //reset values
    arg2 = 2;
    swap_by_reference(arg1, arg2);
    cout << arg1 << " " << arg2 << endl;    //prints 2 1
}

Die Methode "Übergabe durch Referenz" hat eine wichtige Einschränkung . Wenn ein Parameter deklariert ist als durch Referenz übergeben (also mit vorangestelltem &-Zeichen) seine entsprechende der tatsächliche Parameter muss eine Variable sein .

Ein aktueller Parameter, der sich auf den formalen Parameter "passed by value" bezieht, kann sein ein Ausdruck im Allgemeinen, so dass nicht nur eine Variable, sondern auch ein Literal oder sogar das Ergebnis eines Funktionsaufrufs verwendet werden kann.

Die Funktion ist nicht in der Lage, einen Wert in etwas anderes als eine Variable zu setzen. Sie kann einem Literal keinen neuen Wert zuweisen oder einen Ausdruck zwingen, sein Ergebnis zu ändern.

PS: Sie können sich auch die Antwort von Dylan Beattie im aktuellen Thema ansehen, die das Ganze in einfachen Worten erklärt.

Answer 3

Die Frage lautet "vs".

Und niemand hat auf einen wichtigen Punkt hingewiesen. Bei der Übergabe mit Werten wird zusätzlicher Speicher belegt, um die übergebenen Variablenwerte zu speichern.

Bei der Übergabe mit einer Referenz wird kein zusätzlicher Speicher für die Werte belegt (unter Umständen speichereffizient).