可变函数模板中的歧义

Question

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

但是，我遇到了一些问题，这些问题在我使用的编译器（ 英特尔C ++ 14 ）上没有发生，但在其他问题上，如CLang或GCC 。 因此，我很困惑哪个编译器在解释标准时“更加重要”。

这是我的代码：

#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();
}

这使用英特尔C ++ 14编译得很好，并产生我期望的结果：

1 2 3 4 5 6 7 8 

但是在CLang和GCC的最新版本上，它无法编译：

• CLang @ wandbox在线编译器
• GCC @ wandbox在线编译器

现在，我实际上可以理解失败的原因：因为参数包可以包含零元素，所以示例性调用

generate< 8 >( size_t );

可以解决为

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

并作为

generate< N = 8 > ( size_t )

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

1. 哪个编译器“正确”？ 显然，与CLang或GCC相比， 英特尔C ++做出了一些额外的决定。 这个标准是“非法的”吗？ 或者GCC / CLang缺乏？
2. 有没有办法规避这种行为？

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

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... };