C++ перегрузка операторской запятой для вариационных аргументов

Question

Возможно ли построить переменные аргументы для функции путем перегрузки операторской запятой аргумента? Я хочу посмотреть пример, как это сделать .., может быть, примерно так:

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

Это sort- возможно, но использование не будет выглядеть очень красиво. Для 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)); 
} 

Этот недостаток будет исправлена ​​в C++ 0x, где вы можете сделать:

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}); 
} 

или даже со смешанными типами:

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

Операторы имеют фиксированное количество параметров. Вы не можете это изменить. Оператор запятой принимает два аргумента. Так нет. Вы можете катить обычную каскадную версию, хотя и с некоторыми усилиями.

Answer 3

Нет, это не так. Список значений, разделенных оператором запятой, будет оцениваться как одно значение. Например:

1,2,3 

приведет к одному значению, 3.

Answer 4

Может быть что-то вроде этого:

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; 
}; 

Использование будет:

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