可变参数模板和新的

Question

我有这样的类模板：

template<class... T>
class Test {
  std::vector<TestCase*> test_cases;
public:
  Test() {
    // Here, for each T an instance should be added to test_cases.
    test_cases.push_back((new T)...);
  }
};

这对于一个模板参数来说效果很好，但是对于多个参数我收到此错误：

error: too many arguments to function call, expected 1, have 2

如何以这种方式将可变参数模板与 new 一起使用？正确的语法是什么？

---

编辑：我认为我的问题不太清楚。我想要的是这样的：

Test<TestCase1, TestCase2, TestCase3>;
// The constructor will then be:
test_cases.push_back(new TestCase1);
test_cases.push_back(new TestCase2);
test_cases.push_back(new TestCase3);

---

我的编译器是 clang 163.7.1，带有此标志：-std=c++0x。

Answer 1

vector::push_back 需要一个参数，因此您无法在函数调用中扩展可变参数模板。
我还为基类（所有其他类派生自该基类）添加了一个模板参数。

这是编译的内容。

struct base{};
struct d0 : base{};
struct d1 : base{};
struct d2 : base{};

#include <vector>

// termination condition for helper function
template <class T>
void add(std::vector<T*>&) { 
}

// helper function
template <class T, class Head, class... Tail>
void add(std::vector<T*>& v) { 
       v.push_back(new Head()); 
       add<T, Tail...>(v);
}

template <class T, class ... U>
class test
{
    std::vector<T*> vec;
public:
    test() {
       add<T, U...>(vec);      
    }
};

int main() 
{
    test<base, d0,d1,d2> t;
}

Answer 2

您可以完成此任务，但由于您直接编写表达式，因此有点迂回。您需要为可变参数模板参数列表中的每个参数调用一次push_back。

你如何实现这一目标？好吧，通过为每个模板参数调用一次递归函数：

template <typename Base, typename T1, typename T2, typename... T>
void fill(std::vector<Base*>& vec) {
    vec.push_back(new T1);
    fill<Base, T2, T...>(vec);
}

template <typename Base, typename T1>
void fill(std::vector<Base*>& vec) {
    vec.push_back(new T1);
}

这里我们有两个 fill 函数的重载，一个带有可变参数模板参数列表，另一个没有 - 这是递归基本情况。只要仍然至少有两个模板参数，就会调用第一个版本。如果只剩下一个参数，则调用第二个参数。

在构造函数中这样调用它：

fill<TestCase, T...>(test_cases);

Answer 3

包扩展只能在选定的几种情况下发生，并且不适用于任意表达式或语句。但是，由于其中一种情况是列表初始化，并且由于操作顺序是为列表初始化语法的大括号初始值设定项定义的，因此始终可以扩展任意语句。也就是说：

typedef std::initializer_list<int> expand;
expand { ( test_cases.push_back(new T), void(), 0 )... };

void() 技巧是抑制对重载运算符 的任何调用。此处完全不相关，但我已将其包含在内，因为在重构宏中的功能时它可能很有用：

#define EXPAND( exp ) \
    std::initializer_list<int> { ( (exp), void(), 0 )... }

// No use of '...', it's in the macro body
EXPAND(( test_cases.push_back(new T) ));

Answer 4

相关说明，在这种特殊情况下，您可以通过如下编写构造函数来使用向量的 initializer_list 支持，

Test()
:test_cases{ new T ... }
{ }

或者如果由于任何原因无法使用构造函数初始值设定项，则可以使用赋值

Test() {
  test_cases = { new T ... };
}

Answer 5

也许您想要 std::vector 中的元组？不确定这是否是您想要的，但这至少可以在我的 G++ 4.6.1 上编译：D

#include <vector>
#include <utility>
#include <functional>
#include <string>

template<class... T>
class Test {
  std::vector<std::tuple<T*...>> test_cases;
public:
  Test() {
    // Here, for each T an instance should be added to test_cases.
    test_cases.push_back(std::tuple<T*...>((new T)...));
  }
};

int main()
{
   Test<int, float> foo;
   Test<std::string, double> bar;
}

Answer 6

我突然想到你想要一个 any 类型的动态向量（虽然不是我个人看的，但一位朋友告诉我，boost 库中显然有类似的东西），而不是模板向量。

模板向量基本上是一个可以采用任何一个定义类型的向量（所有整数，或所有双精度数，或所有浮点数，但不是整数、双精度数和浮点数）。

传统上没有这样的类的原因是因为每个项目在内存中占用不同的块大小（char 是一个字节，int 可以是 4 个字节等），并且在查找时需要额外的资源知道会发生什么（正常存储是连续的......向量是什么，假设它“基本上”是一个数组）。

如果你想构建自己的（我尝试过），你会看到 void * 指针、动态内存分配和涉及类型转换的一系列令人头疼的问题（我不知道有任何自动化方法可以在幕后正确类型转换项目） ，但其他人也许能够参与）。