Ich verstehe den Unterschied von Call-By-Reference .. nicht

[kujin1000]

Hi leute,
kann mir jemande bitte den Unterschied zwischen Call-By-Reference und Call-By-Value erklären?
Das Delphibuch erklärt es so verwirrend, ich verstehe es nicht. Könnt ihr versuchen es einfach zu erklären, denn
ich bin ja gerade dabei dies zu lernen und kenn mich nicht aus mit dynamische Arrays etc.
Alles ist erstmal auf Funktionen bezogen: sprich function name(var blubb oder ohne var...
Vielen Danke auf die Antworten

[mkinzler]

Bei Call_By_Reference wird ein Zeiger auf die Variable übergeben, bei Call_By_Value ihren Wert.

[toms]

Zitat von kujin1000:

Hi leute,
kann mir jemande bitte den Unterschied zwischen Call-By-Reference und Call-By-Value erklären?

1.2 Prozeduren mit Wertübergabe (call by value)

1.3 Prozeduren mit Variablenübergabe (call by reference)]1.2 Prozeduren mit Wertübergabe (call by value)

[kujin1000]

Kannst du mir bitte ein Beispiel zeigen?
Verstehe das mit dem Zeiger nicht, denn ich verstehe unter einem Zeiger z.b. bei der Funktion Copy.
Der Zeiger zeigt bei welchem Buchstaben es abgeschnittet werden muss...

[mkinzler]

Delphi-Quellcode:

prodedure AlsRef( var a: Integer);
begin
    inc(a);
end;

procedure AlsWert( a: integer);
begin
   inc(a);
end;

..
a := 10;
AlsWert( a);
WriteLn(a); // Ausgabe 10
AlsRef( a);
WriteLn( a); //Ausgabe 11

Siehst du den Unterschied?

[kujin1000]

Zitat von mkinzler:

Delphi-Quellcode:

prodedure AlsRef( var a: Integer);
begin
    inc(a);
end;

procedure AlsWert( a: integer);
begin
   inc(a);
end;

..
a := 10;
AlsWert( a);
WriteLn(a); // Ausgabe 10
AlsRef( a);
WriteLn( a); //Ausgabe 11

Siehst du den Unterschied?

Ich würde es jetzt so verstehen, bei AlsWert ist es so dass a in der procedure 0 ist dann auf 1 (wegen inc)und dann wird a auf 10 gesetzt(wegen a:=10) und bei AlsRef verstehe ich das so, dass der Wert a:= 10 ins das proceduren a kommt und delphi auf 11 zählt. stimmt das?

[Namenloser]

[ot]Was ist der Unterschied zwischen einem Hund?[/ot]

In meinem Delphibuch (Delphi für kids) wurde das mithilfe einer Funktion erklärt, die zwei Variablen vertauschen sollte.

Delphi-Quellcode:

procedure Exchange(x,y: integer);
var
  tmp: integer;
begin
  tmp := y; // Wert von Y zwischenspeichern
  y := x;
  x := tmp;
end;

Diese Funktion könntest du jetzt z.b. so testen:

Delphi-Quellcode:

var
  a,b: integer;
begin
  a := 5;
  b := 42;
  ShowMessage(Format('a:%d; b:%d',a,b)); // Gibt aus: a:5; b:42
  Exchange(x,y);
  ShowMessage(Format('a:%d; b:%d',a,b)); // Gibt ebenfalls aus: a:5; b:42 
end;

Der Wert der Variablen wird also nur innerhlab von der Procedure Exchange verändert, weil sie mit Kopien der Variablen arbeitet. Das ganze ist so natürlich etwas witzlos, denn die Procedure soll ja die Variableninhalte austauschen.

Also schreiben wir das ganze etwas um:

Delphi-Quellcode:

procedure Exchange(var x,y: integer);
//                  ^-- Hierauf achten, bitte
var
  tmp: integer;
begin
  tmp := y; // Wert von Y zwischenspeichern
  y := x;
  x := tmp;
end;

Diesmal arbeitet die Funktion nicht mit einer lokalen Kopie sondern sozusagen "am lebenden Objekt", also direkt mit den Variablen, die wir als Parameter angegeben haben. Wenn du jetzt die Testprozedur nochmals ausführst, solltest du beim zweiten ShowMessage die vertauschten Werte bekommen.

@Kasten: ey... gemein, jetzt hab ich mir so viel Mühe gegeben

[mkinzler]

Nein. In beiden Fällen hat das in der Prozedur den Wert 10 und wird dann auf 11 erhöht. Es war ein Fehler von mir die Variable genauso wie den Parameter zu nennen

Delphi-Quellcode:

prodedure AlsRef( var x: Integer);
begin
    inc(x);
end;

procedure AlsWert( x: integer);
begin
   inc(x);
end;

..
a := 10;
AlsWert( a);
WriteLn(a); // Ausgabe 10
AlsRef( a);
WriteLn( a); //Ausgabe 11

Die lokale Variable x in AlsRef ist nun identisch mit mit a.
Das inc() wirkt sich auf sie aus.

[kujin1000]

achso
Hab es jetzt verstanden
danke!

[Luckie]

Zitat von kujin1000:

Verstehe das mit dem Zeiger nicht, denn ich verstehe unter einem Zeiger z.b. bei der Funktion Copy.
Der Zeiger zeigt bei welchem Buchstaben es abgeschnittet werden muss...

Das ist kein Zeiger im programmiertechnischen Sinne. Ein Zeiger "zeigt" auf einen Speicherbereich bzw. auf eine Adresse im Speicher. Rufst du eine Funktion mit call-by-reference auf, übergibst du als Parameter einen Zeiger auf eine Adresse im Speicher. Rufst du die Funktion mit call-by-value auf, übergibst du der Funktion als Parameter den Wert, der an dieser Adresse im Speicher abgelegt ist.

Änderst du nun in der Funktion einen Parameter, der mit call-by-referenz übergeben wurde, änderst du ihn direkt im Speicher. Die Änderung ist auch nach verlassen der Funktion gültig. Änderst du einen Parameter, der mit call-by-value übergeben wurde, arbeitet die Funktion mit dem Wert dieser Speicheradresse, den die Variable bezeichnet.