C++ 深度懒惰与优雅语法的比较？

Question

我有一个 C++ 类，我需要为其定义一个比较器，该比较器应考虑几种可能代价高昂的方法的结果。我不想为我的集合中的所有对象缓存这些方法的结果，因为具有最高优先级的条件更便宜，而且我希望底部非常昂贵的条件仅在极少数情况下触发。

如果我有一个 cmp() 函数，当第一个参数小于、等于或大于第二个参数时分别返回 -1、0 或 1，并且使用保留整数的快捷逻辑运算符，我可以轻松编写

int compare(const Class &rhs) const {
    return cmp(expensive_method_a(), rhs.expensive_method_b()) ||
           cmp(expensive_method_b(), rhs.expensive_method_b()) ||
           ...
}

不幸的是，我需要使用 < 运算符，所以它变得丑陋、昂贵且容易出错:

bool operator<(const Class &rhs) const {
    return expensive_method_a() < rhs.expensive_method_a() ||
           (expensive_method_a() == rhs.expensive_method_a() &&
            (expensive_method_b() < rhs.expensive_method_b() ||
             (expensive_method_b() == rhs.expensive_method_b() &&
              (...
           ))))
}

或者，成本较低但仍然很丑陋:

bool operator<(const Class &rhs) const {
    auto al = expensive_method_a(), ar = rhs.expensive_method_a();
    if (al != ar) return al < ar;
    auto bl = expensive_method_b(), br = rhs.expensive_method_b();
    if (bl != br) return bl < br;

我在 This 上读到过关于 std::tie 的信息另一个问题，但如果我理解正确，平局会在开始比较之前评估我所有的方法，我希望这些参数被延迟评估。

我考虑过定义这样的预处理器宏:

#define CUT_COMPARE(a,b) { auto _x = (a); auto _y = (b); if (_x != _y) return (_x < _y); }

我会这样使用:

bool operator<(const Class &rhs) const {
    CUT_COMPARE(expensive_method_a(), rhs.expensive_method_a());
    CUT_COMPARE(expensive_method_b(), rhs.expensive_method_b());
    ...
}

希望大括号将我的 _x 和 _y 包含在私有(private)范围内，但是，clang++ 提示 的多个定义>_x 和 _y。

有没有更好的方法解决这个问题？

Answer 1

您可以将所有要调用的成员函数转发给一个辅助模板，该模板会根据需要遍历它们:

bool operator<(const Class& rhs) const {
    return lazy_compare(*this, rhs, &Class::expensive_1,
                                    &Class::expensive_2,
                                    &Class::expensive_3);
}   

lazy_compare 可变参数函数将根据需要一次一个地遍历那些指向成员的指针函数。基本情况只是 true:

template <typename T, typename... MFs>
bool lazy_compare(const T&, const T&, MFs...) {
    return true;
}

递归的情况是弹出第一个指向成员的指针，看看我们是否可以在那个指针处停止:

template <typename T, typename R, typename... MFs>
bool lazy_compare(const T& left, const T& right, R (T::*mf)() const, MFs... rest) {
    R vleft = (left.*mf)(), vright = (right.*mf)();
    if (vleft != vright) {
        return vleft < vright;
    }   
    else {
        return lazy_compare(left, right, rest...);
    }   
}