Comment écrire des fonctions qui acceptent des arguments illimités?

J'ai seulement été en mesure de trouver un façon, de fonctions, de prendre un nombre variable d'arguments.
C'est de cette façon:

#include <iostream>
#include <stdarg.h>

using namespace std;

void Print(int argumentAmount, ... );

int main()
{
    Print(5,11,22,33,44,55);
}

void Print(int argumentAmount, ... ){

    va_list arguments; 
    va_start(arguments, argumentAmount);

    int parameter;
    for(int i = 0; i < argumentAmount; ++i ){
        parameter = va_arg(arguments, int);
        cout << parameter << endl;
    }

    va_end(arguments);
    return;
}

2 Problèmes:
1.) - Je le préciser combien d'arguments, je suis de l'envoyer en pas souhaitable
2.) Je ne peux pas comprendre comment le modifier de sorte qu'il sera de sortie des chaînes de caractères.

Serait quelque chose comme cela sera possible sans avoir à surcharger la fonction plusieurs fois:

void Output(/*not sure how this would look*/);

int main(){

    Output("hello","world");
    Output("this","is","a","test");
    Output("As","many","strings","as","you","want","may","be","passed","in");

    return 0;
}
void Output(/*not sure how this would look*/){

    //loop through each string passed in and output it
}

Quoi à ce sujet:

void Capitalize(/*all passed by reference*/);

int main(){

    string s1 = "hello";
    string s2 = "world";

    string s3 = "this";
    string s4 = "is";
    string s5 = "a";
    string s6 = "test";

    string s7 = "as";
    string s8 = "many";
    string s9 = "strings";
    string s10 = "as";
    string s11 = "you";
    string s12 = "want";

    Capitalize(s1,s2);
    Capitalize(s3,s4,s5,s6);
    Capitalize(s7,s8,s9,s10,s11,s12);

    return 0;
}
void Capitalize(/*all passed by reference*/){

    //capitalize each string passed in

}

Tout ce que je peux penser à faire est de:
-la surcharge de la fonction plusieurs fois
-avoir la fonction d'accepter un certain type de conteneur au lieu

Si c'est PAS POSSIBLEquelqu'un pourrait-il expliquer pourquoi le compilateur n'est pas capable d'accomplir une tâche de ce genre.

source d'informationauteur Trevor Hickey | 2012-01-27

  1. 32

    Avec variadic templates en C++11, vous pouvez faire quelque chose comme ceci (voir le résultat à ideone)

    #include <string>
#include <iostream>

void Output() {
    std::cout<<std::endl;
}

template<typename First, typename ... Strings>
void Output(First arg, const Strings&... rest) {
    std::cout<<arg<<" ";
    Output(rest...);
}

