在具有部分特化的 C++ 中使用模板展开循环

Question

我正在尝试使用模板在 C++ 中展开循环，如下所示。

#include <iostream>

template< class T, T i >
struct printDown {
    static void run(void) {
        std::cout << i << "\n";
        printDown< T, i - 1 >::run();
    }
};

template< class T >
struct printDown< T, 0 > {
    static void run(void) {
        std::cout << 0 << "\n";
    }
};

int main(void) {
    printDown< int, 10 >::run();
    return 0;
}

当我在 Cygwin 中使用 g++ 3.4.4 编译时，出现以下错误。

tmp.cpp:12: error: type T' of template argument0' 取决于 模板参数

我做错了什么？我需要以某种方式注释 0 以说明它是 T 类型吗？

提前致谢。

Answer 1

您是否尝试过int i 而不是T i？

Answer 2

为什么会这样？从 14.5.5/8 开始，

——模板参数的类型 对应一个专门的 非类型参数不应 取决于参数 专业化。 [ 例子：

template <class T, T t> struct C {};
template <class T> struct C<T, 1>; // error
template< int X, int (*array_ptr)[X] > class A {};
int array[5];
template< int X > class A<X,&array> { }; // error

——结束示例]

因此，当您应用部分特化时，0 的类型是 T（取决于特化的参数）。有两种选择，一是使其不依赖，例如将 T i 更改为 int i，二是应用显式特化而不是部分特化。

这两个解决方案都是别人给出的，所以我不会在这里转发。至少你知道原因。它是由标准定义的。

Answer 3

正如phooji 所指出的，您的实现存在一个小问题：它会快速生成一长串调用，这会使编译器很快窒息。

您可以通过使用二进制分解实现稍微复杂的版本来解决此问题。我也会让它在仿函数上通用，因为我很懒。

// Signature
template <Functor F, unsigned N>
struct UnrolledLoop;

我们需要一个辅助模板，它保留要传递的参数的偏移量

template <Functor F, unsigned N, unsigned OffSet>
struct UnrolledImpl;

template <Functor F, unsigned OffSet>
struct UnrolledImpl<F, 0, OffSet>
{
  static F run(F f) { return f; }
};

template <Functor F, unsigned OffSet>
struct UnrolledImpl<F, 1, OffSet>
{
  static F run(F f) { f(OffSet); return f; }
};

template <Functor F, unsigned N, unsigned OffSet>
struct UnrolledImpl
{
  static F run(F f) {
    F f2 = UnrolledImpl<F, N/2, OffSet>::run(f);
    return UnrolledImpl<F, N - N/2, OffSet + N/2>::run(f2);
  }
};

您可以简单地实现UnrolledLoop：

template <Functor F, unsigned N>
struct UnrolledLoop
{
  static F run(F f) { return UnrolledImpl<F, N, 0>::run(f); }
}

请注意，您可以为 N 的更多值（例如 3、4）提供专门化，以便在编译器上更好。

Answer 4

如何将其添加到您的示例中：

template struct printDown< int, 0 >{
    static void run(void) {
    std::cout << 0 << "\n";
} };

如果事先不知道 T 的类型，编译器不能自动将 0 转换为 int。

Answer 5

刚刚发现。显然可以做这样的事情。

template< class T, T i, bool b = (i == 0) >
struct printDown {
    static void run(void) {
        std::cout << i << "\n";
        printDown< T, i - 1 >::run();
    }
};

template< class T, T i >
struct printDown< T, i, true > {
    static void run(void) {
        std::cout << 0 << "\n";
    }
};

我不知道可以这样做。非常Prologish，非常好。

Answer 6

您可以将参数设为类型参数来解决此问题

template< bool > struct bool_ { };

template< class T, T i, typename = bool_<true> >
struct printDown {
    static void run(void) {
        std::cout << i << "\n";
        printDown< T, i - 1 >::run();
    }
};

template< class T, T i >
struct printDown< T, i, bool_<i == 0> > {
    static void run(void) {
        std::cout << 0 << "\n";
    }
};

int main(void) {
    printDown< int, 10 >::run();
    return 0;
}

这样你可以在偏特化中指定你想要的任何条件。