Question

假设我想使用以下语法创建自己的基于 lambda 的开关：

auto s = make_switch(std::pair{0, []{ return 0;   }},
                     std::pair{1, []{ return 50;  }},
                     std::pair{2, []{ return 100; }});

assert( s(0) == 0   );
assert( s(1) == 50  );
assert( s(2) == 100 );

我想使用 fold表达式，以便拥有一个不需要递归的简洁实现。这个想法是生成类似于一堆嵌套if语句的东西：

if(x == 0) return 0;
if(x == 1) return 50;
if(x == 2) return 100;

我想写这个：

// pseudocode
template <typename... Pairs>
auto make_switch(Pairs... ps)
{
    return [=](int x)
    {
        ( if(ps.first == x) return ps.second(), ... );
    };
}

上面的代码不起作用，因为if(...){...}不是表达式。然后我尝试使用&&运算符：

template <typename... Pairs>
auto make_switch(Pairs... ps)
{
    return [=](int x)
    {
        return ((ps.first == x && ps.second()), ...);
    };
}

这会编译，但会返回ps.first == x && ps.second()的结果，这是bool而不是我想要的int值。

我希望某种运算符是逗号运算符和&&之间的组合：它应该评估并评估右侧运算符如果左侧评估为true。

我想不出任何允许我以这样的方式实现它的技术我可以获得ps.second()的返回值并将其传播给make_switch返回的lambda的调用者。 / p>

是否可以使用折叠表达式实现这种“级联if s”模式？我只想评估尽可能多的表达式在找到匹配的分支之前需要。

Answer 1

我很惊讶它还没有建议：

template <typename ...Pairs> auto make_switch(Pairs ...ps)
{
    return [=](int x)
    {
        int ret;
        ((x == ps.first && (void(ret = ps.second()), 1)) || ...)
            /* || (throw whatever, 1) */ ;
        return ret;
    };
}

(try it online)

它需要一个额外的变量，但似乎唯一的选择是递归和带有重载二元运算符的包装类，并且对我来说看起来都不那么优雅。

||的短路用于在找到匹配项时停止该功能。

_{（对于上面的代码，GCC 7.2给了我warning: suggest parentheses around '&&' within '||'。可能是个bug？）}

编辑：

这是一个针对任何类型推广的版本：_{（@Barry建议std::optional的信用）}

template <typename InputType, typename ReturnType, typename ...Pairs> auto make_switch(Pairs ...ps)
{
    /* You could do
     *   using InputType  = std::common_type_t<typename Pairs::first_type...>;
     *   using ReturnType = std::common_type_t<decltype(ps.second())...>;
     * instead of using template parameters.
     */

    return [=](InputType x)
    {
        std::optional<ReturnType> ret /* (default_value) */;
        ( ( x == ps.first && (void(ret.emplace(std::move(ps.second()))), 1) ) || ...)
            /* || (throw whatever, 1) */;
        return *ret;
    };
}

(try it online)

我决定使用参数和返回类型的模板参数，但如果需要，可以推断它们。

请注意，如果您决定没有默认值，也不会throw，那么将无效值传递给交换机将为您提供UB。

Answer 2

这是不可能的。要使用折叠表达式，您需要在Pairs上定义二元运算符。

在你的情况下，这样的二元运算符不能存在，因为：

它需要是有状态的（即捕获x，因为它将Pairs::first与x进行比较）
和运算符必须是（i）非静态成员函数或（ii）非成员函数。

此外：

（i）非静态成员运算符隐式地将this作为第一个参数，并且您不能使this指向Pairs或{{1}的派生}};
（ii）非成员函数无法捕获Pairs。

Answer 3

我认为来自HolyBlackCat的解决方案更好但是......使用总和呢？

template <typename ... Pairs>
auto make_switch (Pairs ... ps)
 {
   return [=](int x)
    { return ( (ps.first == x ? ps.second() : 0) + ... ); };
 }

不幸的是，仅适用于定义总和的类型。

从“级联ifs”折叠表达式

3 个答案:

编辑：