c++ 11 递归 class 复杂错误模板

Question

为什么将#if 0 更改为#if 1 时出现"error C1202: recursive type or function dependency context too complex" 错误？错误版本更简单，我宁愿使用类似的东西。

我正在尝试编写一个散列函数来消除编译时间常数长度的循环。真正的哈希函数比较复杂，这里只是一个简单的例子。

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>...但是在模板中，必须实例化整个函数体。分支只会在稍后得到 p运行ed。因此，无论 CB 的值如何，Hash 的任何实例化都会不断实例化越来越多的 CB 值（例如 Hash<9> 需要 Hash<5> 需要 Hash<1> 需要 Hash<-3> 需要 Hash<-7> ... ) 直到它达到编译器模板递归限制或编译器刚刚运行s 内存不足

另一方面，如果您明确特化所有情况：

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> 只是一个显式特化，过程就此停止。

这就是为什么在涉及模板元编程时，您应该将专业化视为您的分支和基本递归案例。不要考虑实际的运行-time b运行ches。

c++ 11 递归 class 复杂错误模板

c++ 11 recursive class template to complex error

c++

recursion

templates

c++11