pascal! procedure P(y:real;var z: real);?????

[db_fisi99]

abend teilnehmer!kann mir jemand sagen was das var innerhalb

der klammer der procedure P(y:real;var z: real); im zusammenhang mit z bewirkt!?

und warum am ende y=3 ist?

danke!

-----------------------------------------------------------

var x,y,z:real;

function F(x:real):real;

begin

z:=x+z;

F:=z+5.0;

end;

procedure P(y:real;var z: real);

begin

x:=F(z);

z:=y+z;

end;

begin

x:=1.0;y:=2.0;z:=3.0;

P(x,y);

writeln('x=',x:5:1,'y=',y:5:1,'z=',z:5:1);

end.

-----------------------------------

[Staplerfahrer Klaus]

das bewirkt, das du eine lokale variable y und z iniziierst, die nur innerhalb dieser procedure gültig ist.

mit dem aufruf P(x, y) "überspielst" du die globalen variablen x und y auf die lokalen variablen y und z.

wenn du jetzt innerhalb der procedure P mit y rechnest, veränderst du das LOKALE y und NICHT das globale y!

[db_fisi99]

das ist schon mal hilfreich,aber was ich meine ist: was macht den unterschied in der dekleration zwichen y:real und var z: real aus?ausser das y und z verschiedene lokale variablen sind!

[Staplerfahrer Klaus]

ach so!

hab ich gar nicht gesehen. in dem einen fall nimmst du eine vorhandene variable und im annern (var..) deklarierst du eine. das sollte es sein.

wenn nicht, weiß ich auch nicht weiter

[murph]

hallo db_fisi99,

deine frage ist absolut sinnvoll und wichtig. bei einer deklaration der art:

procedure CallByValue(Val: Integer);

handelt es sich um eine Parameterübergabe per Value. D. h. in der Routine CallByValue kannst die variable Val verändern, ohne das dies auswirkungen auf die Variable hat, die im aufrufenden teil steht.

procedure CallByReferenz(var Val: Integer);

hierbei handelt es sich um eine Parameterübergabe per Referenz. das ist im prinzip nix anderes als ein Zeiger. Es folgt ein beispiel:

procedure CallByReferenz(var Val: Integer);

begin

Val := 5000; {Schreibt in die Variable i des aufrufenden Programm-teils den Wert 5000, da Val eine Referenz auf i (Pointer) ist.}

end;

procedure AufrufenderProgrammTeil;

var

i: Integer;

begin

i := 5;

CallByReferenz(i);

ShowMessage(IntToStr(i));

//i hat nun nicht den Wert 5, sondern den Wert 5000;

end;

Ohne die var-Deklaration würde die MessageBox den Wert 5 ausgeben, da die Zuweisung Val := 5000 nur im Programmblock CBR(...) gültig wäre, nicht mehr aber im aufrufenden Teil.

Auf diese weise lassen sich proceduren schreiben, die mehr als einen Wert zurückliefern (eine function kann immer nur einen wert zurückliefern, nämlich Result). benötigt man aber eine Routine die mehr als einen Wert an die aufrufende stelle zurückliefert kann man die durch Parameterübergabe ByReferenz erreichen:

procedure Result_A_B(var A: Integer; var B: Integer);

begin

A := A * A;

B := B * B;

end;

procedure CalcRechteck_A_B;

var

RechteckA, RechteckB: Integer;

begin

RechteckA := 5;

RechteckB := 25;

Result_A_B(RechteckA, RechteckB);

ShowMessage('Fläche von A beträgt: ' + IntToStr(RechteckA));

ShowMessage('Fläche von B beträgt: ' + IntToStr(RechteckB));

end;

Bei einer var-übergabe wird also ein ZEIGER auf die variable der aufrufenden stelle übergeben, NICHT der Wert der variablen.

Diese aussagebn kannst du ganz einfach überprüfen, indem du die routine CalcRechteck_A_B; in einem ButtonClick-Handler unterbringst. So kannst du auch gleich prüfen, was geschieht wenn du genau das selbe machst, ohne mit var-deklarierten Übergabeparametern. das var hat also nichts mit einer deklaration zu tun, zumindest nicht, wenn dies in der parameterlieste einer routine steht. ich hoffe das war einigermassen gut und verständlich erklärt.

mfg

murphy