Wert- und Referenzparameter

• Überblick über die in imperativen oder OO-Sprachen typischen Strategien der Parameterauswertung

Wertparameter

"Call-by-value"

• werden zur Laufzeit lokale Kopien aktueller Parameter erstellt
• bezieht sich die Verwendung formaler Parameter im Rumpf auf diese Kopien
• verändert sich somit der Wert aktueller Parameter nicht

• In Java werden Parameter immer per Wert übergeben.

  public
void normalisiere(double x,double y,double z)
{
    double len = Math.sqrt(x*x+y*y+z*z);
    x/=len;
    y/=len;
    z/=len;
}

  Der Wert der für x,y und z übergebenen Parameter verändert sich nach Aufruf der Methode "normalisiere" nicht.

• Objektvariablen sind Referenzen, also "Zeiger". Arrays sind in Java als Objekte realisiert, so dass Arrayvariablen ebenfalls Referenzen sind.

  public
void normalisiere(double [] v)
{
    double len = Math.sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);
    v[0]/=len;
    v[1]/=len;
    v[2]/=len;
}

  Bei obiger Implementation werden die Werte des übergebenen Parameters verändert, da sich um eine Referenz handelt. Bei dem indizierten Zugriff wird der Zeiger dereferenziert.

• Das Schreiben neuer Werte in das Feld hat somit direkte Auswirkungen.

• Dies entspricht einer Simulation von "Call-by-Reference", wie sie auch in der Sprache "C"eingesetzt wird.

"Call-by-reference"

• stellt der formale Parameter eine Referenz auf den aktuellen dar
• werden verwendete formale Parameter durch die dereferenzierte Adresse ersetzt
• können die Werte dauerhaft geändert werden

• In Pascal werden Referenz-Parameter mit Hilfe des Schlüsselwortes "var" deklariert

  procedure normalisiere (var x:Real;var y:Real;var z:Real);
var len:Real;
begin
    len:=sqrt(x*x+y*y+z*z);
    x:=x/len;
    y:=y/len;
    z:=z/len;
end;

  Nach Aufruf der Methode "normalisiere" haben die Variablen, welche als aktuelle Parameter übergeben wurden, die im Rumpf berechneten Werte.

• Formell unterstützt auch die Sprache C nur Parameterübergabe per Wert.

• Durch die Verwendung von Zeigern kann -wie in Java- jedoch "Call-by-Reference" simuliert werden:

  void normalisiere (float * x,float * y,float * z);

• Die Methode wird mit den Adressen der aktuellen Parameter aufgerufen:

  float v1=0.5,v2=0.2f,v2=-1.2f;
normalisiere (&v1,&v2,&v3);

• Der Stern kennzeichnet in C den Zeigertyp
• Der Adressoperator "&" erzwingt die Verwendung der Adresse der Variablen