C++ 11递归类模板到复杂错误

Question

为什么在将#if 0更改为#if 1时出现“错误C1202：递归类型或函数依赖关系上下文过于复杂”错误？错误版本更简单，我宁愿使用类似的东西。

我想写一个散列函数，消除编译时间常量长度的循环。真正的哈希函数更复杂，这只是一个简单的例子。

typedef unsigned __int8 U1; 
typedef unsigned __int16 U2; 
typedef unsigned __int32 U4; 
#define AS1(a_)  (*(U1*)(a_)) 
#define AS2(a_)  (*(U2*)(a_)) 
#define AS3(a_)  ((U4(((U1*)(a_))[2])<<16) | AS2(a_)) 
#define AS4(a_)  (*(U4*)(a_)) 

#if 0 
template<U4 CB> U4 Hash(const char* sz, int n = 0) { 
    if (CB >= 4) return Hash<CB - 4>(sz + 4, n^AS4(sz)); 
    if (CB == 3) return n^AS3(sz); 
    if (CB == 2) return n^AS2(sz); 
    if (CB == 1) return n^AS1(sz); 
} 
#else 
template<U4 CB> U4 Hash(const char* sz) { 
    return Hash<CB - 4>(sz + 4, Hash<4>(sz)); 
} 
template<U4 CB> U4 Hash(const char* sz, int n) { 
    return Hash<CB - 4>(sz + 4, Hash<4>(sz, n)); 
} 
template<> U4 Hash<1>(const char* sz, int n)  { return n^AS1(sz); } 
template<> U4 Hash<2>(const char* sz, int n)  { return n^AS2(sz); } 
template<> U4 Hash<3>(const char* sz, int n)  { return n^AS3(sz); } 
template<> U4 Hash<4>(const char* sz, int n)  { return n^AS4(sz); } 
template<> U4 Hash<1>(const char* sz)   { return AS1(sz); } 
template<> U4 Hash<2>(const char* sz)   { return AS2(sz); } 
template<> U4 Hash<3>(const char* sz)   { return AS3(sz); } 
template<> U4 Hash<4>(const char* sz)   { return AS4(sz); } 
#endif 

int main(int argc, char* argv[]) 
{ 
    char* sz = "123456789"; 
    int n = Hash<9>(sz); 
    n += Hash<3>(sz); 
    return n; 
} 

Answer 1

问题是这样的功能是无限递归在编译时：

template<U4 CB> U4 Hash(const char* sz, int n = 0) { 
    if (CB >= 4) return Hash<CB - 4>(sz + 4, n^AS4(sz)); 
    if (CB == 3) return n^AS3(sz); 
    if (CB == 2) return n^AS2(sz); 
    if (CB == 1) return n^AS1(sz); 
} 

当然，你有if报表，因此，如果您拨打Hash<3>你并不真的指望它要实例Hash<-1> ...但在模板中，函数的整个主体必须​​被实例化。分支只在稍后修剪。所以不管CB价值的Hash任何实例将保持实例的CB越来越多值（例如Hash<9>需要Hash<5>需要Hash<1>需要Hash<-3>需要Hash<-7> ...），直至碰到编译模板递归限制或编译器只是用完内存

在另一方面，如果你明确地专注所有的案件：

template<U4 CB> U4 Hash(const char* sz, int n = 0) { 
    return Hash<CB - 4>(sz + 4, n^AS4(sz)); 
} 

template <> U4 Hash<3>(const char* sz, int n = 0) { 
    return n^AS3(sz); 
} 

// etc. 

然后，比方说，Hash<9>实例化会导致Hash<5>的实例，然后Hash<1>只是一个明确的专业化，并且过程停在那里。

这就是为什么当涉及到模板元编程时，您应该将专业化看作您的分支和基础递归情况。不要想到实际的运行时早午餐。