Question

考虑一个结构（如：几个成员的愚蠢aggergation），其成员都实现了某种关系R（例如<）：

struct X {
  A a;
  B b;
};

对于大多数运算符，X R X存在规范定义。例如：

bool operator<(X const& x1, X const& x2) {
  if ((x1.a < x2.a) || (x2.a < x1.a)) // I intentionally did not use != here
    return x1.a < x2.a;
  if ((x1.b < x2.b) || (x2.b < x1.b))
    return x1.b < x2.b;
  return false;
}

这对所有操作员来说都很无聊，特别是如果你有一些成员而不仅仅是一个这样的结构。

正如您所看到的，operator<仅X仅依赖于operator<其成员类型（A，B）besids bool || bool的使用std::tuple 1}}。

有没有办法一般地指定这样的运算符（通过模板或内置函数？）。提升不是一种选择（但如果它可以做到这一点会很有趣。）

如果您可以指定成员的评估顺序（速度），那就更大了。

编辑这个问题考虑了C ++ 03，否则你可以使用{{1}}。

Answer 1

是的提升可以使用元组来实现。

因此，您可以通过模板自己完成。但这样做的额外工作似乎是浪费时间。只需使用函数的简单方法（虽然我不喜欢你的逻辑）。

#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>


struct X
{
    int     a;
    float   b;
};

标准方式：

#if (V == 1)

// The normal way of doing it.
bool operator<(X const& lhs, X const& rhs)
{
    if (lhs.a < rhs.a)                          {return true;}
    if ((lhs.a == rhs.a) && (lhs.b < rhs.b))    {return true;}

    // Of course for small structures (as above) it is easy to compress the above
    // lines into a single statement quickly.
    //
    // For larger structures they tend to break it out
    // until they get it correct then spend ten minutes
    // collapsing it into a single expression.
    return false;
}

压缩后执行此操作的正常方法

#elif (V == 6)

// The normal way of doing it.
bool operator<(X const& lhs, X const& rhs)
{
    return (
                (lhs.a < rhs.a)
             || ((lhs.a == rhs.a) && (lhs.b < rhs.b))
           );
}

我过去喜欢的方式，因为它很清楚。

#elif (V == 2)

// The way I like doing it because I think it is slightly more readable.
// Though I normally use the one above now.
bool operator<(X const& lhs, X const& rhs)
{
    if (lhs.a < rhs.a)      {return true;}
    if (lhs.a > rhs.a)      {return false;}
    // If we get here the A are equal
    if (lhs.b < rhs.b)      {return true;}
    if (lhs.b > rhs.b)      {return false;}
    return false;
}

冗长的元组版本

#elif (V == 3)

// A version that will use tupples to do it.
bool operator<(X const& lhs, X const& rhs)
{
    typedef boost::tuple<int, float>   Comp;
    Comp    l(lhs.a, lhs.b);
    Comp    r(rhs.a, rhs.b);
    return l < r;
}

简短的小元组版

#elif (V == 4)

// A version that will use tupples but slightly more compact.
bool operator<(X const& lhs, X const& rhs)
{
    return boost::make_tuple(lhs.a, lhs.b) < boost::make_tuple(rhs.a, rhs.b);
}
#endif

Answer 2

显然没有非增强解决方案，我酝酿了一些模板魔法，我发布这个答案以防有人遇到同样的问题;

版本1：显式参数

namespace multioperator {

  enum LazyBool {
    LB_false = false,
    LB_true = true,
    LB_undefined
  };

  template <typename Cmp, typename B> class Operator {
    public:
      typedef typename Cmp::first_argument_type A;
    private:
      A const& a1;
      A const& a2;
      B const& b;
    public:
      Operator(A const& a1, A const& a2, B const& b)
        : a1(a1), a2(a2), b(b) {
      }
      operator bool() const {
        switch (static_cast<LazyBool>(Cmp(a1,a2))) {
          case LB_false:
            return false;
          case LB_true:
            return true;
          case LB_undefined:
          default: // g++ does not understand that we have all branches :(
            return static_cast<bool>(b);
        }
      }
  };

  template <typename Fn> class BinaryFunctorMonad {
    public:
      typedef typename Fn::first_argument_type first_argument_type;
      typedef typename Fn::second_argument_type second_argument_type;
      typedef typename Fn::result_type result_type;
    private:
      first_argument_type const& a;
      second_argument_type const& b;
    public:
      BinaryFunctorMonad(first_argument_type const& a, second_argument_type const& b)
        : a(a), b(b) {
      }
      operator result_type() {
        return Fn()(a,b);
      }
  };

  enum CmpSymmetry {
    CS_Symmetric = false,
    CS_Asymmetric = true
  };

  template <typename Cmp, CmpSymmetry asymmetric> class LazyCmp {
    public:
      typedef typename Cmp::first_argument_type first_argument_type;
      typedef typename Cmp::first_argument_type second_argument_type;
      typedef LazyBool result_type;
      LazyBool operator()(first_argument_type const& a1, second_argument_type const& a2) const {
        if (Cmp(a1,a2))
          return LB_true;
        if (asymmetric && Cmp(a2,a1))
          return LB_false;
        return LB_undefined;
      }
  };

  template <typename A, typename B> struct MultiLess {
    typedef
      Operator<
        BinaryFunctorMonad<
          LazyCmp<
            BinaryFunctorMonad<std::less<A> >,
            CS_Asymmetric>
        >, B>
      Type;
  };

  template <typename A, typename B> struct MultiEqual {
    typedef
      Operator<
        BinaryFunctorMonad<
          LazyCmp<
            BinaryFunctorMonad<std::equal_to<A> >,
            CS_Symmetric>
        >, B>
      Type;
  };

}

template <typename A, typename B> typename multioperator::MultiLess<A,B>::Type multiLess(A const& a1, A const& a2, B const& b) {
  return typename multioperator::MultiLess<A,B>::Type(a1,a2,b);
}

template <typename A, typename B> typename multioperator::MultiEqual<A,B>::Type multiEqual(A const& a1, A const& a2, B const& b) {
  return typename multioperator::MultiEqual<A,B>::Type(a1,a2,b);
}
// example: multiLess(a1,a2,multiLess(b1,b2,multiLess(c1,c2,false)))

免责声明：我知道BinaryFunctorMonad有点用词不当，我无法想出更好的东西。

版本2：继承

template <typename A, typename Chain> class MultiComparable {
  private:
    A const& a;
    Chain chain;
  public:
    typedef MultiComparable MultiComparableT;
    MultiComparable(A const& a, Chain chain) : a(a), chain(chain) {}
    bool operator<(MultiComparable const& as) {
      if (a != as.a)
        return a < as.a;
      return chain < as.chain;
    }
    bool operator==(MultiComparable const& as) {
      if (a != as.a)
        return false;
      return chain == as.chain;
    }
};

template <typename A, typename Chain> MultiComparable<A,Chain> multiComparable(A const& a, Chain chain) {
  return MultiComparable<A,Chain>(a,chain);
}

//example:
struct X : MultiComparable<int,MultiComparable<float,bool> > {
  int i;
  float f;
  X() : MultiComparableT(i,multiComparable(f,false)) {}
}

规范关系运算符（==，＆lt;，...）

2 个答案: