Verhalten bei Parameter-Übergabe

Spatzihasi · 13.08.2010

Hallo ihr Lieben,

Ich bin gerade dabei das Buch Einstieg in PHP 5.3 und MySQL 5.4 durchzuarbeiten. Bisher hats auch wirklich gut geklappt und war alles verständlich aber im Moment bin ein bisschen am Stutzen weil ich zum Teil zwar verstehe was dort gemacht wird aber wie ein Tausch von Variablen innerhalb eine Funktion stattfinden.

Ich hab hier mal den Code dafür und die Erklärungen die im Buch stehen:

PHP:

<html>
<head>
<title>Kopie und Referenz P250 </title>
</head>
<?php
   function vtauschen($a, $b)
   {
      $temp = $a;
      $a = $b;
      $b = $temp;
   }

   function rtauschen(&$a, &$b)
   {
      $temp = $a;
      $a = $b;
      $b = $temp;
   }
?>
<body>
<?php
   $x = 12;   $y = 18;
   echo "<p>Methode 1, vorher: $x, $y<br />";
   vtauschen($x,$y);
   echo "Methode 1, nachher: $x, $y</p>";

   $x = 12;   $y = 18;
   echo "<p>Methode 2, vorher: $x, $y<br />";
   rtauschen($x,$y);
   echo "Methode 2, nachher: $x, $y</p>";

   $x = 12;   $y = 18;
   echo "<p>Methode 3, vorher: $x, $y<br />";
   vtauschen(&$x,&$y);
   echo "Methode 3, nachher: $x, $y</p>";
?>
</body>
</html>

Die Erklärung dazu:

1. Der Wert der Variablen $x wird bei Aufruf der Funktion vtauschen() an die Variable $a übergeben. Der Wert der Variablen $y wird an die Variable $b übergeben. Innerhalb der Funktion vtauschen() werden $a und $b getauscht. Da aber nur die Kopien getauscht wurden, hat dies auf die Originale $x und $y keine Auswirkungen.

2. Den Unterschied sieht man im Funktionskopf function rtauschen(&$a, &$b). Die Variable $x wird bei Aufruf der Funktion rtauschen() per Verweis (Zeichen &) an die Variable $a übergeben. Die Variable $y wird per Verweis an die Variable $b übergeben. Innerhalb der Funktion werden $a und $b vertauscht. Dadurch werden auch die Originale $x und $y vertauscht.

3. Den Unterschied sieht man beim Aufruf der Funktion: vtauschen (&$x, &$y); Die Variable $x wird beim Aufruf der Funktion vtauschen() per Verweis (Zeichen &) an die Variable $a übergeben. Die Variable $y wird beim Aufruf per Verweis an die Variable $b übergeben. Innerhalb der Funktion werden $a und $b vertauscht. Dadurch werden auch die Originale $x und $y vertauscht.

Und hier der Text der Ausgabe im Browser:

Methode 1, vorher: 12, 18
Methode 1, nachher: 12, 18

Methode 2, vorher: 12, 18
Methode 2, nachher: 18, 12

Methode 3, vorher: 12, 18
Methode 3, nachher: 18, 12

***************************

Wie muss ich mir jetzt den Vorgang erklären, damit ich nachvollziehen kann das die Variablen getauscht wurden also von 12, 18 zu 18,12.

Wenn die ganzen Variablen vertauscht würden, also von $x und $y zu $y und $x würde ich das ja noch verstehen, aber so?

Vielleicht kann mir ja jemand helfen. Wäre toll

Danke schon mal

Viele Grüsse
Spatzihasi

KarlHH · 13.08.2010

AW: Verhalten bei Parameter-Übergabe

Bei der Funktion vtauschen wird der Wert der sich in $x befindet nach $a kopiert man kann sich das wie in $a = $x vorstellen.
Das Selbe mit $y und $b. In der Funktion vtauschen wird dann nur mit den Werten gearbeitet.

In der Funktion rtauschen wird aber nicht der Wert von $x an $a übergeben sondern die Adresse der Speicherstelle in der die Variable $x gespeichert ist.

Und deshalb passiert in der Funktion rtauschen eigentlich das folgende:

$temp = $x;
$x = $y;
$x = $temp;

