Positions- und Standardargumente

Positionsargumente sind eine Methode, Werte an eine Funktion in einer bestimmten Reihenfolge entsprechend der Signatur der Funktion zu übermitteln.

Sie werden "positional" genannt, weil die Werte den Parametern gemäß ihren Positionen in der Parameterliste der Funktionssignatur zugeordnet werden. Die Position jedes Arguments bestimmt, welchem Parameter es entspricht.

main


              123456789101112131415161718192021
            
#include <iostream>

// Function that takes two positional arguments
float divide(float a, float b)
{
    if (b == 0) {
        std::cout << "Error: Division by zero is not allowed" << std::endl;
        return 0;
    }
    return a / b;
}

int main()
{
    float x = 8;
    float y = 4;

    // Calling the 'divide' function with two positional arguments
    float result = divide(x, y);
    std::cout << "The result is: " << result << std::endl;
}

Sie können ein kleines Experiment durchführen: Ändern Sie die Reihenfolge, in der Argumente an die Funktion übergeben werden (verwenden Sie divide (y, x) anstelle von divide(x, y)), und Sie werden sehen, dass sich das Ergebnis verändert hat. Genau das ist das Wesen positionsabhängiger Argumente: die Reihenfolge, in der Parameter an die Funktion übergeben werden, ist wichtig und beeinflusst direkt das Ergebnis.

Standardargumente

Standardargumente in C++ ermöglichen es Ihnen, Funktionsparametern Standardwerte zuzuweisen. Wenn Sie in einer Funktionsdeklaration Standardwerte für Parameter angeben, bedeutet das, dass, wenn ein Aufrufer keinen expliziten Wert für diesen Parameter übergibt, der Standardwert verwendet wird. Sie können einen Standardwert angeben, indem Sie einfach das erforderliche Argument mit einem bestimmten Wert initialisieren in der Funktionssignatur.

Betrachten wir ein Beispiel basierend auf unserer divide() Funktion:

main


              123456789101112131415161718192021
            
#include <iostream>

// Added the third default argument with specified value
float divide(float a, float b, bool divideByZero = false) {
    if (b == 0 && !divideByZero) {
        std::cerr << "Error: Division by zero is not allowed." << std::endl;
        return 0;
    }
    else if (b == 0 && divideByZero) 
        return a / 0.0000001;
    else
        return a / b;
}

int main() {
	float result1 = divide(51, 0.0, true); // Division by zero allowed
    std::cout << "Allowed: " << result1 << std::endl;

    float result2 = divide(7.0, 0.0); // Default behavior (Error message)
    std::cout << "Default: " << result2 << std::endl;
}

Wir können sehen, dass das Argument divideByZero einen spezifizierten false Standardwert hat, und es beim Aufrufen der Funktion ignoriert werden kann. Aber wenn wir einen Fehler vermeiden und die Berechnung fortsetzen möchten, können wir divideByZero=true am Ende der Parameterliste setzen.

Hinweis

Es ist wichtig, dass alle Standardargumente nach den positionsbezogenen Argumenten in der Parameterliste stehen. Andernfalls wird der Compiler einen Fehler auslösen.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 1