3

所以，我在 C++ 中遇到过几次这样的事情，我真的很想写类似的东西

case (a,b,c,d) of
     (true, true, _, _ )     => expr
   | (false, true, _, false) => expr
   | ...

但在 C++ 中，我总是会得到这样的结果：

bool c11 = color1.count(e.first)>0;
bool c21 = color2.count(e.first)>0;
bool c12 = color1.count(e.second)>0;
bool c22 = color2.count(e.second)>0;
// no vertex in this edge is colored
// requeue
if( !(c11||c21||c12||c22) )
{
    edges.push(e);
}
// endpoints already same color
// failure condition
else if( (c11&&c12)||(c21&&c22) )
{
    results.push_back("NOT BICOLORABLE.");
    return true;
}
// nothing to do: nodes are already
// colored and different from one another
else if( (c11&&c22)||(c21&&c12) )
{
}
// first is c1, second is not set
else if( c11 && !(c12||c22) )
{
    color2.insert( e.second );
}
// first is c2, second is not set
else if( c21 && !(c12||c22) )
{
    color1.insert( e.second );
}
// first is not set, second is c1
else if( !(c11||c21) && c12 )
{
    color2.insert( e.first );
}
// first is not set, second is c2
else if( !(c11||c21) && c22 )
{
    color1.insert( e.first );
}
else
{
    std::cout << "Something went wrong.\n";
}

我想知道是否有任何方法可以清除所有这些 if 和 else 的情况，因为它似乎特别容易出错。如果在 case 表达式（或 C++ 中的语句）不是详尽无遗的情况下能够像 SML 那样让编译器抱怨，那就更好了。我意识到这个问题有点模糊。也许，总而言之，如何在 C++ 中简洁地表示具有任意数量变量的详尽真值表？提前致谢。

4

3 回答 3

7

我喜欢艾伦的解决方案，但我恭敬地不同意他的结论，即它太复杂了。如果您可以访问 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, _, false\n";
    } else {
        std::cout << "else\n";
    }
}

int
main()
{
    f(true, true, true, true);
    f(false, true, true, false);

    return 0;
}

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

于 2012-09-02T23:46:01.660 回答
5

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++ 领域，绝对不是我会为如此基本的东西做的事情。

于 2012-08-30T20:53:06.957 回答
2

对于 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;
        });
}
于 2012-08-31T23:36:16.153 回答