从“级联ifs”折叠表达式中检索值

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 的调用者。

是否可以使用

fold表达式

实现这种“级联if”模式？我想仅评估所需数量的表达式，直到找到匹配的分支。

Answer 1

我很惊讶还没有建议：

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

（在线尝试）

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

||

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

_{（对于上面的代码，GCC 7.2 给了我}

warning: suggest parentheses around '&&' within '||'

。可能是一个错误？）

编辑：

这是适用于任何类型的通用版本：_{（感谢 @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, true) */;
        return *ret;
    };
}

（在线尝试）

我决定对参数和返回类型使用模板参数，但如果你愿意，你可以推断它们。

请注意，如果您决定不使用默认值，也不使用

throw

，那么向开关传递无效值将为您提供 UB。

Answer 2

这是不可能的。为了使用折叠表达式，您需要在

Pairs

上定义一个二元运算符。

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

• 它需要是有状态的（即捕获 x，因为它将

  Pairs::first

  与

  x

  进行比较）
• 和 运算符必须是 (i) 非静态成员函数或 (ii) 非成员函数。

此外：

• (i) 非静态成员运算符隐式将

  this

  作为第一个参数，并且您不能将

  this

  设为指向

  Pairs

  或

  Pairs

  派生的指针；
• (ii) 非成员函数无法捕获

  x

  的值。

Answer 3

我认为 HolyBlackCat 的解决方案更好，但是......使用总和怎么样？

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

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