Spatzihasi · 13.08.2010

AW: Verhalten bei Parameter-Übergabe

also ich kann mir das ehrlich gesagt ganz ganz schlecht vorstellen wie der tauschvorgang zustande geht.

ich kann ja erkennen das sich die parameter 2 x untereinander vertauschen in den funktionen.
aber wie der tauschvorgang der variablen vonstatten gehen soll keine ahnung.

tut mir leid

was wollen die mit dem $temp bezwecken?

würde es heissen das beim tausch anstatt:

PHP:

$temp = $a;
      $a = $b;
      $b = $temp;

steht:

PHP:

$temp = $b;
      $b = $a;
      $a = $temp;

Das wäre das einzige logische wie ich mir das erklären kann

und dann eben die Werte von den Variablen....

PHP:

$x  = 12;
$y = 18;

.... eingesetzt in die Funktion....

PHP:

$temp = $18;
      $18 = $12;
      $12 = $temp;

also wird dann bei der Ausgabe für x:

PHP:

$18

und für y:

PHP:

$12

genommen???

Ingesamt hatte ich mir das dann so vorgestellt:

PHP:

$18 = $12;

So dass dann die Ausgabe:

Methode 3, nachher: 18, 12

erscheint...?!

Meine Logik, sorry aber ich versuch mir das grad begreiflich zu machen.
Korrigiert mich wenn ich falsch liegen sollte

Chriss1987 · 13.08.2010

AW: Verhalten bei Parameter-Übergabe

Hi,

bei normalen Funktionen wie vtauschen werden die Parameter als KOPIE übergeben, d.h. Änderungen, die in der Funktion stattfinden, finden wirklich nur innerhalb der Funktion statt. Das liegt daran, dass innerhalb von Funktionen erzeugte Variablen NUR innerhalb der Funktion gültig sind, es handelt sich dabei also um LOKALE Variablen. Dazu ein Beispiel:

PHP:

<?php
// innerhalb einer Funktion erzeugte Variable
function foo()
{
    $eineVariable = "Wert";
}

foo();

echo $eineVariable; // Fehlermeldung, $eineVariable existiert nicht
?>

PHP:

<?php
// außerhalb einer Funktion erzeugte Variable 
// und versuchter Zugriff auf diese Variable innerhalb einer Funktion
$eineVariable = "Hallo, ich bin der 1. Wert";

function foo()
{
    $eineVariable = "Wert";
}

foo();

echo $eineVariable; // gibt "Hallo, ich bin der 1. Wert" aus
?>

Um eine zuvor definierte Variable in einer Funktion zu benutzen, gibt es das Schlüsselwort global:

PHP:

<?php
// außerhalb einer Funktion erzeugte Variable 
// und versuchter Zugriff auf diese Variable innerhalb einer Funktion
$eineVariable = "Hallo, ich bin der 1. Wert";

function foo()
{
    global $eineVariable; // hier wird gesagt, dass die globale Variable $eineVariable verwendet wird
    $eineVariable = "Wert";
}

foo();

echo $eineVariable; // gibt "Wert" aus
?>

Möchte man der Funktion Parameter übergeben und darin auf die übergebenen Variablen zugreifen,
bleiben Änderungen innerhalb der Funktion auch nur dort, die Übergebene Variable wird außerhalb der Funktion nicht verändert:

PHP:

<?php
// außerhalb einer Funktion erzeugte Variable 
// und versuchter Zugriff auf diese Variable
// innerhalb einer Funktion durch Übergabe der Variablen
$eineVariable = "Hallo, ich bin der 1. Wert";

function foo($bar)
{
    $bar = "Wert";
}

foo($eineVariable);

echo $eineVariable; // gibt "Hallo, ich bin der 1. Wert" aus
?>

Benötigt man jedoch Änderungen an Variablen innerhalb der Funktion auch außerhalb,
kann man die Variable als Referenz übergeben. Eine Referenz ist ein Verweis auf die globale Variable.
Dies hat zufolge, dass Änderungen der Variable innerhalb der Funktion auch die Variable außerhalb ändert.
Um eine Referenz statt einer Kopie zu übergeben, wird in der Parameterauflistung der Funktion vor den gewünschten Variablen ein "&" gesetzt:

PHP:

<?php
// außerhalb einer Funktion erzeugte Variable 
// und versuchter Zugriff auf diese Variable 
// innerhalb einer Funktion durch Übergabe der Variablen,
// jedoch Übergabe als Referenz
$eineVariable = "Hallo, ich bin der 1. Wert";

function foo(&$bar)
{
    $bar = "Wert";
}

foo($eineVariable);

echo $eineVariable; // gibt "Wert" aus
?>

PHP:

<?php
// außerhalb einer Funktion erzeugte Variable 
// und versuchter Zugriff auf diese Variable 
// innerhalb einer Funktion durch Übergabe der Variablen,
// jedoch Übergabe als Referenz
$eineVariable = "Hallo, ich bin der 1. Wert";

function foo($bar)
{
    $bar = "Wert";
}

foo(&$eineVariable); // funktioniert genauso...

echo $eineVariable; // gibt "Wert" aus
?>

Um auf dein Beispiel zurück zu kommen:
Methode 1. übergibt nur die Variablen, also wird von diesen eine KOPIE erzeugt, desshalb passiert außerhalb der Funktion nichts mit den Variablen und sie behalten ihren Wert.

Methode 2. übergibt die Variablen als Referenz, also wird ein Verweis auf die globalen Variablen gelegt und Änderungen der Variablen in der Funktion betreffen auch die Werte der globalen Variablen.

Methode 3. ist ähnlich wie Methode 2, jedoch wird erst beim Funktionsaufruf festgelegt, dass Referenzen übergeben werden sollen.

Der Schritt mit der $temp-Variablen ist notwendig, da sonst bei "$a = $b" "$a" sofort den Wert von "$b" annimmt und der alte Wert von "$a" unwiederbringlich überschrieben währe. So muss man den Wert von "$a" in einer Variablen, hier "$temp", zwischenspeichern.

Beim "="-Operator werden ja Werte, die rechts davon stehen, auf die Variablen links davon kopiert.

Ich hoffe, ich konnte ein wenig helfen...

Schöne Grüße aus dem Sauerland!
Chriss

aliasltb · 13.08.2010

AW: Verhalten bei Parameter-Übergabe

Das kannst du dir so vorstellen (ich nehme mal das Beispiel 2):

Du hast die Variablen $x=12 und $y=18 vordefiniert.
Anschließend wird die Funktion rtauschen($x, $y) aufgerufen.

Wie du deinem Text, den du uns hier gepostet hast, entnehmen kannst bezieht sich diese auf die Originalvariablen außerhalb der Funktion, weshalb diese sich verändern, sobald etwas innerhalb der Funktion tut.

Jetzt besteht das Problem, dass du in der Funktion nur die beiden Variablen $a und $b hast. (Dadurch dass die Variablen jeweils den Wert von $x und $y annehmen, kann es eventuell zu Verwirrungen kommen, aber letztendlich nimmt $a den Wert von $x und $b den Wert von $y an).

In der Funktion sollen ja die Werte der Variablen ausgetauscht werden. Wenn du jetzt einfach den Wert von $a der Variablen $b zuordnest, dann hast du in beiden Variablen den Wert von $a, da $b von $a überschrieben wurde. Also hast du keine Möglichkeit noch an den Wert von $b zu kommen.

Also bedient man sich einer dritten Variable, nämich in diesem Fall $temp.

So wird der Variable $temp temporär der Wert von $a zugeordnet.
Jetzt kann man wie oben beschrieben der Variablen $a den Wert von $b zuweisen.

Soweit haben wir also $temp = 12, $a = 18 und $b = 18.
Anschließend müssen wir dann nur noch wieder den $a in $temp gespeicherten Wert $b übergeben ($b = $temp) und somit ist der Austausch vollzogen ($temp = 12, $a = 18, $b = 12). Für alles weitere kannst du dann die Variable $temp vernachlässigen, da sie nicht mehr benötigt wird.

Da jetzt mit dem &-Zeichen mit den Parametern Bezug auf die Originalvariablen genommen wurde und diese sich verändern werden automatisch die neuen (überschriebenen) Werte von $x und $y verwendet, was dann letztendlich der Austausch war.

