C ++ sovraccarico virgola operatore per argomenti variadic

Question

è possibile costruire argomenti variadic per la funzione sovraccaricando 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 'sorta-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 si può cambiare la situazione. L'operatore virgola prende due argomenti. Quindi no. Si può tirare un personalizzato, a cascata versione però, con un certo sforzo.

Answer 3

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

Utilizzo potrebbe essere:

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

Answer 4

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

1,2,3

si tradurrà in un unico valore, 3.