int main() {
    Output("I","am","a","sentence");
    Output("Let's","try",1,"or",2,"digits");
    return 0;
}
  2. 11

    De réponse simple et rapide.

    Pour le C++, vous devez spécifier le nombre d'arguments ou d'une sentinelle de la valeur pour indiquer la fin d'arguments.

    Votre premier exemple est un bon exemple de specing le comte, vous pouvez aussi faire:

    void Print(const char *arg, ... ){
    va_list arguments;

    for (va_start(arguments, arg); arg != NULL; arg = va_arg(arguments, const char *)) {
        cout << arg << endl;
    }

    va_end(arguments);
}

    Où votre convention d'appel est:

    Print("foo","bar",NULL);

    Si vous voulez le prendre au prochain niveau, vous pouvez mélanger dans un peu de le Préprocesseur C et à faire:

    #define mPrint(...) Print(__VA_ARGS__, NULL)

    Maintenant vous pouvez simplement dire:

    mPrint("fooo","bar");

    Et la macro NULL mettre fin à l'appel.

  3. 5

    Au lieu de passer dans le compte, vous pouvez demander une "fuite" argument (soit nullptr ou un pointeur pour certains codée en dur "magique" de la chaîne) et votre variable d'argument de la fonction d'arrêt de l'extraction des arguments en plus une fois qu'ils voient la fuite. Qui peut soulager votre codage d'un bit.

    Vous pouvez également passer des pointeurs (références) pour les récipients, contenant (ou pointant sur/référencement) dans vos cordes. Tout ce qui peut en quelque sorte de lien à tous vos arguments se faire (par exemple, un vecteur).

    Exemple (peut-être pas très idiomatique, mais devrait servir d'illustration):

    #include <iostream>
#include <string>
#include <cstdarg>
#include <cctype>
#include <vector>
using namespace std;
void AntiCapitalize(vector<string*>& v);
void Capitalize(string* s, ...);
void Print(string* s, ...);
int main()
{
string s1 = "hello";
string s2 = "world";
string s3 = "this";
string s4 = "is";
string s5 = "a";
string s6 = "test";
string s7 = "as";
string s8 = "many";
string s9 = "strings";
string s10 = "as";
string s11 = "you";
string s12 = "want";
Capitalize(&s1, &s2, 0);
Capitalize(&s3, &s4, &s5, &s6, 0);
Capitalize(&s7, &s8, &s9, &s10, &s11, &s12, 0);
Print(&s1, &s2, 0);
Print(&s3, &s4, &s5, &s6, 0);
Print(&s7, &s8, &s9, &s10, &s11, &s12, 0);
vector<string*> v;
v.push_back(&s1);
v.push_back(&s2);
v.push_back(&s3);
v.push_back(&s4);
v.push_back(&s5);
v.push_back(&s6);
v.push_back(&s7);
v.push_back(&s8);
v.push_back(&s9);
v.push_back(&s10);
v.push_back(&s11);
v.push_back(&s12);
AntiCapitalize(v);
Print(&s1, &s2, 0);
Print(&s3, &s4, &s5, &s6, 0);
Print(&s7, &s8, &s9, &s10, &s11, &s12, 0);
return 0;
}
void Capitalize(string* s, ...)
{
va_list ap;
va_start(ap, s);
while (s)
{
string::size_type i = 0;
while ((*s)[i] != '\0')
{
(*s)[i] = toupper((*s)[i]);
i++;
}
s = va_arg(ap, string*);
}
va_end(ap);
}
void Print(string* s, ...)
{
va_list ap;
va_start(ap, s);
while (s)
{
cout << *s << endl;
s = va_arg(ap, string*);
}
va_end(ap);
}
void AntiCapitalize(vector<string*>& v)
{
vector<string*>::iterator it;
for (it = v.begin(); it != v.end(); it++)
{
string::size_type i = 0;
while ((**it)[i] != '\0')
{
(**it)[i] = tolower((**it)[i]);
i++;
}
}
}

    De sortie:

    HELLO
WORLD
THIS
IS
A
TEST
AS
MANY
STRINGS
AS
YOU
WANT
hello
world
this
is
a
test
as
many
strings
as
you
want
  4. 0

    Je pense qu'il y est une autre solution possible:
    Vous pourriez surcharge de l'opérateur "<< " comme ceci:

    class OutputObject {
public:
//Some class functions/members
};
template<class T>
static operator << (OutputObject& out, T temp) {
cout << temp;
}
static OutputObject Obj = OutputObject();

    Et puis vous pouvez faire ce qui suit dans le principal:

    #include "OutputObject.hpp"
#include <string>
using namespace std;
int main(void) {
string str = "Hello World";
Obj << 12 << str << 3.14f << "C++";
Obj << 12;
Obj << str;
return(0);
};

    Si j'ai fait quelque chose de mal ou il y a une raison de ne pas s'il vous plaît
    dites-moi, c'était juste mon Idée de l'infini de paramètres.
    Je n'ai pas pu le tester encore, mais je pense que cela devrait fonctionner.