Arguments Positionnels et par Défaut

Les arguments positionnels sont une méthode pour transmettre des valeurs à une fonction dans un ordre spécifique, basé sur la signature de la fonction.

Ils sont appelés "positionnels" car les valeurs sont associées aux paramètres en fonction de leurs positions dans la liste des paramètres de la signature de fonction. La position de chaque argument détermine à quel paramètre il correspond.

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;
}

Vous pouvez mener une petite expérience : modifiez l'ordre de passage des arguments à la fonction (utilisez divide (y, x) au lieu de divide(x, y)) et vous verrez que le résultat a changé. C'est précisément l'essence des arguments positionnels : l'ordre de passage des paramètres à la fonction est important, car il influence directement le résultat.

Arguments par défaut

Les arguments par défaut en C++ vous permettent de spécifier des valeurs par défaut pour les paramètres des fonctions. Lorsque vous fournissez des valeurs par défaut dans la déclaration d'une fonction, cela signifie que si l'appelant ne transmet pas explicitement un argument pour ce paramètre lors de l'appel, la valeur par défaut sera utilisée à la place. Vous pouvez fournir une valeur par défaut en instanciant simplement l'argument requis avec une certaine valeur dans la signature de la fonction.

Examinons un exemple basé sur notre fonction divide() :

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;
}

Nous pouvons voir que l'argument divideByZero a une valeur par défaut false spécifiée, et nous pouvons l'ignorer lors de l'appel de la fonction. Mais si nous voulons éviter une erreur et poursuivre le calcul, nous pouvons définir divideByZero=true à la fin de la liste des paramètres.

Note

Il est important que tous les arguments par défaut soient situés après ceux positionnels dans la liste des paramètres. Sinon, le compilateur générera une erreur.

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 1