Comment implémenter une fonction prenant des paramètres optionnels en C++ ?

Question

J'ai une fonction qui prend 3 paramètres déterminés et un paramètre supplémentaire.

Dans Matlab, je peux utiliser nargin < 4 pour distinguer le cas avec le paramètre additionnel et celui sans paramètre additionnel.

Comment puis-je implémenter une fonction en C++ imitant ce comportement ?

J'ai trouvé que le parameter pack / variadic parameter peut être utile, mais je n'ai aucune idée de comment l'utiliser.

Quelqu'un peut-il m'apporter des informations ?

Answer 1

Vous pouvez utiliser std::optional . Dans la déclaration de la fonction, attribuez la valeur par défaut de std::nullopt à votre argument facultatif. Il s'agit d'une valeur spéciale destinée à indiquer que std::optional ne contient pas de valeur. Ainsi, vous pourrez appeler votre fonction avec 3 ou 4 paramètres.

void function(int a, int b, int c, std::optional<int> d = std::nullopt) {
   // check if d has value (there is a special bool conversion in std::optional)
   if (d) {
      int temp = d.value();
   }
}

int main() {
    function(0,1,2);
    function(0,1,2,3);
}

Answer 2

Vous pouvez utiliser le pack de paramètres comme suit pour un comportement similaire :

#include <iostream>

//template function, takes any number of argument
template <typename... Args>
int func(Args... args)
{
    //sizeof...(args) is the number of args provided
    switch (sizeof...(args)) {
        case 4:
            std::cout << "4"; break;
        case 2:
            std::cout << "2"; break;
        default:
            std::cout << "Args: " << sizeof...(args);
    }
}

int main()
{
    func(1,2,3); //prints "Args: 3"
}

Answer 3

Comment puis-je implémenter une fonction en C++ imitant ce comportement ?

Cela dépend de ce que vous allez faire exactement à l'intérieur de cette fonction dans le cas de 3 arguments réels et de 4 arguments réels. Si ces actions sont très similaires -- alors vous feriez mieux d'opter pour la fonction std::optional<> comme suggéré précédemment.

Cependant, si ces actions sont substantiellement différentes, alors vous pouvez tout simplement surcharge cette fonction. C'est-à-dire qu'il faut deux fonctions portant le même nom : une pour 3 arguments et une autre pour 4 arguments, avec des corps absolument indépendants. Le compilateur sera capable de déterminer quelle implémentation appeler.

#include <iostream>

void MyFunc(int a, int b, int c)
{
    std::cout << "3-argument version called." << std::endl;
}

void MyFunc(int a, int b, int c, int d)
{
    std::cout << "4-argument version called." << std::endl;
}

int main()
{
    MyFunc(1, 2, 3);
    MyFunc(1, 2, 3, 4);
}