将 args 参数包解压到可变参数模板中定义的每个类的构造函数中

Question

我正在尝试创建一个继承多个类（由可变参数模板定义）的类，并且对于每个类，将相同的 args 参数包传递给每个类的构造函数。但是，似乎我无法解压类的可变参数模板和 args 的参数包。

我有一个类：

template<class... __Policies>
class GenericPolicyAdapter : public __Policies...{

使用构造函数：

template<class... __Args>
GenericPolicyAdapter( __Args... args ) : __Policies( args... ){

和测试：

GenericPolicyAdapter<T1,T2> generic_policy_adapter( arg1, arg2, arg3 );

gcc 失败：

error: type ‘__Policies’ is not a direct base of ‘GenericPolicyAdapter<T1,T2>’

其中 __Policies = T1, T2

为了澄清，我本质上是在尝试这样做：

GenericPolicyAdapter : public T1, public T2
{
  public:
    template<class... __Args>
    GenericPolicyAdapter( __Args... args ) : T1( args... ), T2( args... ){}
};

但是使用 T1 和T2 从 __Policies 推导出来

有什么想法吗？看起来 gcc 将 __Policies 视为单一类型而不是类型列表。提前致谢！

---

编辑：

我应该澄清我正在使用 gcc/g++ 4.4.5。

Howard Hinnant 的建议是：

template<class... __Args>
    GenericPolicyAdapter( __Args... args )
        : __Policies( args...)...
    {}

但是，对于 gcc/g++ 4.4.5，这会导致包扩展表达式的使用无效。很高兴这可以在 OSX/clang 中工作，但是有没有办法在 gcc/g++ 中做到这一点？

Answer 1

“...”很像“typename”。你只需要继续积极地撒布它，直到事情编译完成。 :-)

template<class... __Policies>
class GenericPolicyAdapter
    : public __Policies...
{
public:
    template<class... __Args>
        GenericPolicyAdapter( __Args... args )
            : __Policies( args...)...
        {}
};

struct T1
{
    T1(int, int, int) {}
};

struct T2
{
    T2(int, int, int) {}
};

int main()
{
    GenericPolicyAdapter<T1,T2> generic_policy_adapter( 1, 2, 3 );
}

Answer 2

来自 http://www.open-std.org/jtc1/sc22 /wg21/docs/papers/2011/n3242.pdf

14.5.3 可变参数模板                              [温度变量]

5  名称出现在包扩展模式中的参数包将由该包扩展进行扩展。 参数包名称的外观仅由最内层的封闭包扩展来扩展。包扩展的模式应命名一个或多个未由嵌套包扩展扩展的参数包。由包扩展扩展的所有参数包应指定相同数量的参数。未展开的参数包名称的外观格式不正确。 [示例：

模板<类型名称...>结构体元组{}；
模板<类型名称 T1，类型名称 T2>结构对{}；

模板结构拉链{
  模板结构体带有 {
    typedef Tuple ...>>类型;
  };
};

typedef zip::with::type T1;
    // T1 是 Tuple, Pair>
typedef zip::with::type T2;
    // 错误：为 Args1 和 Args2 指定的参数数量不同

模板<类...参数>无效g（参数...参数）{
  f(const_cast(&args)...); // OK：“Args”和“args”被扩展
  f(5 ...); // 错误：模式不包含任何参数包
  f(参数); // 错误：参数包“args”未展开
  f(h(参数 ...) + 参数 ...); // OK：第一个“args”在 h 内扩展，第二个
  // “args” 在 f 中扩展
}

—示例结束]

我认为 f(h(args ...) + args ...); 可能是您将得到的最接近的标准示例。

请注意，如果您这样做了：

template<class... __Policies>
class GenericPolicyAdapter
    : public __Policies...
{
public:
    template<class... __Args>
        GenericPolicyAdapter( __Args... args )
            : __Policies(args)... // See the missing '...' ?
        {}
};

您将提取构造函数参数列表的单个参数，并将它们按顺序应用到基本构造函数。关键是在展开args之后再展开__Policies。

Answer 3

正如上面评论中提到的，目前 gcc 对可变参数模板的支持相当薄弱。尤其是在参数包扩展方面。 Gcc 4.6 甚至无法将包扩展为固定长度的列表。

以下代码是一种可能的解决方法，它基于一种更复杂的方法来解决我通常使用的这些限制。它只会在 svn 的最新 gcc 上进行编译：

#include <iostream>

template<class T>
struct derive : T
{
    template<class... A>
    derive( A... a ) :
        T(a...)
    {
    }
};

template<class X, class... T>
struct deriver;

template<class X>
struct deriver<X> :
    derive<X>
{
    template<class... A>
    deriver( A... a ) :
        derive<X>(a...)
    {
    }
};

template<class X, class... T>
struct deriver : 
    derive<X>, deriver<T...>
{
    template<class... A>
    deriver( A... a ) :
        derive<X>(a...), deriver<T...>(a...)
    {
    }
};

template<class... __Policies>
class GenericPolicyAdapter
    : public deriver<__Policies...>
{
public:
    template<class... __Args>
        GenericPolicyAdapter( __Args... args )
            : deriver<__Policies...>( args...)
        {}
};

#define BARK std::cout << __PRETTY_FUNCTION__ << "\n"
struct T1
{
    T1(int, int, int) {BARK;}
};

struct T2
{
    T2(int, int, int) {BARK;}
};

int main()
{
    GenericPolicyAdapter<T1,T2> generic_policy_adapter( 1, 2, 3 );
}

所有发布的 gcc 都会因以下问题而窒息：

sorry, unimplemented: cannot expand 'T ...' into a fixed-length argument list

这也可能通过更多间接方式解决，但这应该是一个很好的起点（取决于您想要多少可移植性）。