So ich hoffe das ist das Problem was du hattest. Ansonsten weiß ich nicht, wo du gerade am stocken bist. :eek:

Spatzihasi · 13.08.2010

AW: Verhalten bei Parameter-Übergabe

Das war mal eine verständliche Erklärung, vielen Dank

War denn meine Erklärung oben wie man zur Ausgabe 18,12 kommt einigermaßen trotzdem noch richtig?

Ich hab noch mal ein kleines Beispiel:

PHP:

<?php
   function rechne($a, $b, &$su, &$pr)
   {
      $su = $a + $b;
      $pr = $a * $b;
   }
?>
</head>
<body>
<?php
   $x = 7;
   $y = 5;
   rechne($x, $y, $summe, $produkt);
   echo "<p>Die Summe von $x und $y ist $summe</p>";
   echo "<p>Das Produkt von $x und $y ist $produkt</p>";
?>

Hier sind ja die Variablen

PHP:

$su

und

PHP:

$pr

unten bei der Ausgabe der Funktion rechner() ausgeschrieben als

PHP:

$summe

und

PHP:

$produkt

.

Heisst das das durch die Referenz

PHP:

&$su

und

PHP:

&$pr

die unterschiedliche Schreibweise der Variablen

PHP:

$su

und

PHP:

$pr

bzw.

PHP:

$summe

und

PHP:

$produkte

das richtige Ergebnis ausgeben? Denn wie in Deinen Beispielen zu erkennen, ignoriert das Script die Variable ausserhalb der Funktion wenn innerhalb der Funktion eine Referenz in einer Variable eingebettet ist, daher wird bei Deinen Beispielen "Wert" ausgegeben statt der Satz der Variable ausserhalb der Funktion.

Ich hatte selbst eben mal an dem Script ein bisschen getestet und verändert und das Ergebnis wurde nur in dieser Schreibweise richtig bzw überhaupt ausgegeben.

Spatzihasi · 13.08.2010

AW: Verhalten bei Parameter-Übergabe

aliasltb schrieb:
Soweit haben wir also $temp = 12, $a = 18 und $b = 18.
Anschließend müssen wir dann nur noch wieder den $a in $temp gespeicherten Wert $b übergeben ($b = $temp) und somit ist der Austausch vollzogen ($temp = 12, $a = 18, $b = 12). Für alles weitere kannst du dann die Variable $temp vernachlässigen, da sie nicht mehr benötigt wird.

hmm oben in meiner selbst erklärten methode ists genau umgekehrt wie ich es mir dachte und vorallem hab ich auf beiden seiten die zahlen vergeben und nicht wie du $a = 12 usw... aber eine gute erklärung ist das von dir

danke

ich glaub ich muss mir das einfach nochmal genau angucken

aliasltb schrieb:
So ich hoffe das ist das Problem was du hattest. Ansonsten weiß ich nicht, wo du gerade am stocken bist.

ja genau das war das problem. wie der tausch vonstatten gehen soll

ich habs mit php ziemlich schwer aber so langsam wirds

Chriss1987 · 13.08.2010

AW: Verhalten bei Parameter-Übergabe

Hi,
also wenn ich dich jetzt richtig verstanden hab, ja, das Ergebnis wird richtig ausgegeben, denn $summe und $produkt werden als Referenz übergeben. Die Namen für beide Variablen sind INNERHALB der Funktion $su und $pr. Versuchst du z.B. nach dem Funktionsaufruf außerhalb der Funktion auf $su und $pr zuzugreifen wird dir ein Fehler gemeldet, da diese beiden Variablennamen außerhalb der Funktion nicht gültig sind, genauso kannst du innerhalb der Funktion nicht auf die Variablen $summe und $produkt zugreifen, da die Funktion die Variablennamen nicht kennt (habs mal in das untere Bsp gepackt).
Allerdings solltest du die Variablen $summe und $produkt zuvor definieren, also bevor du sie einer Funktion übergibst:

PHP:

<?php
   function rechne($a, $b, &$su, &$pr)
   {
      $su = $a + $b;
      $pr = $a * $b;
      
      echo $summe; // gibt eine Fehlermeldung aus, da die Variable nicht existiert
      echo $produkt; // gibt eine Fehlermeldung aus, da die Variable nicht existiert
   }
