使用 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: 错误：输入 T' of 模板参数0'取决于 模板参数

我做错了什么？我是否需要以某种方式注释 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;
}

这样您就可以在部分特化中指定所需的任何条件。