c++ - 这个for循环可以用预处理器完成吗？

Question

我的代码使用了一个使用模板函数的库（FastLED）：

#define NUM_WIDGETS 4

Library.function<1>();
Library.function<2>();
Library.function<3>();
Library.function<4>();

我不能把它放在一个正常的 for 循环中，因为模板参数需要在编译时是可计算的。我可以在预处理器中执行此操作吗？还有什么建议吗？我希望能够方便地更改 NUM_WIDGETS 而无需复制粘贴这些行。

Answer 1

您可以在以下工具的帮助下使用模板来做到这一点std::index_sequence：

constexpr size_t NUM_WIDGETS = 4;

template <size_t N>
void foo() {
    std::cout << N << '\n';
}

template <size_t... Ns>
void call_foo_helper(std::index_sequence<Ns...>) {
    (foo<Ns>(), ...);
}

template <size_t N>
void call_foo() {
    call_foo_helper(std::make_index_sequence<N>());
}

int main() {
    call_foo<NUM_WIDGETS>();
}

这使用 C++17 折叠表达式。如果您没有可用的 C++17，则可以使用递归模板：

constexpr size_t NUM_WIDGETS = 4;

template <size_t N>
void foo() {
    std::cout << N << '\n';
}

template <size_t N>
void call_foo() {
    foo<N>();
    call_foo<N - 1>();
}

template <>
void call_foo<0>() { }

int main() {
    call_foo<NUM_WIDGETS>();
}

Answer 2

基于折叠表达式或递归模板的解决方案更胜一筹。但是，如果您想要一个预处理器解决方案，您可以查看您的编译器是否将包含深度作为预定义的宏提供。例如，GCC 提供__INCLUDE_LEVEL__（和 MSVC 提供__COUNTER__）。然后，您可以使用递归包含来生成模板函数调用。

$ gcc -E r.cc | grep -v '^#' | sed '/^ *$/d'
int main()
{
   Library.function<1>();
   Library.function<2>();
   Library.function<3>();
   Library.function<4>();
}
$ cat r.cc
int main()
{
    #define NUM_WIDGETS 4
    #include "r.i"
}
$ cat r.i
#ifndef NUM_WIDGETS
# error "NUM_WIDGETS needs to be defined!"
#else
# if (__INCLUDE_LEVEL__) < ((NUM_WIDGETS) + 1)
   Library.function<__INCLUDE_LEVEL__>();
#  include __FILE__
# endif
#endif

此技术仅限于编译器的嵌套包含限制。

Answer 3

迈尔斯回答中的模板解决方案绝对是要走的路。

但只是为了好玩，您实际上也可以使用预处理器来完成：

#include <iostream>
#include <boost/preprocessor/repetition/repeat.hpp>

template <int N> void function() { std::cout << N << "\n"; }

#define NUM_WIDGETS 4

int main()
{
#define CALL_FUNC(z,n,d) function<n+1>();
    BOOST_PP_REPEAT(NUM_WIDGETS, CALL_FUNC, ~)
#undef CALL_FUNC
}

这不太好，因为NUM_WIDGETS预处理器需要将计数作为纯数字字符串知道。Not (4), not 4U, notconstexpr变量等等。并且 Boost.Preprocessor 确实有 256 次重复的限制（如果使用 MSVC，则略少）。

Answer 4

正如我之前在评论中提到的，使用模板比使用预处理器更容易做到这一点。

首先定义一个模板

 template<unsigned n> void invoke() {Library.function<n>();  invoke<n-1>();};

然后特化一个什么都不做的结束条件

 template<> void invoke<0U>() {};

并称之为

 int main()
 {
      invoke<NUM_WIDGETS>();
 }

这将以与指定相反的顺序调用该函数。这可以通过将模板函数更改为

 template<unsigned n> void invoke() {Library.function<NUM_WIDGETS + 1 - n>(); invoke<n-1>();};

并保持相同的专业化以结束递归。

当然，如果你需要做这样的技巧（无论是使用预处理器还是模板），这暗示了一个损坏的设计，你应该首先问为什么Library.function()是模板。