Question

这可能是一个无用的问题，但它在我脑海里停留了几个小时。

我想编写一个接受一些（POD）参数的函数，将它们转换为字符串并返回串联。例如

template<typename A, typename B>
string ToString(A a, B b)
{
    stringstream ss;
    ss << a << b;
    return ss.str();
}

很容易，对吧？但当我想用未知数量的参数编写相同的函数时，它（当然对我来说）非常困难。

甚至可能吗？任何解决方案？

Answer 1

在C ++ 03中，没有。您所能做的就是使用不同数量的参数创建重载：

template<typename A, typename B>
string ToString(A a, B b)
{
    stringstream ss;
    ss << a << b;
    return ss.str();
}

template<typename A, typename B, typename C>
string ToString(A a, B b, C c)
{
    stringstream ss;
    ss << a << b << c;
    return ss.str();
}

这可以通过Boost.Preprocessor库自动（稍微）。

在C ++ 0x中，您可以使用如下的可变参数模板：

#include <iostream>

void f()
{
}

template <class T, class ... Ts>
void f(const T& a, const Ts&... args)
{
  std::cout << a;
  f(args...);
}

Answer 2

几乎像真实的东西： - ）

#include <iostream>
#include <string>
#include <sstream>
using namespace std;

template<class L,class R>
struct cons_t
{
    const L &l; const R &r;
    cons_t(const L &_l, const R &_r) : l(_l),r(_r) {}
};
template<>
struct cons_t<void,void>{};
typedef cons_t<void,void> cons;

template<class L,class R,class A>
cons_t< cons_t<L,R>, A> operator , (const cons_t<L,R> &l, const A &arg)
{
    return cons_t< cons_t<L,R>, A>(l,arg);
}
void to_stream(stringstream &s, const cons_t<void,void> &) { }
template<typename L, typename R>
void to_stream(stringstream &s, const cons_t<L,R> &c)
{
    to_stream(s, c.l); 
    s << c.r;
}
template<typename L, typename R>
string to_string(const cons_t<L,R> &c)
{
    stringstream ss;
    to_stream(ss,c);
    return ss.str();
}

#define ToString(...) to_string((cons(),__VA_ARGS__))
int main()
{
    cout << ToString(1,2,"Hi There",3.14159);
}

Answer 3

我知道这可能是一个学术问题，所以解决方案可能不是你想要的。

但是

在现实生活中处理这种情况的一种简单方法是传入对象的List或Array，而不是有多个参数。
你知道，像Main（）

具有未知数量参数的C ++模板函数

3 个答案: