c++ - 可变参数模板 - 不完整类型

Question

有这个代码:

template<class ...Args>
struct Are_Same
{
    enum {value = Are_Same<Args...>::value};
};

template<class A,class... C>
struct Are_Same<A,C...>
{
    enum {value = Are_Same<A,C...>::value};//HERE is THE ERROREOUS LINE
};

template<class A,class B>
struct Are_Same<A,B>
{
    enum {value = std::is_same<A,B>::value};
};  

我从 gcc 4.6.1 得到错误:

error: incomplete type 'Are_Same' used in nested name specifier.

我认为通过做 Are_Same<A,C...>::value我将调用递归调用，最后将简单地扩展为 Are_Same<A,B> .显然不是这样的。任何人都知道我在哪里犯错？

Answer 1

我认为模板的定义是错误的，在这两种情况下你都触发了精确的递归。我本以为编译器会因编译器内部的一些 stackoverflow 而死，但会产生不同的错误...

are_same 可变参数模板的实现可以是:

template <class... Args>                    // base (optional to declare the template)
struct are_same;

template <class A, class B, class... Args>  // recursion
struct are_same<A,B,Args...> {
    static const bool value = is_same<A,B>::value && are_same<A,Args...>::value;
};

template <class A, class B>                 // stop condition
struct are_same<A,B> {
    static const bool value = is_same<A,B>::value;
};

请注意，在递归 步骤中，一个参数从参数列表中删除，因此要解决的新问题是原始问题的简化 版本。这种类型的模板元编程与递归非常相关，并且适用相同的规则，为了能够使用递归，您需要确保每个递归步骤都让您更接近解决方案。在这种特殊情况下，给定 N 个可能相同类型的列表，每个步骤都会将问题简化为查找 N-1 个类型是否相同。

您也可以使用 are_same 问题的退化版本作为停止条件(替换前一个条件):

template <class A> 
struct are_same<A> {
   static const bool value = true;
};

从某种意义上说，它是退化的，因为询问单一类型是否*是相同的*确实没有意义，但对于不同的元编程任务，它可能是合适的。

不依赖于 is_same 的另一种可能更有效的算法(我不确定编译器是否会避免在上面的递归步骤中实例化模板)可能是:

template <class... Args>
struct are_same;

template <class A, class... Args>
struct are_same<A,A,Args...> {              // recursion
    static const bool value = are_same<A,Args...>::value;
};

template <class A, class B, class... Args>
struct are_same<A,B,Args...> {              // cut, A and B are not the same
    static const bool value = false;
};

template <class A>
struct are_same<A> {                        // end of recursion
    static const bool value = true;
};

在这种情况下，只要两种类型相同，编译器就会优先选择 recursion 而不是 cut 步骤，所以我们不需要检查 is_same内部。同时，如果编译器进入 cut 步骤，我们不需要处理类型列表的其余部分，因为我们已经知道答案了。