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

这种可能性很高，但使用效果不会很好。例如：

#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

也许是这样的：

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

Answer 4

不，不是。由逗号运算符分隔的值列表将作为单个值进行计算。例如：

1,2,3

将产生单个值，3。

C ++重载变量参数的运算符逗号

4 个答案: