Variablenübergabe - erklärt mir das einer?

[Amandus]

Hallo

Wir programmieren seit Schulbeginn mit Borland Delphi 6. Ich komm eigentlich ganz gut damit klar, habe aber eine Frage bezüglich der Variablenübergabe. Ich schreibe das Beispielprogramm rein und hab dann spezifische Fragen:

Delphi-Quellcode:

program V_ADD2;    // Vektoraddition mit Unterprogramme
{$APPTYPE CONSOLE}
uses
  SysUtils;

type vektor=array[1..3] of integer;
      //benutzerdef. Variablentyp

var  a, b, c : vektor;
     
procedure eingabe (ch:char;var v:vektor);
var i:integer;
 begin
  writeln('Vektoreingabe ',ch,'.Vektor:');
  writeln;
   for i:=1 to 3 do
      begin
        write(i,'-te Koordinate = ');
        readln(v[i]);
      end;
 end;

procedure vektoraddition (v1,v2:vektor; var v3:vektor);
var i : integer;
 begin
  for i:=1 to 3 do v3[i]:=v1[i]+v2[i];
 end;

procedure ausgabe (v:vektor);
var i:integer;
 begin
  writeln('Der Summenvektor lautet:');
  writeln;
   for i:=1 to 3 do writeln(i,'-te Koordinate = ',v[i]);
 end;

begin
  writeln('VEKTORADDITION');
  writeln('==============');
  writeln;
  eingabe('1',a);
  eingabe('2',b);
  vektoraddition(a,b,c);
  ausgabe(c);
  writeln;
  writeln('RETURN zum Beenden!');
  readln;
end.

