C++ que sobrecarga la coma del operador para los argumentos variad

Question

¿es posible construir argumentos variados para la función sobrecargando la coma del operador del argumento? Quiero ver un ejemplo de cómo hacerlo ..., tal vez algo como esto:

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

Es Sort- de posible, pero el uso no se verá muy bien. Para 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)); 
} 

Esta deficiencia se fijará en C++ 0x donde se puede hacer:

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 incluso con tipos mixtos:

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

Los operadores tienen un número fijo de parámetros. No puedes cambiar eso. El operador de coma toma dos argumentos. Entonces no Sin embargo, puede rodar una versión personalizada en cascada, con cierto esfuerzo.

Answer 3

No, no lo es. La lista de valores separados por el operador de coma se evaluará como un valor único. Por ejemplo:

1,2,3 

resultará en un único valor, 3.

Answer 4

Tal vez algo como esto:

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 sería:

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