?>
</head>
<body>
<?php
   $x = 7;
   $y = 5;
   $summe = 0;
   $produkt = 0;
   rechne($x, $y, $summe, $produkt);
   echo "<p>Die Summe von $x und $y ist $summe</p>";
   echo "<p>Das Produkt von $x und $y ist $produkt</p>";

   echo $su; // gibt eine Fehlermeldung aus, da die Variable nicht existiert
   echo $pr; // gibt eine Fehlermeldung aus, da die Variable nicht existiert
?>

Sonst könnten Fehler auftreten.

Schöne Grüße aus dem Sauerland!
Chriss

aliasltb · 13.08.2010

AW: Verhalten bei Parameter-Übergabe

Spatzihasi schrieb:
ja genau das war das problem. wie der tausch vonstatten gehen soll

ich habs mit php ziemlich schwer aber so langsam wirds

Okay kein Problem. Wobei dein Problem weniger mit PHP sondern mehr mit dem logischen Verständnis zu tun hatte. ^^

Spatzihasi · 13.08.2010

AW: Verhalten bei Parameter-Übergabe

Chriss1987 schrieb:
Allerdings solltest du die Variablen $summe und $produkt zuvor definieren, also bevor du sie einer Funktion übergibst:

hey, naja das script war so in den lösungen des buchs enthalten, da gabs keine definition der beiden variablen. wie könnte man denn sowas zb definieren?

aliasltb schrieb:
Okay kein Problem. Wobei dein Problem weniger mit PHP sondern mehr mit dem logischen Verständnis zu tun hatte. ^^

das problem hab ich schon immer mit logik, daher ist mir mathe früher schwer gefallen, da ich aber in meinem fernstudium verpflichtet bin php hefte durch zu arbeiten, sind zwar nur noch zwei, muss ich mir über ein buch hilfe holen, denn die hefte der fernschule sind schlecht ohne ende.

ist methode 3 denn genauso von der handhabung her oder sieht dort der tausch anders aus? ich war auch vorhin erst am überlegen woran ich ne kopie erkenne und woran das original. aber ich glaub das hab ich in den scriptbeispielen von chriss ganz gut verstanden. der eigeintliche tausch erfolgt doch an der 3. stelle also $b = $temp, wenn ich das richtig mitgekriegt hab, oder? hier werden den variablen werte zugewiesen: $temp = 12, $a = 18 und $b = 18 (vor dem tausch) und das was sich ändert ist der wert der bei $a in $temp eingegebene wert für $b also 12 ($temp = 12, $a = 18 und $b = 12)

bitte korrigier mich wenn ich wieder falsch liegen sollte. tut mir leid das ich das so schwer von begriff bin aber php ist echt horror für mich auch wenn einiges schon sehr viel besser geht wie bevor ich das buch angefangen habe.

aber deine erklärung war schon wirklich gut. jetzt wüsste ich nur noch gerne wo das zum einsatz kommt in der praxis. man weiss zwar wie das geht und das es referenzen gibt aber nicht in welchen praktischen anwendungsgebieten man das nutzt.

Chriss1987 · 16.08.2010

AW: Verhalten bei Parameter-Übergabe

Hallo,

wenn man die Funktion vtauschen() mal betrachtet und im Hinterkopf behält, dass php Scripte Zeile für Zeile abarbeitet,
würden die einzelnen Schritte so aussehen:

PHP:

<?php
$x = 10;
$y = 15;
1. function vtauschen($a, $b)
   {
2.    $temp = $a;
3.    $a = $b;
4.    $b = $temp;
   }
vtauschen($x, $y);
?>

1. Schritt: Funktion wird aufgerufen, dabei werden die Variablen $a und $b mit den Werten, die übergeben wurden, initialisiert. Angenommen, wir rufen die Funktion mit vtauschen($x, $y) auf und haben zuvor $x mit 10 und $y mit 15 definiert, dann sind in Zeile 1 folgende Variablen mit folgenden Werten definiert:
$a = 10 und $b = 15

2. Schritt: es wird eine lokale Hilfsvariable $temp definiert und mit dem Wert von $a vorbelegt. Folgende Variablen sind der Funktion mit folgenden Werten bekannt:
$a = 10, $b = 15 und $temp = 10

