Apprendre Arguments Positionnels et par Défaut | Spécification des Arguments de Fonction

Les arguments positionnels représentent une méthode de transmission de valeurs à une fonction selon un ordre spécifique défini par 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 la fonction. La position de chaque argument détermine à quel paramètre il correspond.

main.cpp


              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 réaliser 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 constaterez 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 et influence directement son résultat.

Arguments par défaut

Les arguments par défaut en C++ permettent de spécifier des valeurs par défaut pour les paramètres d'une fonction. 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 une valeur pour ce paramètre lors de l'appel de la fonction, la valeur par défaut sera utilisée à la place. Vous pouvez fournir une valeur par défaut en initialisant simplement l'argument requis avec une valeur dans la signature de la fonction.

Considérons un exemple basé sur notre fonction divide() :

main.cpp


              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 constater que l'argument divideByZero possède une valeur par défaut spécifiée à false, et nous pouvons l'ignorer lors de l'appel de la fonction. Mais si nous souhaitons éviter une erreur et poursuivre le calcul, nous pouvons définir divideByZero=true à la fin de la liste des paramètres.

Remarque

Il est important que tous les arguments par défaut soient placés après les arguments 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

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you explain more about how default arguments work in C++?

What happens if I provide only some of the arguments when calling the function?

Can you give another example of using default arguments in a function?

Awesome!

Completion rate improved to 5

Glissez pour afficher le menu

Les arguments positionnels représentent une méthode de transmission de valeurs à une fonction selon un ordre spécifique défini par la signature de la fonction.

main.cpp


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

Arguments par défaut

Considérons un exemple basé sur notre fonction divide() :

main.cpp


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

Remarque

Il est important que tous les arguments par défaut soient placés après les arguments 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