Parameter

Parameter werden in formale Parameter und aktuelle Parameter unterteilt

Formale Parameter

Der englische Begriff lautet Formal Parameter, üblicherweise nur formaler Parameter genannt.

Ein formaler Parameter ist eine spezielle lokale Variable, die in den Klammern bei der Methodendeklaration notiert wird – er ist keine Variable innerhalb des Methodenrumpfs.

Die beiden Variablen in den Klammern nach dem folgenden Funktionsnamen sind formale Parameter. Wer die Programmiersprache C gelernt hat, kennt dieses Konzept bereits.

// x, y sind zwei formale Parameter
public void PrintArea(int x, float y )
{
}
Code-Sprache: C# (cs)

1. Sie besitzen einen Datentyp und einen Variablennamen, Lese- und Schreibzugriff sind möglich;
2. Sie werden außerhalb des Methodenrumpfs definiert und vor Ausführung der Methode automatisch initialisiert (außer bei out-Ausgabeparametern);
3. Mehrere Parameter werden durch Kommas getrennt, es gibt keine Begrenzung der Parameteranzahl;
4. Sie können im Methodenrumpf genau wie gewöhnliche lokale Variablen verwendet werden.

Kurz gesagt sind formale Parameter spezielle lokale Variablen. Sie empfangen Werte, die beim Funktionsaufruf übergeben werden. Die Zuweisung findet also zum Zeitpunkt des Aufrufs statt; wenn der Programmablauf in die Funktion eintritt, sind die formalen Parameter bereits belegt.

public void PrintArea( int x, float y )
{
    float area = x * y; // x, y sind formale Parameter, area ist eine normale lokale Variable für das Produkt von x und y
    Console.WriteLine($"Flächenberechnung: { x } * { y } = { area }");
}
Code-Sprache: C# (cs)

Lauffähiges Beispiel

class Program
{
    static void Main()
    {
        Program program = new Program();
        program.PrintArea(10,6.5F);
    }

    public void PrintArea(int x, float y)
    {
        float area = x * y; // x, y sind formale Parameter, area ist eine normale lokale Variable für das Produkt von x und y
        Console.WriteLine($"Flächenberechnung: {x} * {y} = {area}");
    }
}Code-Sprache: C# (cs)

Ausgabe

Flächenberechnung: 10 * 6.5 = 65

Beim Aufruf der Funktion entspricht dies der Initialisierung von x mit 10 und y mit 6,5

Das F hinter 6.5F kennzeichnet diesen Wert als Gleitkommazahl einfacher Genauigkeit (float). Ohne das Suffix F interpretiert der Compiler den Wert als double und meldet einen Fehler.

Einfachgenaues float und doppeltgenaues double belegen unterschiedlich viele Bits im Speicher, daher unterscheidet sich die Genauigkeit bei der Wertablage.

Genauigkeit gibt an, wie viele Nachkommastellen ein Datentyp zuverlässig speichern kann. Überschreitet man diesen Bereich, können Werte ungenau werden. Das hängt von der Anzahl der reservierten Speicherbits ab.

x und y sind formale Parameter. Beim Aufruf

ist es vergleichbar mit der Initialisierung zweier lokaler Variablen mit diesen Werten.

int x = 10;

float y = 6.5F;Code-Sprache: C# (cs)

Hinweis:

Typ, Reihenfolge und Schreibweise der formalen Parameter bilden zusammen mit dem Methodennamen die Methodensignatur. Man kann die Signatur als Ausweis einer Funktion verstehen. Wir werden Signaturen später behandeln: Übereinstimmende Signaturen bestimmen, ob zwei Methoden identisch sind, zudem lernen wir die Funktionsüberladung kennen.

---

Aktuelle Parameter

Englischer Begriff: Actual Parameters (aktuelle Parameter, auch Argumente genannt)

Beim Methodenaufruf bezeichnet man die Variablen oder Ausdrücke, die Werte an formale Parameter übergeben, als aktuelle Parameter. Vor der Ausführung der Methode werden die formalen Parameter mit den Werten der aktuellen Parameter initialisiert.

1. Aktuelle Parameter stehen in den Klammern beim Methodenaufruf;
2. Typregel: Der Typ des aktuellen Parameters muss zum zugehörigen formalen Parameter passen oder der Compiler unterstützt eine implizite Typumwandlung;
3. Positionszuordnung: Standardmäßig erfolgt die Zuordnung der Reihe nach (Positionsargumente).

Ändern wir zum Beispiel die Main-Funktion im obigen Code wie unten gezeigt. Beim Aufruf ist das erste Argument der Literalwert 5, das zweite die lokale Variable f.

Program program = new Program();
float f = 6.3F;
program.PrintArea(5,f);
// 5 ist ein aktueller Parameter als Konstantenausdruck, f ist ein variabler aktueller Parameter
// Positionszuordnung: 5 → x, f → y
Code-Sprache: C# (cs)

Beim Aufruf werden die Werte der aktuellen Parameter an die formalen Parameter gleicher Position kopiert, danach läuft der Methodenrumpf ab.

---

Positionsargumente

class Calculate
{
    // Zwei formale Parameter vom Typ int
    public int Sum(int x, int y)
    {
        return x + y;
    }

    // Zwei formale Parameter vom Typ float
    public float Avg(float x, float y)
    {
        return (x + y) / 2.0F;
    }
}

class Program
{
    static void Main()
    {
        Calculate cal = new Calculate();
        int num = 6;

        // Sum: aktueller Parameter int passt zum formalen Parameter int
        Console.WriteLine("Sum: {0} and {1} is {2}",
            5, num, cal.Sum(5, num));

        // Avg: int wird implizit zu float umgewandelt
        Console.WriteLine("Avg: {0} and {1} is {2}",
            5, num, cal.Avg(5, num));
    }
}
Code-Sprache: PHP (php)

Ausgabeergebnis

Sum: 5 and 6 is 11
Avg: 5 and 6 is 5.5Code-Sprache: HTTP (http)

C# unterstützt die implizite Umwandlung von Typen mit kleinerem Wertebereich zu Typen mit größerem Bereich (int → float). Die umgekehrte Umwandlung float → int führt zu einem Kompilierfehler und erfordert eine explizite Typumwandlung durch den Entwickler.

num ist eine Variable vom Typ int. Wird sie als aktueller Parameter an den formalen float-Parameter der Avg-Funktion übergeben, wandelt der Compiler int automatisch implizit nach float um – ohne Fehler. Der Wertebereich von int ist vollständig im Wertebereich von float enthalten.

Deshalb entsteht kein Datenverlust bei der Übergabe von int an float. Man kann es sich vorstellen wie eine kleine Kiste in einer großen Kiste. Andersherum lässt sich eine große Kiste nicht in eine kleine stecken.

Parameter