3. Schritt: jetzt wird der Wert von $b auf $a kopiert, der vorige Wert von $a wird dabei überschrieben. Also sind der Funktion folgende Variablen und Werte bekannt:
$a = 15, $b = 15 und $temp = 10

4. Schritt: hier wird deutlich, dass eine Hilfvariable notwendig ist, da nach dem vorigen Schritt beide Variablen den gleichen Wert haben. In diesem Schritt wird nun der zwischengespeicherte Wert von $a über die Hilfsvariable $temp auf $b kopiert, somit sind der Funktion folgende Variablen und Werte bekannt:
$a = 15, $b = 10 und $temp = 10

Somit ist der Tausch vollzogen. Werde die Variablen als Referenz an die Funktion übergeben, ändert sich im Ablauf nichts, jedoch werden Änderungen, also Wertezuweisungen auf die übergebenen Variablen mit angewendet. Hier nochmal die Werte und Variablen der Schritte 1.-4., wenn die Variablen als Referenz übergeben werden (es wird zwischen lokal, also IN der Funktion und global, außerhalb der Funktion unterschieden:

Code:

1. Schritt: lokal: $a = 10 und $b = 15; global: $x = 10 und $y = 15
2. Schritt: lokal: $a = 10, $b = 15 und $temp = 10; global: $x = 10 und $y = 15
3. Schritt: lokal: $a = 15, $b = 15 und $temp = 10; global: $x = 15 und $y = 15
4. Schritt: lokal: $a = 15, $b = 10 und $temp = 10; global: $x = 15 und $y = 10

In der Praxis werden z.B. Instanzen von Datenbankklassen als Referenz an Funktionen übergeben, somit wird sichergestellt, das die Verbindung nicht erneut aufgebaut wird und die Klasse vorige Anfragen weiterhin kennt. In einfachen Programmabläufen wird es mMn seltener verwendet, aber in der OOP sind Referenzen mitunter sehr nützlich, da Änderungen an Klassen-Variablen auch außerhalb der Funktionen gültig bleiben müssen. Hier ein kleines Beispiel einer Klasse "Party", nur um das mal grob zu veranschaulichen. Es wird eine neue Instanz der Klasse "Party" erstellt. Diese Instanz wird an eine Funktion übergeben, um die Party zu starten. Wäre die Übergabe an die Funktion nicht als Referenz erfolgt, wäre eine neue Instanz der Klasse "Party" angelegt worden und die Änderung in der Funktion, also dass die Party gestartet wird, würde nicht außerhalb der Funktion startePartyExtern() bekannt werden... (Hoffe, das verwirrt nicht mehr als es hilft, wenns zu verwirrend ist, einfach überlesen, hat auch nicht viel mit dem eigentlichen Problem zu tun, aber als kleine Veranschaulichung hoffentlich doch ganz gut...)

PHP:

<?php
class Party
{
    var $anzahlPersonen = 10;
    var $partyOrt = "bei mir";
    var $partyStarted = false;
    
    function Party()
    {
    }
}

$bigParty = new Party();

function startePartyVonExtern(&$party)
{
    $party->partyStarted = true;
}

startePartyVonExtern($bigParty);
?>

Schöne Grüße aus dem Sauerland!
Chriss

P.S.: Variablen werden mit dem Zuweisungsoperator definiert, also nichts anderes als:

PHP:

$var = 'Wert';

In deinem Fall also z.B.:

PHP:

$produkt = $summe = 0;

So wird (da von rechts nach links interpretiert wird) $summe der Wert 0 zugewiesen und anschließend $produkt der Wert von $summe, in dem Fall 0, zugewiesen und die Variablen sind definiert.

Spatzihasi · 17.08.2010

AW: Verhalten bei Parameter-Übergabe

hi chriss

danke für die tolle erklärung. das prinzip hab ich verstanden aber ich denke ich muss einfach noch ein paar übungen damit machen damit der funken überspringt

ak56Lk · 27.08.2010

AW: Verhalten bei Parameter-Übergabe

wenn du

PHP:

$a = $b;
$b = $a;

schreibst, ist das sinnfrei, denn $a erhält den wert von $b und den willst du dann nochmal $b zuweisen. im endeffekt $b = $b.