返回保存在 std::variant 映射中的 std::function

Question

我有一张std::variant地图，其中包含几个std::function专业化，例如：

// note the different return types
using function_t = std::variant<std::function<int(void)>, std::function<void(int)>>;
std::map<int, function_t> callbacks;
callbacks[0] = [](){ return 9; };

我如何编写一个caller(...)辅助函数，它会给我一个索引处保存在我的变体中的映射std::function的引用，允许类似于以下内容的调用：

int value = caller(callbacks, 0)();

由于function_t中包含不同的返回类型，因此简单的访问者不起作用，即：

// cannot compile
auto caller(std::map<int, function_t> callbacks, int idx) {
    return std::visit([](const auto& arg) { return arg; }, callbacks[idx]);    
}

Answer 1

第一部分是只有在参数匹配时才能调用函数：

struct void_t {};

template<class R, class...Args, class...Ts,
  // in C++20 do requires
  std::enable_if_t<sizeof...(Args)==sizeof...(Ts), bool> = true,
  class R0=std::conditional_t< std::is_same_v<R,void>, void_t, R >
>
std::optional<R0> call_me_maybe( std::function<R(Args...)> const& f, Ts&&...ts ) {

  if constexpr ( (std::is_convertible_v<Ts&&, Args> && ... ))
  {
    if constexpr (std::is_same_v<R, void>) {
      f(std::forward<Ts>(ts)...);
      return void_t{};
    } else {
      return f(std::forward<Ts>(ts)...);
    }
  }
  else
  {
    return std::nullopt;
  }
}
template<class R, class...Args, class...Ts,
  // in C++20 do requires
  std::enable_if_t<sizeof...(Args)!=sizeof...(Ts), bool> = true,
  class R0=std::conditional_t< std::is_same_v<R,void>, void_t, R >
>
constexpr std::optional<R0> call_me_maybe( std::function<R(Args...)> const& f, Ts&&...ts ) {
  return std::nullopt;
}

第二部分涉及一些变体的工作：

template<std::size_t I>
using index_t = std::integral_constant<std::size_t, I>;
template<std::size_t I>
constexpr index_t<I> index = {};

template<std::size_t...Is>
using variant_index_t = std::variant< index_t<Is>... >;
template<std::size_t...Is, class R=variant_index_t<Is...>>
constexpr R make_variant_index( std::size_t I, std::index_sequence<Is...> ) {
  constexpr R retvals[] = {
    R( index<Is> )...
  };
  return retvals[I];
}
template<std::size_t N>
constexpr auto make_variant_index( std::size_t I ) {
  return make_variant_index( I, std::make_index_sequence<N>{} );
}
template<class...Ts>
constexpr auto get_variant_index( std::variant<Ts...> const& v ) {
  return make_variant_index<sizeof...(Ts)>( v.index() );
}

这使您可以以更编译时友好的方式使用变体索引。

template<class...Ts>
std::optional<std::variant<Ts...>> var_opt_flip( std::variant<std::optional<Ts>...> const& var ) {
  return std::visit( [&](auto I)->std::optional<std::variant<Ts...>> {
    if (std::get<I>(var))
      return std::variant<Ts...>(std::in_place_index_t<I>{}, *std::get<I>(var));
    else
      return std::nullopt;
  }, get_variant_index(var) );
}

这让我们可以使用一个variant<optional<Ts>...>并产生一个optional<variant<Ts...>> ，即使有重复的类型。

我们现在需要能够构建正确的返回值。

现在我们可以编写这个函数，它接受函数和参数的变体，并可能调用活动的：

template<class...Sigs, class...Ts>
auto call_maybe( std::variant<std::function<Sigs>...> const& vf, Ts&&...ts )
{
  using R0 = std::variant< decltype(call_me_maybe(std::function<Sigs>{}, std::forward<Ts>(ts)...))... >;
  R0 retval = std::visit(
    [&](auto I)->R0 {
      return R0( std::in_place_index_t<I>{}, call_me_maybe(std::get<I>(vf), std::forward<Ts>(ts)... ) );
    },
    get_variant_index(vf)
  );
  return var_opt_flip( std::move(retval) );
}

然后我们重写caller来使用它：

using function_t = std::variant< std::function< void() >, std::function< int(int) > >;

template<class...Ts>
auto caller(std::map<int, function_t> const& callbacks, int idx, Ts&&...ts) {
  auto it = callbacks.find(idx);
  using R = decltype(call_maybe( it->second, std::forward<Ts>(ts)... ));
  // wrong index:
  if (it == callbacks.end())
    return R(std::nullopt);
  // ok, give it a try:
  return call_maybe( it->second, std::forward<Ts>(ts)... );
}

将会有一些编译器不喜欢我对auto I所做的事情； 在这些方面， decltype(I)::value替换I可能会有所帮助（我能说的是，并非所有编译器都符合 C++ 标准）。

