可变函数模板中的歧义

Question

我最近开始尝试各种模板技巧。在这种情况下，我尝试实现一个 class 来保存由使用参数包的可变参数模板提供的数字序列。

但是，我运行遇到一些不会发生在我使用的编译器上的问题 (Intel C++ 14) ，但在 CLang 或 GCC 等其他人身上。因此，我很困惑哪个编译器在对标准的解释中 "more on point"。

这是我的代码：

#include <iostream>

using namespace std;

template< size_t... Sequence >
class CSequence
{ 
    public:
        CSequence()
        {
            this->generate< Sequence... >();
            this->out();
        }

    private:
        // Recursion end
        template< size_t N >
        void generate(size_t sz)
        {
            // Create array
            this->m_Array = new size_t[sz+1];

            this->m_Len = sz+1;

            this->m_Array[sz] = N;
        }

        // Recursion segment
        template< size_t N, size_t... Ns >
        void generate(size_t sz)
        {
            generate<Ns...>(sz+1);

            this->m_Array[sz] = N;
        }

        // Recursion start
        template< size_t... Ns >
        void generate()
        {
            generate<Ns...>(0);
        }         

        void out()
        {
            for(int i = 0; i < this->m_Len; i++)
            {
                std::cout << this->m_Array[i] << " ";
            }

            std::cout << std::endl;
        }

    private:
        size_t*     m_Array;
        size_t      m_Len;
};

int main()
{
    CSequence< 1, 2, 3, 4, 5, 6, 7, 8 > a;
   std::getchar();
}

这在我这边使用 Intel C++ 14 编译得很好，并产生了我期望的结果：

1 2 3 4 5 6 7 8

但是在最新版本的 CLang 和 GCC 上编译失败：

CLang @ wandbox Online compiler
海湾合作委员会@ wandbox Online compiler

现在，我终于明白失败的原因了：由于参数包可以包含零个元素，示例调用

generate< 8 >( size_t );

可以同时解析为

generate< N = 8, Ns = <> > ( size_t )

和

generate< N = 8 > ( size_t )

从而导致无法解决的歧义。但它在我这边编译并实际给出预期结果的事实让我想知道：

哪个编译器是"right"？显然，与 CLang 或 GCC 相比，Intel C++ 做出了一些额外的决定。这"illegal"是关于标准的吗？或者只是缺少 GCC/CLang？
有什么方法可以避免这种行为吗？

请注意，这段代码被视为某种实验，因此我对这段代码的替代策略和修复感到满意。

Answer 1

Clang 和 GCC 是正确的，因为参数包可以包含零个元素，并且没有为这种情况定义偏序，因此调用不明确。

解决这个问题的最简单方法是使递归案例采用额外的模板参数。这样调用就完全没有歧义了：

// Recursion segment
template< size_t N1, size_t N2, size_t... Ns >
//              extra param ^^
void generate(size_t sz)
{
    generate<N2,Ns...>(sz+1);
    //add N2 ^^

    this->m_Array[sz] = N1;
}

Answer 2

这根本不需要递归实现。

template< size_t... Ns >
void generate()
{
    m_Len = sizeof...(Ns);
    m_Array = new size_t[m_Len] { Ns... };
}

您也可以省去动态分配并使 m_Array 成为实际数组，并使用 NSDMI 对其进行初始化：

size_t m_Array[sizeof...(Sequence)] = {Sequence... };

可变函数模板中的歧义

Ambiguity in variadic function template

c++

templates

variadic-templates

c++11