生成操作符过载函数的有效机制

Question

我正在尝试整理一个C++框架(PyCXX)。

一个特定的文件包含大约400行操作符重载函数，我设法将其简化为：

#define OP( op, l, r, cmpL, cmpR ) \
    bool operator op( l, r ) { return cmpL op cmpR; }

#define OPS( l, r, cmpL, cmpR ) \
    OP( !=, l, r, cmpL, cmpR ) \
    OP( ==, l, r, cmpL, cmpR ) \
    OP( > , l, r, cmpL, cmpR ) \
    OP( >=, l, r, cmpL, cmpR ) \
    OP( < , l, r, cmpL, cmpR ) \
    OP( <=, l, r, cmpL, cmpR )

    OPS( const Long &a, const Long &b,   a.as_long() , b.as_long() )
    OPS( const Long &a,       int   b,   a.as_long() , b           )
    OPS( const Long &a,       long  b,   a.as_long() , b           )
    OPS( int         a, const Long &b,   a           , b.as_long() )
    OPS( long        a, const Long &b,   a           , b.as_long() )

#ifdef HAVE_LONG_LONG
    OPS( const Long &a, PY_LONG_LONG b,   a.as_long_long() , b                )
    OPS( PY_LONG_LONG a, const Long &b,   a                , b.as_long_long() )
#endif

    //------------------------------------------------------------
    // compare operators
    OPS( const Float &a, const Float &b,   a.as_double() , b.as_double() )
    OPS( const Float &a, double       b,   a.as_double() , b             )
    OPS( double a,       const Float &b,   a             , b.as_double() )

}    // end of namespace Py

不过，我不知道可否进一步整理一下。

看起来，我可以节省每次传递所有参数的费用，方法是：

#define OPS( ... ) \
    OP( !=, ##__VA_ARGS__ ) \
    OP( ==, ##__VA_ARGS__ ) \
    OP( > , ##__VA_ARGS__ ) \
    OP( >=, ##__VA_ARGS__ ) \
    OP( < , ##__VA_ARGS__ ) \
    OP( <=, ##__VA_ARGS__ )

虽然我有预感，但这可能会降低代码的透明度。

另一个可能的想法是存储对：

#define FD(op, x) (       Float &x , op, x.as_double()    )
#define L1(op, x) ( const Long &x  , op, x.as_long()      )
#define L2(op, x) ( const Long &x  , op, x.as_long_long() )
:

但我正冒着混淆的危险，因为我太努力了。我认为人们普遍认为，在其他条件相同的情况下，可读性胜于简洁。

我还能考虑哪些其他可行的设计模式？

Answer 1

这是我想出的最好的办法：

#define OP( op, l, r, cmpL, cmpR ) \
    bool operator op( l, r ) { return cmpL op cmpR; }

#define OPS( ... ) \
    OP( !=, ##__VA_ARGS__ ) \
    OP( ==, ##__VA_ARGS__ ) \
    OP( > , ##__VA_ARGS__ ) \
    OP( >=, ##__VA_ARGS__ ) \
    OP( < , ##__VA_ARGS__ ) \
    OP( <=, ##__VA_ARGS__ )

#define BI_( a, b, convA, convB ) \
    OPS(a, b, convA, convB ) \
    OPS(b, a, convB, convA )

    OPS( const Long  &a, const Long  &b  ,  a.as_long()      , b.as_long()    )
    BI_( const Long  &a, int          b  ,  a.as_long()      , b              )
    BI_( const Long  &a, long         b  ,  a.as_long()      , b              )

#ifdef HAVE_LONG_LONG
    BI_( const Long  &a, PY_LONG_LONG b  ,  a.as_long_long() , b              )
#endif

    OPS( const Float &a, const Float &b  ,  a.as_double()    , b.as_double()  )
    BI_( const Float &a, double       b  ,  a.as_double()    , b              )

#undef OP, OPS, BI_

我在这里详细介绍了这个思想过程：http://mathpad.wikidot.com/pycxx-operators