c++ - 可变参数模板 : "Sorry, unimplemented: cannot expand ' Identifier. 的 GCC 错误。 .' into a fixed-length argument list"

Question

在 GCC 上使用 C++11 进行可变参数模板编程时，偶尔会收到一条错误消息，提示“抱歉，未实现:无法将 '标识符...' 扩展为固定长度的参数列表。”如果我删除代码中的“...”，我会得到一个不同的错误:“错误:参数包没有用'...'扩展”。

因此，如果我输入了“...”，则 GCC 将其称为错误，如果我将“...”取出，则 GCC 也将其称为错误。

我能够处理这个问题的唯一方法是使用不同的方法从头开始完全重写模板元程序，并且(幸运的是)我最终想出了不会导致错误的代码。但我真的很想知道我做错了什么。尽管谷歌搜索并进行了大量实验，但我无法确定我在产生此错误的可变参数模板代码和没有错误的代码之间所做的不同。

错误消息的措辞似乎暗示代码应该按照 C++11 标准工作，但 GCC 还不支持它。或者它可能是一个编译器错误？

这是一些产生错误的代码。注意:我不需要您为我编写正确的实现，而只是指出导致此特定错误的代码是什么

// Used as a container for a set of types.
template <typename... Types> struct TypePack
{
    // Given a TypePack<T1, T2, T3> and T=T4, returns TypePack<T1, T2, T3, T4>
    template <typename T>
    struct Add
    {
        typedef TypePack<Types..., T> type;
    };
};

// Takes the set (First, Others...) and, while N > 0, adds (First) to TPack.
// TPack is a TypePack containing between 0 and N-1 types.
template <int N, typename TPack, typename First, typename... Others>
struct TypePackFirstN
{
    // sorry, unimplemented: cannot expand ‘Others ...’ into a fixed-length argument list
    typedef typename TypePackFirstN<N-1, typename TPack::template Add<First>::type, Others...>::type type;
};

// The stop condition for TypePackFirstN:  when N is 0, return the TypePack that has been built up.
template <typename TPack, typename... Others>
struct TypePackFirstN<0, TPack, Others...> //sorry, unimplemented: cannot expand ‘Others ...’ into a fixed-length argument list
{
    typedef TPack type;
};

编辑:我注意到，虽然看起来像的部分模板实例化确实会导致错误:

template <typename... T>
struct SomeStruct<1, 2, 3, T...> {};

重写它不会产生错误:

template <typename... T>
struct SomeStruct<1, 2, 3, TypePack<T...>> {};

似乎您可以声明部分特化的参数是可变参数的；即这条线没问题:

template <typename... T>

但你实际上不能使用特化中的那些参数包，即这部分不行:

SomeStruct<1, 2, 3, T...>

事实上，如果你将包包装成其他类型，你就可以让它工作，例如:

SomeStruct<1, 2, 3, TypePack<T...>>

对我来说意味着对部分模板特化的可变参数的声明是成功的，你只是不能直接使用它。谁能证实这一点？

Answer 1

有一个技巧可以让它与 gcc 一起工作。该功能尚未完全实现，但您可以构建代码以避免未实现的部分。手动将可变参数模板扩展为参数列表是行不通的。但是模板特化可以为您做到这一点。

template< char head, char ... rest >
struct head_broken
{
   static const char value = head;
};

template< char ... all >
struct head_works; // make the compiler hapy

template< char head, char ... rest >
struct head_works<head,rest...> // specialization
{
   static const char value = head;
};

template<char ... all >
struct do_head
{
   static const char head = head_works<all...>::value;
   //Sorry, unimplemented: cannot expand 'all...' into a fixed-length arugment list
   //static const char head = head_broken<all...>::value;
};

int main
{
   std::cout << head_works<'a','b','c','d'>::value << std::endl;
   std::cout << head_broken<'a','b','c','d'>::value << std::endl;
   std::cout << do_head<'a','b','c','d'>::head << std::endl;
}

我用 gcc 4.4.1 对此进行了测试