模拟运行时数字模板参数的成语？

Question

假设我们有

template <unsigned N> foo() { /* ... */ }

定义。现在，我要实现

do_foo(unsigned n);

调用foo() 的相应变体。这不仅仅是一个综合的例子——这确实发生在现实生活中（当然，不一定有 void-to-void 函数和一个模板参数，但我正在简化。当然，在 C++ 中，我们不能有以下几点：

do_foo(unsigned n) { foo<n>(); }

而我现在做的是

do_foo(unsigned n) { 
    switch(n) {    
    case n_1: foo<n_1>(); break;
    case n_2: foo<n_2>(); break;
    /* ... */
    case n_k: foo<n_k>(); break;
    }
}

当我知道 n 有效地限制在 n_1,...,n_k 的范围内时。但这很不合时宜，当调用时间较长并且我需要多次复制一长串模板和常规参数时更是如此。

我正要开始编写一个宏来生成这些 switch 语句，这时我想也许有人已经在某个库中进行了此工作并且可以分享他们所做的。如果不是，也许仍然可以使用某种 C++ 构造，该构造采用任意函数，具有任何模板和非模板参数序列，包括一些数字模板参数，以及某种形式的值序列，以生成包装器可以将该模板参数作为附加的运行时参数，例如

auto& transformed_foo = magic<decltype(foo)>(foo)::transformed;

Answer 1

为了使这更容易，我将围绕foo 制作一个函子包装器：

struct Foo {
    template <unsigned N>
    void operator()(std::integral_constant<unsigned,N>)
    { foo<N>(); }
};

现在我们可以勾勒出我们的访客：

template <std::size_t Start, std::size_t End, typename F>
void visit(F f, std::size_t n) {
    //magic
};

完成后，它会被这样调用：

visit<0, 10>(Foo{}, i);
// min^  ^max       

魔术将涉及使用索引技巧。我们将生成一个涵盖所需范围的索引序列并将标签分派给一个助手：

visit<Start>(f, n, std::make_index_sequence<End-Start>{});

现在是实施的真正内容。我们将构建一个 std::functions 数组，然后使用运行时提供的值对其进行索引：

template <std::size_t Offset, std::size_t... Idx, typename F>
void visit(F f, std::size_t n, std::index_sequence<Idx...>) {
    std::array<std::function<void()>, sizeof...(Idx)> funcs {{
        [&f](){f(std::integral_constant<unsigned,Idx+Offset>{});}...
    }};

    funcs[n - Offset]();
};

这当然可以更通用，但这应该为您提供一个很好的起点来应用您的问题域。

Live Demo

Answer 2

这是@TartanLlama 将无参数函数的解决方案扩展到具有任意数量参数的函数。它还有一个额外的好处，那就是规避 GCC 错误（版本 8 之前），即当扩展是 lambda 时无法正确扩展可变参数模板参数包。

#include <iostream>
#include <utility>
#include <array>
#include <functional>

struct Foo {
    template <std::size_t N, typename... Ts> void operator()(std::integral_constant<std::size_t,N>, Ts... args)
    { foo<N>(std::forward<Ts>(args)...); }
};

template <std::size_t N, typename F, typename... Ts>
std::function<void(Ts...)> make_visitor(F f) {
    return 
        [&f](Ts... args) {
            f(std::integral_constant<std::size_t,N>{}, std::forward<Ts>(args)...);
        };
}

template <std::size_t Offset, std::size_t... Idx, typename F, typename... Ts>
void visit(F f, std::index_sequence<Idx...>, std::size_t n, Ts... args) {
    static std::array<std::function<void(Ts...)>, sizeof...(Idx)> funcs {{
        make_visitor<Idx+Offset, F, Ts...>(f)...
    }};
    funcs[n-Offset](std::forward<Ts>(args)...);
};

template <std::size_t Start, std::size_t End, typename F, typename... Ts>
void visit(F f, std::size_t n, Ts... args) {
    visit<Start>(f, std::make_index_sequence<End-Start>{}, n, std::forward<Ts>(args)...);
};

Live demo

Answer 3

虽然其他两个答案相当通用，但编译器很难对其进行优化。我目前处于非常相似的情况，使用以下解决方案：

#include <utility>
template<std::size_t x>
int tf() { return x; }

template<std::size_t... choices>
std::size_t caller_of_tf_impl(std::size_t y, std::index_sequence<choices...>) {
  std::size_t z = 42;
  ( void( choices == y && (z = tf<choices>(), true) ), ...);
  return z;
}

template<std::size_t max_x, typename Choices = std::make_index_sequence<max_x> >
std::size_t caller_of_tf(std::size_t y) {
  return caller_of_tf_impl(y, Choices{});
}

int a(int x) {
  constexpr std::size_t max_value = 15;
  return caller_of_tf<max_value+1>(x);
}

我们有一些模板函数tf，出于说明原因，它只返回其模板参数和一个函数caller_of_tf(y)，它希望在给定运行时参数y的情况下调用适当的tf<X>。它本质上依赖于首先构造一个适当大小的参数包，然后使用短路&& 运算符扩展此参数包，该运算符严格仅在第一个参数为真时才评估其第二个参数。然后，我们只需将运行时参数与参数包的每个元素进行比较。

这个解决方案的好处是它很容易优化，例如Clang 将上面的 a() 变成检查 x 是否小于 16 并返回它。 GCC 的优化程度稍差，但仍设法仅使用 if-else 链。对 einpoklum 发布的解决方案执行相同操作会导致生成更多程序集（例如使用 GCC）。当然，缺点是上面的解决方案更具体。