#Programmieren Teil 4 – Funktionsparameter – Von Bits und Bytes

int f() 
{
    return 42; 
}

Die Funktion liefert den Wert 42 zurück, und zwar bei jedem Aufruf. Das ist zwar schön und gut, wenn man einen konstanten Wert berechnen und wiederverwenden möchte, aber so richtig weit kommt man damit nicht. Und wenn wir an die Mathematik denken, dann verhalten sich Funktionen dort auch meist ein klein wenig anders, indem sie nämlich ein Ergebnis abhängig von einer Eingabe berechnen. Die mathematische Funktion

sqr(x) = x * x

etwa berechnet das Quadrat der Eingabe. Um Funktionen sinnvoll nutzen zu können, benötigen wir das natürlich auch beim Programmieren – gibt es natürlich auch. Das Schlüsselwort hierfür sind die bereits erwähnten Funktionsparameter. Genutzt haben wir die auch schon indirekt, und zwar hier:

printf( "Hello World!" );

Die Funktion printf verlangt als Funktionsargument die Zeichenkette, die sie auf dem Bildschirm ausgeben soll (und zusätzlich eventuell noch weitere Argumente, aber das ist ein anderes Thema). Wir geben der Funktion damit eine Eingabe, mit der sie etwas macht (in diesem Fall, sie auf dem Bildschirm auszugeben). Die große Frage ist nun nur noch: wie teilen wir einer Funktion mit, dass sie eine Eingabe erwartet, und noch wichtiger: was für eine Eingabe?

Nichts leichter als das. Wir müssen einfach nur die Signatur der Funktion (wir erinnern uns: das war der Kopf, etwa hier: int main()) um die Informationen erweitern, welche Eingabe von einer Funktion erwartet wird. Dazu schreiben wir einfach in die Klammern der Signatur, welche Eingabe wir erwarten, sprich: welche Datentypen erwarten wir als Eingabe und mit welchem Namen wollen wir die Eingabe dann in der Funktion ansprechen. Das erfolgt in Form der bereits bekannten Variablendeklarationen und sieht zum Beispiel so aus:

int sqr( int x )

Hiermit definieren wir den Kopf einer Funktion, die eine einzelne ganze Zahl x als Eingabe erwartet und eine ganze Zahl als Ergebnis zurückliefert. Die Variable x bezeichnen wir als Funktionsparameter. Die vollständige Funktion sieht dann so aus:

int sqr( int x )
{
    return x * x;
}

Wir sehen, dass die im Funktionskopf deklarierte Variable x wie eine normale lokale Variable im Funktionsrumpf genutzt werden kann. Die Nutzung der so definierten Funktion erfolgt dann in der bekannten Weise:

#include <cstdio>

int sqr( int x )
{
    return x * x;
}

int main()
{
    int x = 42;
    printf( "%i squared is: %i", x, sqr( x ) );
}

Eine Bemerkung zu den Begrifflichkeiten: bei der Definition einer Funktion spricht man von Funktionsparametern, beim Aufruf der Funktion spricht man bei den übergebenen Werten von Funktionsargumenten. Der Parameter ist also die im Funktionskopf deklarierte Variable, das Argument ist der tatsächlich eingegebene Wert. In int f( int x ) heißt x also Parameter, in f( x ) heißt x Argument.

Und um an dieser Stelle gleich einen bekannten Fallstrick zu erwähnen: Funktionsparameter und -argumente sind – genauso wie gleich benannte Variablen in unterschiedlichen Scopes – vollkommen unabhängig voneinander, sprich, nur weil der Parameter einer Funktion x heißt, muss als Argument nicht auch zwingend eine Variable mit der Bezeichnung x eingegeben werden. Das ergibt sich schon logisch daraus, dass als Argument jeder beliebige Ausdruck eingesetzt werden kann, und nicht nur Variablen. Der folgende Codeausschnitt ist ebenso gültig (in verkürzter Formatierung der sqr-Funktion):

int sqr( int x ) { return x * x; }

int main()
{
    int y = 42;
    printf( "%i squared is: %i", y, sqr( y ) );
}