基本思想是我们创建一个带有匹配索引的函数可能返回值的变体。 然后我们返回一个可选的，以处理失败肯定是可能的（在运行时）这一事实。

call_me_maybe是（除了歌曲参考）一种能够假装我们可以调用任何东西的方式。 这就是当R为void时nothing_t可能有用的地方。

variant_index_t是我用来将变体作为泛型和类型处理的技巧，其中可能包含重复类型。

首先，我们定义一个名为index的编译时整数。 它基于现有的std::integral_constant 。

然后我们制作这些的变体，使得替代 3 是编译时索引 3。

然后我们可以使用std::visit( [&](auto I){/*...*/}, get_variant_index(var) )将变体的索引用作编译时常量。

如果var有 4 个备选方案并持有备选方案 2，则get_variant_index返回一个std::variant<index<0>, index<1>, index<2>, index<3>> ，其中填充了index<2> 。

（在运行时，这似乎由 64 位整数2 。我觉得这很有趣。）

当我们std::visit这个variant_index ，我们传递的 lambda会通过index_t<I> 。 所以 lambda 有一个编译时常量传递给它。 在index_t<I>的编译器中，您可以constexpr通过它隐含的operator std::size_t从index_t<I>提取值。 对于愚蠢的编译器，您必须执行std::decay_t<decltype(I)>::value ，这将是相同的编译时整数。

使用该编译时整数，我们可以std::get<I>(var) lambda 中的值（并保证在正确位置的值），并且我们可以使用它来构造相同替代方案的另一个变体，即使那样其他变体有模棱两可的选择。 在你的情况下，你会看到，如果你有

std::function<int(int)>
std::function<int(int,int)>

“结果变体”看起来像std::variant<int,int> ——它不同于std::variant<int> 。

（作为附加步骤，您可以从此变体中删除重复类型，但我建议单独执行此操作）

每个call_me_maybe调用都返回一个optional<R> 。 但是一个variant<optional<R>...>是愚蠢的，所以我将它翻转为一个optional<variant<R>...> 。

这意味着您可以快速检查函数调用是否有效，如果有效，您可以查看从中获得的价值。

---

测试代码：

    std::map<int, function_t> callbacks = {
        { 0, []{ std::cout << 0 << "\n"; } },
        { 1, [](int x){ std::cout << "1:" << x << "\n"; return x+1; } },
    };
    std::optional<std::variant<void_t, int>> results[] = {
        caller(callbacks, 0),
        caller(callbacks, 0, 1),
        caller(callbacks, 1),
        caller(callbacks, 1, 1),
    };
    for (auto&& op:results) {
        std::cout << (bool)op;
    }
    std::cout << "\n";
    auto printer = [](auto val) {
        if constexpr (std::is_same_v<decltype(val), void_t>) {
            std::cout << "void_t";
        } else {
            std::cout << val;
        }
    };
    int count = 0;
    for (auto&& op:results) {
        
        std::cout << count << ":";
        if (!op) {
            std::cout << "nullopt\n";
        } else {
            std::visit( printer, *op );
            std::cout << "\n";
        }
        ++count;
    }

我得到这个输出：

 0 1:1 1001 0:void_t 1:nullopt 2:nullopt 3:2

前两行是void()和int(int) std::function记录它们的调用。

第三行显示哪些调用成功——0 参数调用void()和 1 参数调用int(int) 。

最后 4 行是存储的结果。 第一个， optional<variant>参与并持有void_t 。 第二次和第三次调用失败所以nullopt ，最后一个包含将1传递给返回1+1的函数的结果。

活生生的例子。

从返回值中，您可以看到调用是否有效（查看外部可选是否被占用），确定调用的是哪个回调（变体索引），并获取被调用变体的值（对其进行访问） ）。

---

如果函数类型的数量很大，则应考虑进行优化。

上面有两个嵌套的std::visits变量索引，都保证返回相同的值。 这意味着正在生成 O(n^2) 代码，其中只需要 O(n) ，其中 n 是function_t的替代数量。

您可以通过将变体索引“向下”作为额外参数传递给call_maybe和var_opt_flip来清理它。 理论上，编译器可以计算出其他 n^2-n 生成的代码元素是不可访问的，但这两者都需要编译器进行大量工作，即使它工作也很脆弱。

这样做会减少构建时间（这种愚蠢的行为会花费构建时间；不要在通常包含的公共头文件中调用它！），并且可以减少运行时可执行文件的大小。

大多数编程语言和 C++ 的大多数用途不允许 O(n) 代码生成多于 O(n) 的二进制文件； 但是模板足够强大，特别是 std 变体，可以生成 O(n^2) 甚至 O(n^3) 二进制代码输出。 所以应该注意一些。