Operatore di overload C++ virgola per argomenti variadici

Question

è possibile costruire argomenti variadici per funzione sovraccaricando l'operatore virgola dell'argomento? voglio vedere un esempio di come farlo .., forse qualcosa di simile:

template <typename T> class ArgList { 
public: 
    ArgList(const T& a); 
    ArgList<T>& operator,(const T& a,const T& b); 
} 
//declaration 
void myFunction(ArgList<int> list); 

//in use: 
myFunction(1,2,3,4); 

//or maybe: 
myFunction(ArgList<int>(1),2,3,4); 

Answer 1

E 'sort- di possibile, ma l'utilizzo non sarà molto bello. Per exxample:

#include <vector> 
#include <iostream> 
#include <algorithm> 
#include <iterator> 

template <class T> 
class list_of 
{ 
    std::vector<T> data; 
public: 
    typedef typename std::vector<T>::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<int>& args) 
{ 
    std::copy(args.begin(), args.end(), std::ostream_iterator<int>(std::cout, " ")); 
} 

int main() 
{ 
    print((list_of<int>(), 1, 2, 3, 4, 5)); 
} 

Questa lacuna verrà risolto in C++ 0x, dove si può fare:

void print(const std::initializer_list<int>& args) 
{ 
    std::copy(args.begin(), args.end(), std::ostream_iterator<int>(std::cout, " ")); 
} 

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

o anche con tipi misti:

template <class T> 
void print(const T& t) 
{ 
    std::cout << t; 
} 

template <class Arg1, class ...ArgN> 
void print(const Arg1& a1, const ArgN& ...an) 
{ 
    std::cout << a1 << ' '; 
    print(an...); 
} 


int main() 
{ 
    print(1, 2.4, 'u', "hello world"); 
} 

Answer 2

Gli operatori hanno un numero fisso di parametri. Non puoi cambiarlo. L'operatore virgola accetta due argomenti. Quindi no. Tuttavia, è possibile eseguire il rollover di una versione personalizzata a cascata con un certo sforzo.

Answer 3

No, non lo è. L'elenco di valori separati dall'operatore virgola verrà valutato come un singolo valore. Per esempio:

1,2,3 

si tradurrà in un unico valore, 3.

Answer 4

Forse qualcosa di simile:

class MyArgList { 
public: 
    typedef std::list<boost::any> ManyList; 

    template <typename T> 
    MyArgList& operator, (const T& val) { 
     elems.push_back(val); 
     return *this; 
    } 

    ManyList::iterator begin() {return elems.begin();} 
     ... 

private: 
    ManyList elems; 
}; 

Uso sarebbe:

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