Virgule d’opérateur surchargée C ++ pour les arguments variadiques

est-il possible de construire des arguments variadic pour function en surchargeant la virgule d’opérateur de l’argument? je veux voir un exemple comment faire .., peut-être quelque chose comme ceci:

template  class ArgList { public: ArgList(const T& a); ArgList& operator,(const T& a,const T& b); } //declaration void myFunction(ArgList list); //in use: myFunction(1,2,3,4); //or maybe: myFunction(ArgList(1),2,3,4); 

C’est en quelque sorte possible, mais l’utilisation ne sera pas très belle. Par exemple:

 #include  #include  #include  #include  template  class list_of { std::vector data; public: typedef typename std::vector::const_iterator const_iterator; const_iterator begin() const { return data.begin(); } const_iterator end() const { return data.end(); } list_of& operator, (const T& t) { data.push_back(t); return *this; } }; void print(const list_of& args) { std::copy(args.begin(), args.end(), std::ostream_iterator(std::cout, " ")); } int main() { print( (list_of(), 1, 2, 3, 4, 5) ); } 

Cette lacune sera corrigée dans C ++ 0x où vous pouvez faire:

 void print(const std::initializer_list& args) { std::copy(args.begin(), args.end(), std::ostream_iterator(std::cout, " ")); } int main() { print( {1, 2, 3, 4, 5} ); } 

ou même avec des types mixtes:

 template  void print(const T& t) { std::cout << t; } template  void print(const Arg1& a1, const ArgN& ...an) { std::cout << a1 << ' '; print(an...); } int main() { print( 1, 2.4, 'u', "hello world" ); } 

Les opérateurs ont un nombre fixe de parameters. Vous ne pouvez pas changer cela. L’opérateur de virgule prend deux arguments. Donc non. Vous pouvez cependant lancer une version personnalisée en cascade, avec quelques efforts.

Peut-être quelque chose comme ça:

 class MyArgList { public: typedef std::list ManyList; template  MyArgList& operator, (const T& val) { elems.push_back(val); return *this; } ManyList::iterator begin() {return elems.begin();} ... private: ManyList elems; }; 

L’utilisation serait:

 void foo(MyArgList& list); foo((myArgList(),1,2,3,4,5)); 

Non ce n’est pas. La liste des valeurs séparées par l’opérateur virgule sera évaluée comme une valeur unique. Par exemple:

 1,2,3 

se traduira par une valeur unique, 3.