:PI-BASIS: Funktionen Spezial: Funktionen mit Ein- und Rückgabe

Funktion mit Rückgabe

Wie kann bei dem Beispiel mit sum() die Variable c eingespart werden?

void als Wert einer Funktion

Sie haben sich sicher schon über das "void" gewundert. In Java und C++ gibt es nur Funktionen (in Pascal gibt es eine eigene Bezeichnung für Unterprogramme ohne Rückgabe: "procedure"). Bei Funktionen ist es üblich etwas zurück zu geben, die Funktion hat einen Wert. Wenn man nichts bestimmtes zurückgeben will, wird das "void" genannt.

int als Wert einer Funktion

Im folgenden Beispiel gibt sum() den Wert der Addition zurück, die Funktion hat den Typ int, d.h. ihr Ergebnis ist vom typ int:

int a=10,b=5; // Variablen vereinbaren

int sum(){  // Unterprogramm namens sum(), Rückgabe vom Typ int
  return a+b;
}

void ButtonClick(){ 
  Ausgabe(sum()); // sum() aufrufen und den Wert von sum() ausgeben
}

Mit der Anweisung "return" wird der Wert der Funktion bestimmt, die Funktion wird mit diesem Wert sofort verlassen.
Beispiel aus Java: Methode getText() eines Textfeldes, Rückgabewert ist vom Typ "String".

Aufgabe: Implementieren Sie das Programm und fügen sie zusätzliche Ausgaben für Ihr Verständnis ein. Beschreiben Sie mit eigenen Worten den Programmablauf.

Funktion mit Eingabe und Rückgabe

Dieses Beispiel zeigt eine Funktion mit Eingabe und Ausgabe:

int a=10; // Variablen vereinbaren

int plusfive(int b){  // Unterprogramm namens plusfive(int b), Rückgabe vom Typ int
  b= b+5; // zu b 5 addieren;
  return b; // b zurückgeben
}

void ButtonClick(){ // dieses Rezept wird ausgeführt
  Ausgabe(plusfive(a)); // plusfive(a) aufrufen und den Wert von plusfive(a) ausgeben
}

Beim Aufruf von ButtonClick passiert folgendes:

plusfive(int b) wird mit dem Wert von a also 10 aufgerufen. (int b) nennt man den Parameter oder die Schnittstelle der Funktion. Der Wert 5 wird der Parametervariablen b der Funktion übergeben, nennt man "call by value", weil er in b kopiert wird. Innerhalb der Funktion steht nun die Variable b zur Verfügung. Auf den Wert von b wird nun 5 addiert und das Ergebnis zurückgegeben. Das ist dann der Wert von plusfive(10). Die Ausgabe 15.

Parameter und lokale Variablen

Der Platz für die Variable int b wird erst beim Aufruf der Funktion reserviert und nach Ende der Funktion wieder freigegeben.

int a=10; // Variablen vereinbaren

int plusfive(int b){  // Unterprogramm namens plusfive(int b), Rückgabe vom Typ int
  int c;  // lokale Variable c
  c= b+5; // zu b 5 addieren und in c speichern;
  return c; // c zurückgeben
}

void ButtonClick(){ // dieses Rezept wird ausgeführt
  Ausgabe(plusfive(a)); // plusfive(a) aufrufen und den Wert von plusfive(a) ausgeben
}

Die Variablen b und c sind nur innerhalb der Funktion vorhanden (sichtbar), sie werden beim Aufruf der Funktion reserviert. Außerhalb der Funktion existieren sie nicht!

Wichtig: Lokale Variablen verdecken globale Variablen mit dem selben Namen:

int a=10; // Variablen vereinbaren

int plusfive(int b){  // Unterprogramm namens plusfive(int b), Rückgabe vom Typ int
  int a;  // lokale Variable a, verdeckt globales a
  a= b+5; // zu b 5 addieren und in a speichern;
  return a; // a zurückgeben
}

void ButtonClick(){ // dieses Rezept wird ausgeführt
  Ausgabe(plusfive(a)); // plusfive(a) aufrufen und den Wert von plusfive(a) ausgeben
}

Die lokale Variable a in der plusfive-Funktion verdeckt das globale a, d.h. was innerhalb von plusfive mit a gemacht wird hat keine Auswirkung auf das globale a, der Wert bleibt unverändert! Gilt auch für die Parametervariable b, sie würde auch eine globales b entsprechend verdecken.

Funktion mit Eingabe ohne Rückgabe

Beispiel aus Java: Die Methode setText("Hallo") des Textfeldes oder des Labels. Wirkung durch Seiteneffekt:

int a=10,c; // Variablen vereinbaren

void plusfive(int b){  // Unterprogramm namens plusfive(int b)
  c= b+5; // zu b 5 addieren und in c speichern;
}

void ButtonClick(){ // dieses Rezept wird ausgeführt
  plusfive(a)
  Ausgabe(c); // plusfive(a) aufrufen, Seiteneffekt auf c und den Wert von c ausgeben
}

Hier besteht die Wirkung durch den Seiteneffekt auf die globale Variable c, in der das Ergebnis gespeichert wird.

Zusammenfassung

Funktionen sind Unterprogramme. Durch Verwenden von Parametern und lokalen Variablen können globale Variablen eingespart und die Auswirkungen durch die Funktionen (Seiteneffekte) überschaubarer gehalten werden. Funktionen können einen Wert zurückgeben, dadurch kann eine globale Variable zur Werteübergabe eingespart werden. Die Umgebung moderner Programmiersprachen besteht aus Objekten, deren Eigenschaften werden durch den Aufruf der vorgesehenen Methoden verändert. Durch das Kapseln von Eigenschaften in Objekten macht die Umgebung beherrschbarer, unerwünschte Seiteneffekte werden vermieden.

Aufgaben und Vertiefung

Zu den Aufgaben...