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

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 收到错误：

错误：使用的类型“Are_Same”不完整 嵌套名称说明符。

我认为通过执行 Are_Same::value 我将调用递归调用，最后将简单地扩展为 Are_Same >。显然事实并非如此。谁知道我在哪里犯了错误？

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

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

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

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

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

不依赖于 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;
};

在这种情况下，编译器将当两种类型相同时，我们更喜欢使用递归而不是cut步骤，因此我们不需要在内部检查is_same。同时，如果编译器进入 cut 步骤，我们不需要处理类型列表的其余部分，因为我们已经知道答案。

Answer 2

我会这样做：

#include <type_traits>
#include <iostream> 

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

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

int main()
{
    std::cout<< std::boolalpha << are_same< int >::value << std::endl;
    std::cout<< std::boolalpha << are_same< int, int, int >::value << std::endl;
    std::cout<< std::boolalpha << are_same< int, int, double, int >::value << std::endl;
}

Answer 3

最简单的实现可能是这样的：

template <typename... TList>
struct are_same { constexpr static bool value = false; };

template <typename T, typename... TList>
struct are_same<T, T, TList...> { 
    constexpr static bool value = are_same<T, TList...>::value; 
};

template <typename T>
struct are_same<T> { constexpr static bool value = true; };

或者，您可以将停止条件替换为

template <typename T>
struct are_same<T, T> { constexpr static bool value = true; };

但第一个更通用，因为 are_same::value == true。另一个问题是 are_same<>::value 应该等于什么。这会给你 false 但添加一个像这样的模板专业化并不是什么大问题。

template <>
struct are_same<> { constexpr static bool value = true; };