Nombre de paramètres Variable en fonction en C++

Ceux-ci sont appelés Variadic fonctions. Listes de wikipédia exemple de code pour C++.

À mettre en œuvre de façon portable variadic
fonctions dans la programmation en C
la langue, la norme stdarg.h en-tête
le fichier doit être utilisé. Les plus âgés
varargs.h la tête a été désapprouvée
en faveur de stdarg.h. En C++, l'
fichier d'en-tête cstdarg doit être utilisé.

Pour créer un variadic fonction, un
points de suspension (...) doit être placé à l'
à la fin d'une liste de paramètres. À l'intérieur de la
corps de la fonction, une variable de
type va_list doit être défini. Puis le
les macros va_start(va_list, last fixed
param), va_arg(va_list, cast type),
va_end(va_list) peut être utilisé. Pour
exemple:

#include <stdarg.h>

double average(int count, ...)
{
    va_list ap;
    int j;
    double tot = 0;
    va_start(ap, count); //Requires the last fixed parameter (to get the address)
    for(j=0; j<count; j++)
        tot+=va_arg(ap, double); //Requires the type to cast to. Increments ap to the next argument.
    va_end(ap);
    return tot/count;
}

Côté de l'autre réponses, si vous êtes juste essayer de passer un tableau d'entiers, pourquoi pas:

void func(const std::vector<int>& p)
{
    //...
}

std::vector<int> params;
params.push_back(1);
params.push_back(2);
params.push_back(3);

func(params);

Vous ne pouvez pas l'appeler dans le paramètre de forme, cependant. Vous auriez à utiliser les variadic fonction figurant dans vos réponses. C++0x permettra variadic templates, ce qui permettra de type-safe, mais pour l'instant, c'est essentiellement de la mémoire et de la coulée.

Vous pourrait émuler une sorte de variadic paramètre->vecteur chose:

//would also want to allow specifying the allocator, for completeness
template <typename T> 
std::vector<T> gen_vec(void)
{
    std::vector<T> result(0);
    return result;
}

template <typename T> 
std::vector<T> gen_vec(T a1)
{
    std::vector<T> result(1);

    result.push_back(a1);

    return result;
}

template <typename T> 
std::vector<T> gen_vec(T a1, T a2)
{
    std::vector<T> result(1);

    result.push_back(a1);
    result.push_back(a2);

    return result;
}

template <typename T> 
std::vector<T> gen_vec(T a1, T a2, T a3)
{
    std::vector<T> result(1);

    result.push_back(a1);
    result.push_back(a2);
    result.push_back(a3);

    return result;
}

//and so on, boost stops at nine by default for their variadic templates

Utilisation:

func(gen_vec(1,2,3));

Voir Variadic des fonctions en C, Objective-C, C++, et D

Vous devez inclure stdarg.h et ensuite utiliser va_list, va_start, va_arg et va_end, comme l'exemple de l'article de Wikipédia montre. C'est un peu plus encombrant que le Java ou le C#, parce que le C et le C++ n'ont guère de prise en charge intégrée pour les varargs.

GManNickG et Christoph réponses sont bonnes, mais variadic fonctions vous permettent de pousser dans le ... paramètre que vous voulez, pas que des nombres entiers. Si vous sera voulez dans la avenir, pour pousser de nombreuses variables et les valeurs de différents types dans une fonction sans utiliser variadic fonction, car il est trop difficile ou trop compliqué pour vous, ou vous n'aimez pas la manière de l'utiliser ou que vous ne voulez pas inclure les en-têtes requis pour l'utiliser, alors vous pouvez toujours utiliser void** paramètre.

Par exemple, Stephan202 posté le:

double average(int count, ...)
{
    va_list ap;
    int j;
    double tot = 0;
    va_start(ap, count); //Requires the last fixed parameter (to get the address)
    for(j=0; j<count; j++)
        tot+=va_arg(ap, double); //Requires the type to cast to. Increments ap to the next argument.
    va_end(ap);
    return tot/count;
}

cela peut aussi être écrit comme:

double average(int count, void** params)
{
    int j;
    double tot = 0;
    for (j=0; j<count; j++)
       tot+=*(double*)params[j];
    return tot/count;
}

Maintenant l'utiliser comme ça:

int _tmain(int argc, _TCHAR* argv[])
{
    void** params = new void*[3];
    double p1 = 1, p2 = 2, p3 = 3;
    params[0] = &p1;
    params[1] = &p2;
    params[2] = &p3;
    printf("Average is: %g\n", average(3, params));
    system("pause");
    return 0;
}

pour le code complet:

#include "stdafx"
#include <process.h>

double average(int count, void** params)
{
    int j;
    double tot = 0;
    for (j=0; j<count; j++)
        tot+=*(double*)params[j];
    return tot/count;
}

int _tmain(int argc, _TCHAR* argv[])
{
    void** params = new void*[3];
    double p1 = 1, p2 = 2, p3 = 3;
    params[0] = &p1;
    params[1] = &p2;
    params[2] = &p3;
    printf("Average is: %g\n", average(3, params));
    system("pause");
    return 0;
 }

De SORTIE:

Moyenne est de: 2

Appuyez sur n'importe quelle touche pour continuer . . .