1. procedure eingabe: Also die Variable ch bekommt vom Unterprogramm den Wert 1 zugewiesen. Aber: Warum rechnet man in "eingabe" nicht gleich mit der Variable "a", wieso verwendet man "v"? Ich habe gelesen, dass im Unterprogramm die Variablen, die übergeben werden, neu bezeichnet werden sollen, aber warum? Was passiert da? (in einfachen Worten, wenn's geht)
Wieso kann das Unterprogramm überhaupt mit v rechnen? v ist doch nirgends deklariert?

2. procedure vektoraddition: Was passiert da mit den Variablen? Wie werden die hin- und hergeschaufelt? Ich habe schon gegoogelt, aber das wesentliche nie verstanden, wenns um Variablenübergabe ging...

3.procedure ausgabe: "... Koordinate = ',v[ i ]]; ..." - Wie kann hier mit v gerechnet werden, wo v doch gar nicht deklariert wird?

Ich bin für euren Rat schon im Voraus dankbar,
Amandus

[edit=Admin]Delphi-Code bitte in die Tags [ delphi] und [ /delphi] stecken. Danke. Mfg, Daniel[/edit]
[edit=Admin] Mfg, Daniel[/edit]

[Christian S.]

Hallo!

Ich gehe jetzt einfach mal die Fragen durch.

(1) Weshalb mit im Unterprogramm nicht gleich mit "a" rechnet wird schon in Deinem eigenen Programm klar. Dann müsstest Du für "b", welches Du ja auch noch einmal mit dem gleichen Unterprogramm einliest, das ganze noch einmal schreiben. Und so, wie es jetzt ist, kannst Du jeden beliebigen Vektor einelesen!
Deklarieren musst Du den Vektor v nicht, denn dadurch, dass Du ihn als Parameter angegeben hast, ist er im Unterprogramm schon deklariert.

(2) An die Prozedur "Vektoraddition" werden drei Parameter übergeben. Die ersten beiden sind die Vektoren, die addiert werden sollen und der dritte ist der Ergebnisvektor. Dabei ist zu beachten, dass vor dem Ergebnisvektor das Wörtchen "VAR" steht. Das bedeutet, dass wenn Du - wie es in Deinem Beispiel geschieht - eine Variable c (die im Hauptprogramm deklariert ist) an diese Prozedur als Ergebnisvektor übergibst, jede Änderung, die im Unterprogramm an dieser Variable gemacht wird, auch im Hauptprogramm erscheint. Man sagt, die Variable wird "als Referenz" übergeben. Die beiden ersten Variablen werden "als Wert" übergeben. (Fachbegriffe "call by reference" und "call by value").
Um es deutlicher zu machen: da Du c "als Referenz" übergeben hast, werden die Zuweisungen, die im Unterprogramm "Vektoraddition" gemacht werden, für c auch im Hauptprogramm gelten.
Effektiv wird in der Vektoraddition also nur jeden Komponente von a mit der entsprechenden Komponente in b addiert wird und das Ergebnis in der entsprechenden Komponente in c gespeichert wird ... und dies auch im Hauptprogramm in c zu sehen ist.

(3) siehe (1)

So, ich hoffe ein wenig Klarheit geschafft zu haben. Wenn nicht, denk dran: es ist schon spät!

mfG
Peter

//edit: Ach ja: Willkommen im Forum!

[Amandus]

Danke für die Antwort, jetzt ist's mir ein bisserl klarer.

Ein anderes Beispiel: Ich gebe die Variablen a,b ans Unterprogramm. Dort rechne ich a,b auf ein Zwischenergebnis o und aus dem dann c. "o" wird nur im Unterprogramm verwendet, ist also eine lokale Variable von der procedure. "c" ist aber später im Hauptprogramm interessant.

Welche Parameter muss ich dann in den Parameterkopf schreiben?

stimmt das:

Code:

procedure unterprogramm(m,n:real;var p)
var o:real; 
begin
  o:=a+b;
  p:=o*pi
end;

.
.
.

begin
  .
  .
  .
  unterprogramm(a,b,c)
  .
  .
  .
end.

Also a entspricht m, b entspricht n und c - das Ergebnis - entspricht p. Wenn ich später p erneut in einem Unterprogramm verwende, muss ich es wieder mit unterprogramm2(c) übergeben, oder? Da c ja der Wert von p "überwiesen" wurde.

Amandus

[Christian S.]

Dein Unterprogramm ist noch nicht ganz richtig. Denn im Unterprogramm willst Du ja nicht mit den Variablen a und b arbeiten (die im Hauptprogramm deklariert wurden), sondern mit den Parametern m und n. Auch hast Du vergessen p einen Typen zuzuweisen. Es muss also heißen:

Delphi-Quellcode:

procedure unterprogramm(m,n:real;var p : real) 
var o:real; 
begin 
  o:=m+n; 
  p:=o*p; 
end;

Zu Deiner letzten Frage muss ich dann doch nochmal was weiter ausholen und meine vorigen Erklärungen ergänzen. Also noch einmal zu "call by reference": Wenn Du schreibst, der Wert von p an c überwiesen wird, ist das nicht ganz korrekt. (Kannste ja auch nicht wissen.) Denn im Grunde genommen ist p nur ein Zweitname für c.
Eine Variable ist ja eigentlich nur ein Speicherbereich. Und mit "c" sagst Du dem Compiler nur, auf welchen Bereich im Speicher er zugreifen soll. Wenn Du nun eine Variable durch "call by reference" übergibst (z.B. als p), dann greifst Du mit "p" auf denselben Speicherbereich zu wie mit "c". Der Wert von p wird also nicht an c "überwiesen", sondern der Wert p ist der Wert von c.

Ich hoffe, das alles nicht zu viel auf einmal!

MfG
Peter

[Amandus]

Das hast du aber schön erklärt. Danke. Natürlich sollte das im Unterprogramm m und n heißen, statt a und b.

[Amandus]

Hallo again

Ich habe noch eine Frage:

Code:

procedure unterprogramm(var u_zahl:integer);
  begin
    u_zahl:=u_zahl*7;
  end;

begin
  .
  .
  .
  zahl:=5;
  unterprogramm(zahl);
  .
  .
  .
end.

Im Hauptprogramm wird "zahl" der Wert 5 zugewiesen. Dann wird Das Unterprogramm aufgerufen, in dem zahl mit 7 multipliziert wird. Dann gibt das Unterprogramm die Variable wieder an das Hauptprogramm zurück, in dem zahl dann 7x größer ist, als vor dem Unterprogramm.

Wieso aber weiß das Unterprogramm von "zahl"? zahl wird doch nur per "var u_zahl:integer" an das Hauptprogramm zurückgegeben aber nicht hineingegeben?! Wird eine Variable per var herausgegeben UND hineingegeben?

Fragen: Warum heißt es nicht:

Code:

procedure unterprogramm(zahl:integer;var u_zahl:integer);
  begin
    u_zahl:=u_zahl*7;
  end;

begin
  .
  .
  .
  zahl:=5;
  unterprogramm(zahl,zahl);
  .
  .
  .
end.

Ich weiß, dass das erste Beispiel funktioniert, finde es aber seltsam, da man "zahl" doch auch hineingeben sollte. Sorry für die etwas laienhafte Wortwahl, aber ich hab noch keinen Programmierer-Slang.

Amandus

[fkerber]

Hi!

Also ich glaub grundsätzlich mal, neue Frage nuer Thread, aber ich guck trotzdem mal

Also im Kopf der Prozedur werden keine Rückgaben angegeben (also bei dem 2. Beispiel machst du 2 Übergaben, und nicht 1 und 1). Für Rückgaben braucht man function

Wie allerdings beim 1. Beispiel der neue Wert wieder in Zahl kommen soll ist mir nicht begreiflich!
Nachdem was da steht ist Zahl nachher immer noch 5 und u_zahl 35

Sollte es vielleicht heißen

zahl:=u_zahl*7 (dann müsste aber Zahl ne globale Variable sein, was ich für unwahrscheinlich halte)

Ciao fkerber

[Christian S.]

Hallo!

@fkerber: call by reference ist Dir schon bekannt, oder? Und der Gebrauch von "VAR"?

So, zur Erklärung. Dazu erst einmal noch mal aus meinem letzten Posting:

Zitat von Peter Lustig:

Zu Deiner letzten Frage muss ich dann doch nochmal was weiter ausholen und meine vorigen Erklärungen ergänzen. Also noch einmal zu "call by reference": Wenn Du schreibst, der Wert von p an c überwiesen wird, ist das nicht ganz korrekt. (Kannste ja auch nicht wissen.) Denn im Grunde genommen ist p nur ein Zweitname für c.
Eine Variable ist ja eigentlich nur ein Speicherbereich. Und mit "c" sagst Du dem Compiler nur, auf welchen Bereich im Speicher er zugreifen soll. Wenn Du nun eine Variable durch "call by reference" übergibst (z.B. als p), dann greifst Du mit "p" auf denselben Speicherbereich zu wie mit "c". Der Wert von p wird also nicht an c "überwiesen", sondern der Wert p ist der Wert von c.

So. Hier geht es geanuso. Sagen wir, "zahl" zeigt im Hauptprogramm auf den Speicherbereich Nr. 42. Dann bewirkt das "VAR" in der Parameter-Übergabe, dass "u_zahl" im Unterpogramm ebenfalls auf Speicherbereich Nr. 42 zeigt. Damit wird jede Aktion, die an "u_zahl" vorgenommen wird, auf dem Speicherbereich 42 vorgenommen.
Da jedoch im Hauptprogramm "zahl" ja immer noch auf Speicherbereich 42 zugreift, ändere ich mit dem Unterprogramm den Inhalt von "zahl". Wie gesagt: "u_zahl" ist nur ein Zweitname für den Speicherbereich von "zahl".

Wenn Du das "VAR" nicht im Parameter hättest, würde das nicht funtionieren. Dann würde für "u_zahl" im Unterprogramm ein eigener Speicherbereich (z.B. Nr. 43) eingerichtet und der Wert von "zahl" in diesen Speicherbereich kopiert. Da jedoch "u_zahl" jetzt mit Speicherbereich 43 arbeitet, "zahl" aber mit 42, würden die Änderungen auf "zahl" keine Auswirkung haben. Wie gesagt: nur wenn das "VAR" nicht dort steht. Das wäre dann "call by value", weil der Wert kopiert wird.

MfG
Peter

MfG
Peter

[fkerber]

ich hab das var überlesen *schäm*
tja uups
schieben wir es mal auf meine Signatur oder reden uns damit raus, dass kein Syntaxhighlighting eingesetzt war!!!

Aber im Endeffekt muss ich wohl lesen lernen

Sorry für die falschen Ausführungen.

[Christian S.]

Macht ja nichts! Hat mich halt nur irgendwie gewundert. Das überlesene Wörtchen erklärt es natürlich.