C++能做一些类似ML大小写表达式的事情吗

我喜欢Alan的解决方案，但我不同意他的结论，即它太复杂了。如果您可以访问C++11，它几乎为您提供了所需的所有工具。您只需要编写一个类和两个函数：

namespace always {
struct always_eq_t {
};
template <class lhs_t>
bool operator==(lhs_t const&, always_eq_t)
{
    return true;
}
template <class rhs_t>
bool operator==(always_eq_t, rhs_t const&)
{
    return true;
}
}  // always

然后，您可以用与ML:相对类似的方式编写函数

#include <tuple>
#include <iostream>
void f(bool a, bool b, bool c, bool d)
{
    always::always_eq_t _;
    auto abcd = std::make_tuple(a, b, c, d);
    if (abcd        == std::make_tuple(true,  true, _, _)) {
        std::cout << "true, true, _, _n";
    } else if (abcd == std::make_tuple(false, true, _, false)) {
        std::cout << "false, true, _, falsen";
    } else {
        std::cout << "elsen";
    }
}
int
main()
{
    f(true, true, true, true);
    f(false, true, true, false);
    return 0;
}

在C++中，你经常想考虑是否有一种合理的类型可以帮助我更容易地编写代码？此外，我认为如果您有ML背景，您将从研究C++模板中受益匪浅。它们对于在C++中应用函数式编程风格非常有帮助。

C++传统上是面向个人的，无论语法如何，都无法执行类似以下操作。

if ([a,b,c,d] == [true,true,false, false]) {}

新C++标准有一些东西可以让你内联地定义常量数组，因此可以定义一个类，将数组作为构造函数并支持这种比较。类似的东西

auto x = multi_val({a,b,c,d});
if (x == multi_val({true, true, false, false}))
{ ... }
else if (x == multi_val(etc.))

但现在要进行像_这样的部分匹配，这是不直接支持的，你必须让你的类变得更加复杂才能篡改它，比如使用一个可能的模板类型并进行

multi_val(true, true, maybe<bool>(), maybe<bool>)

这进入了相当令人兴奋的C++领域，绝对不是我对如此初级的东西会做的。

对于C++11，假设您只想匹配固定数量的布尔值，并且可以在没有_模式匹配的情况下生存，那么[1]（扩展到您需要的变量数量）。

我仍在研究一种替代解决方案，该解决方案使用模板来匹配任意类型，使用lambda或函数来匹配表达式。

-编辑-

正如承诺的那样，[2]任意类型的模式匹配，包括未指定的值。

注意几个注意事项：

1. 这段代码只适用于4个变量（实际上是我第一次尝试使用模板元编程）。使用可变模板可以大大改善这一点
2. 它起作用，但不是很整洁或组织良好。更多的是在引入生产代码之前需要清理的概念验证
3. 我对比赛功能不满意。我希望使用初始值设定项列表来传递要计算的表达式，并在第一次匹配时停止（在当前实现中，将执行每个匹配条件）——然而，我无法快速想到如何通过单个初始值设定器列表传递不同类型的表达式匹配对象

我想不出任何一种方法来验证真值表是详尽的。

干杯，

-缺口

[1]

constexpr int match(bool v, int c)
{
    return v ? (1 << c) : 0;
}
constexpr int match(bool a, bool b)
{
    return match(a, 0) | match(b, 1);
}
int main()
{
    int a = true;
    int b = false;
    switch(match(a, b))
    {
        case match(false, false):
            break;
        case match(false, true):
            break;
        case match(true, false):
            break;
        case match(true, true):
            break;
    }
}

[2]

template<typename V1, typename V2, typename V3, typename V4>
class pattern_match_t
{
private:
    V1 value_0;
    V2 value_1;
    V3 value_2;
    V4 value_3;
public:
    typedef std::function<void(V1, V2, V3, V4)> expr_fn;
    template <typename C1, typename C2, typename C3, typename C4>
    pattern_match_t<V1, V2, V3, V4>& match(C1 a, C2 b, C3 c, C4 d, expr_fn fn)
    {
        if(value_0 == a && value_1 == b && value_2 == c && value_3 == d)
            fn(value_0, value_1, value_2, value_3);
        return *this;
    }
    pattern_match_t(V1 a, V2 b, V3 c, V4 d)
     : value_0(a), value_1(b), value_2(c), value_3(d)
    {
    }
};
template<typename T>
class unspecified
{};
template<typename T>
constexpr bool operator==(unspecified<T>, const T&)
{
    return true;
}
template<typename T>
constexpr bool operator==(const T&, unspecified<T>)
{
    return true;
}
template<typename V1, typename V2, typename V3, typename V4>
pattern_match_t<V1, V2, V3, V4> pattern_match(V1 a, V2 b, V3 c, V4 d)
{
    return pattern_match_t<V1, V2, V3, V4>(a, b, c, d);
}
int main()
{
    bool test_a = true;
    std::string test_b = "some value";
    bool test_c = false;
    bool test_d = true;
    pattern_match(test_a, test_b, test_c, test_d)
        .match(true, unspecified<std::string>(), false, true, [](bool, std::string, bool, bool)
        {
            return;
        })
        .match(true, "some value", false, true, [](bool, std::string, bool, bool)
        {
            return;
        });
}