Passez quelques arguments dans une fonction C++?

J'ai une fonction C++ qui a 5 arguments, qui ont tous des valeurs par défaut. Si je passe dans les trois premiers arguments, le programme va attribuer une valeur par défaut pour les deux derniers arguments. Est-il possible de passer 3 arguments, et sautez dans le milieu, en donnant des valeurs à-dire, la première, la deuxième et la cinquième arguments?

Réponse courte: Non.
Il existe des solutions de contournement. Mais si vous le pouvez, la surcharge de la place.

OriginalL'auteur kyrpav | 2013-09-26

  1. 5

    Pas directement, mais vous pourriez être en mesure de faire quelque chose avec std::bind:

    int func(int arg1 = 0, int arg2 = 0, int arg3 = 0);

//elsewhere...
using std::bind;
using std::placeholders::_1;
auto f = bind(func, 0, _1, 0);

int result = f(3); //Call func(0, 3, 0);

    L'inconvénient est bien sûr que vous êtes re-spécifier les paramètres par défaut. Je suis sûr que quelqu'un d'autre va venir avec une solution intelligente, mais cela pourrait fonctionner si vous êtes vraiment désespéré.

    OriginalL'auteur bstamour

  2. 1

    Avec un classique 5 arguments de la fonction, il n'y a aucun moyen de lui donner seulement 3 ou 4. Vous ne pouvez écrire 3 ou 4 avec des arguments par défaut, mais à la fin, vous obtiendrez un appel de fonction avec 5 arguments.

    Il y a aussi des problèmes avec votre système, s'il y a plusieurs paramètres avec le même type.
    Par exemple, si vous avez foo(int a=4,int b=5) et appel foo(10), comment savez-vous que vous voulez l'appeler foo(10,5) ou foo(4,10) ?

    Avec C++11 tuples et Les paramètres nommés idiome, vous pouvez tricher un peu.

    #include <iostream>
#include <functional>
#include <tuple>
#include <string>

struct f_
{
    private:

    typedef std::tuple<int,int,double> Args;

    //default arguments
    static constexpr const Args defaults = std::make_tuple(10,52,0.5);
    Args args;
    public :
    f_():args(defaults)
    {}

    template <int n,class T> f_& setArg(T&& t)
    {
        std::get<n>(args) = t;
        return *this;
    }

    void operator()() 
    {
        return (*this)(std::move(args));
    }

    void operator()(Args&& a)
    {
        int n1=std::get<0>(a);
        int n2=std::get<1>(a);
        double n3=std::get<2>(a);

        std::cout<<n1<<" "<<n2<<" "<<n3<<std::endl;
    }
};
#define set(n,v) setArg<n>((v))
int main()
{
    //f_().set<1>(42).set<3>("foo") ();
    f_().setArg<1>(42)(); //without Macro
    f_().set(0,666).set(1,42)(); //with Macro
    f_()(); //without any parameters
    f_()(std::forward_as_tuple(-21,-100,3.14)); //direct call
}

    Une autre méthode consiste à utiliser std::bind comme décrit il y

    OriginalL'auteur Davidbrcz

  3. 0

    Non, Il n'est pas possible.


    Cependant, je voudrais suggérer que vous devriez utilisation des paramètres de type de données de tableau au lieu de réaliser le scénario vous a donné. Vous pouvez surcharge. Si les types de données des paramètres varie alors vous devriez définir une classe qui a les paramètres requis en tant que membres. L'objet de cette classe. Il permettra non seulement de résoudre votre problème, mais il est également recommandé du point de vue de la facilité de maintenance.

    OriginalL'auteur Adarsh Kumar

  4. -2

    C'est probablement quelque chose que vous cherchez peut-être, juste une solution de contournement !

    /*
Function f() is called by passing 2 arguments. So to make sure that these 2 arguments are treated as
first and third, whereas the second and the fourth are taken as defaults:

SOLUTION 1 : using recursive call
*/

#include <iostream>
using namespace std;


void f( int = 10,int = 20, int = 30, int = 40);

static int tempb;

static int flag = 1;

int main()
{
    cout << "calling function \n";
    //f();
    f(12,39);
}

void f( int a,int b,int c,int d )
{
    //static int flag = 1;
    //f();  
    if( flag == 1 )
    {
        --flag; 
        f();        //recursive call to intialize the variables a,b,c,d as per the prototype
        c = b;
        b = tempb;
        //cout << c;
    }
    else
    {
        tempb = b;
        return;
    }

    cout << endl <<"a = " << a  << endl << "b = "<< b << endl << "c = " << c << endl << "d = " << d << endl;
}

    La suite est une autre solution de contournement peut être cela aide aussi !

    /*
Function f() is called by passing 2 arguments. So to make sure that these 2 arguments are treated as
first and third, whereas the second and the fourth are taken as defaults:

SOLUTION 2 : using static variable

*/

#include <iostream>
using namespace std;


void f( int = 10,int = 20, int = 30, int = 40);

static int tempb;

int main()
{
    f();
    f(12,39);
}

void f( int a,int b,int c,int d)
{
    static int flag = 1;

    if( flag == 1 )
    {
        --flag; 
        tempb = b;
        return;
    }
    else
    {
        c = b;
        b = tempb;
    }

    cout << "a = " << a << endl << "b = " << b << endl << "c = " << c << endl << "d = " << d;
}
    Je ne peux pas aller pour la variable globale statique pour sélectionner les paramètres de la méthode. Personne ne devrait utiliser cette approche.

    OriginalL'auteur linuxstack