boost:operators 布满荆棘的人生 2022-08-29 10:57 164阅读 0赞 C++提供了强大且自由的操作符重载能力,可以重新定义大多数操作符的行为,使操作更加简单直观。这方面很好的例子就是标准库中的string和complex,可以像操作内置类型int、double那样对它们进行算术运算和比较运算,非常方便。 但实现重载操作却要比使用它要麻烦很多,因为很多算法具有对称性,如果定义了operator+,那么很自然需要operator-,如果有小于比较,那么也应该有小于等于、大于、大于等于比较。完全实现这些操作符的重载工作是单调乏味的,而且增加的代码量也增加了出错的可能性,还必须保证这些操作符都实现了正确的语义。 实际上很多操作符可以从其他的操作符自动推导出来,比如a!=b可以是!(a==b)。因此原则上只需要定义少量的基本操作符,其他的操作符就可以用逻辑组合实现。 在C++标准的std::rel\_ops名字空间里提供了四个模板比较操作符`!=、>、<=、>=`,只需要为类定义了`==`和`<`操作符,那么这四个操作符就可以自动实现。比如: #include <iostream> #include <utility> #include <assert.hpp> class deme_class{ public: deme_class(int n) : x(n){ } int x; friend bool operator<(const deme_class& l, const deme_class & r){ return l.x < r.x; } }; int main() { deme_class a(10), b(20); using namespace std::rel_ops; // 打开 std::rel_ops 名字空间 assert(a < b); // 自定义的<操作符 assert(b >= a); // >=操作符被自动实现 return 0; } 但std::rel\_ops的解决方案过于简单,还很不够。除了比较操作符,还有很多其他的操作符重载标准库没有给出解决方案。而且使用这些操作符需要用using语句打开`std::rel_ops`名字空间,很不方便,也会带来潜在的冲突风险。 由此,就产生了boost.operators库。它采用类似std::rel\_ops的实现手法,允许用户在自己的类里仅定义少量的操作符,就可以自动生成其他操作符重载,而且保证正确的语义实现。 operators位于名字空间boost,需要包含头文件`<boost/operators.hpp>`,即: #include <boost/operators.hpp> using namespace boost; ## 基本运算概念 ## 由于C++可重载的操作符非常多,因此operator库是由多个类组成的,分别用来实现不同的运算概念,比如`less_than_comparable`定义了`<`操作符,`left_shiftable`定义了`<<`系列操作符。 operators中的概念很多,囊括了C++中的大部分操作符重载。下面是比较常用的: * `equality_comparable`:要求提供`==`,可自动实现`!=`,相等语义。 * `less_than_comparable`:要求提供`<`,可自动实现`>`、`<=`、`>=` * `addable`:要求提供`+=`,可自动实现`+` * `subtractable`:要求提供`-=`,可自动实现`-` * `incrementable`:要求提供前置`++`,可自动实现后置`++` * `decrementable`:要求提供前置`--`,可自动实现后置`--` * `equivalent`: 要求提供`<`,可自动实现`==`,等价语义 这些概念在库中以同名类的形式提供,用于需要以继承的方式来使用它们。继承的修饰符并不重要(`private、public`)都可以,因为`operators`库里面都是空类,没有成员函数和成员变量,仅定义了数个友元操作符函数。比如: ![在这里插入图片描述][46160cfa7b394626ae576caa80ad021a.png] 如果要同时实现多个运算概念则可以使用多重继承技术,把自定义类作为多个概念的子类,但多重继承在使用时存在很多问题,需要用到一些特别的技巧 ## 算术操作符 ## 我们用一个三维空间的点point作为operator库的示范类: class point{ int x, y, z; public: explicit point(int a = 0, int b = 0, int c = 0) : x(a), y(b), z(c){ } void print() const { printf("x = %d, y = %d, z = %d\n", x, y, z); } }; 我们先来实现less\_than\_comparable,它要求point类提供“<”操作符,并由它继承。因此,我们只需要为point增加父类,并定义less\_than\_comparable概念所要求的operator<: #include <iostream> #include <assert.hpp> #include <boost/operators.hpp> using namespace boost; class point: boost::less_than_comparable<point>{ int x, y, z; public: explicit point(int a = 0, int b = 0, int c = 0) : x(a), y(b), z(c){ } void print() const { printf("x = %d, y = %d, z = %d\n", x, y, z); } friend bool operator<(const point& l, const point& r) { return (l.x*l.x + l.y*l.y +l.z*l.z < r.x*r.x + r.y*r.y +r.z*r.z); } }; int main() { point p0, p1(1,2,3), p2(3,0,5), p3(3,2,1); assert(p0 < p1 && p1 < p2); assert(p2 > p0); assert(p1 <= p3); assert(!(p1<p3)&&!(p1>p3) ); return 0; } boost::less\_than\_comparable作为基类的用法可能优点奇怪,它把子类point作为了父类的目标参数:`less_than_comparable<point>`,看起来好像是个“循环继承”。实际上,point类作为less\_than\_comparable的模板类型参数,只是用来实现内部的比较操作符,用做操作符函数的类型,没有任何继承关系。less\_than\_comparable生成的代码可以理解成这样: struct less_than_comparable{ friend bool operator>=(const point& l, const point& r){ return !(x < y) } }; 从上面可以推导出,point类定义了一个友元operator<操作符,然后其余的>,<=,>=就由less\_than\_comparabel自动生成。 同样定义相等关系,可以使用equality\_comparable,需要自行实现operator==: #include <iostream> #include <assert.hpp> #include <boost/operators.hpp> using namespace boost; class point: boost::less_than_comparable<point, boost::equality_comparable<point> >{ // 使用多种继承 int x, y, z; public: explicit point(int a = 0, int b = 0, int c = 0) : x(a), y(b), z(c){ } void print() const { printf("x = %d, y = %d, z = %d\n", x, y, z); } friend bool operator<(const point& l, const point& r) { return (l.x*l.x + l.y*l.y +l.z*l.z < r.x*r.x + r.y*r.y +r.z*r.z); } friend bool operator==(const point& l, const point& r) { return r.x == l.x && r.y == l.y && r.z == l.z; } }; int main() { point p0, p1(1,2,3), p2(3,0,5), p3(3,2,1); assert(p0 < p1 && p1 < p2); assert(p2 > p0); assert(p1 <= p3); assert(!(p1<p3)&&!(p1>p3) ); { point p0, p1(1,2,3), p2(p1), p3(3,2,1); assert(p1 == p2); assert(p1 != p3); } return 0; } ## 基类链 ## 多重继承一直是C++中引发争论的话题,如果使用不当的话,会导致难以优化和砖石型继承。 operators库使用泛型编程的“基类链”技术解决了多重继承的问题,这种技术通过模板把多继承转换为链式的单继承。 前面当讨论到`less_than_comparable<point>`这种用法时,我们说它不是继承,然而现在,我们将看到它可以实现继承的功能。这从一个方面展示了泛型编程的强大威力。 operators库的操作符模板类除了接受子类作为比较类型外,还可以接受另外一个类,作为它的父类,由此可以无限串联在一起(但受到编译器的模板编译能力限制),像这样: demoe : x<demo, y<demo, z<demo, ...>>> 使用基类链技术,point类的基类部分可以是这样: boost::less_than_comparable<point, //注意这里 boost::equality_comparable<point> > //是一个有很大模板参数列表的类 对比一下多种继承的写法: boost::less_than_comparable<point>, //注意这里 boost::equality_comparable<point> //有两个类 代码非常相似,区别仅仅在于模板参数列表结束符号`>`的位置。正是这个小小的差距,使基类链通过模板组成了一连串的单继承链表,而不是多个父类的多重继承。 比如,如果为point类在增加加法和减法定义,则继承列表就是: ![在这里插入图片描述][9f430cd052a24906807f7a7f6a7929c2.png] 基类链技术会导致代码出现一个有趣的形式:在派生类的基类声明末尾处出现一长串的`>`。编写代码时需要小心谨慎以保证尖括号的匹配,使用良好的代码缩进和换行可以减少错误的发生。 ## 复合运算的概念 ## 基类链技术解决了多重继承的效率问题,但它也带来了新的问题,为了使用操作符概念需要写出很长的基类链代码。因此operators库使用基类链把一些简单的运算概念组合成了复杂的概念,即复合运算。复合运算不仅进一步简化了代码的编写,给出了更明确的语义,它也可以避免用户代码中基类链过长的问题。 operators库提供的常用复合运算概念如下: * `totally_ordered`:全序概念,组合了equality\_comparable和less\_than\_comparable * `additive`:可加减概念,组合了addable和substractable * `multiplicative`:可乘除概念,组合了multipliable和dividable * `arithmetic`:算术运算概念,组合了additive和multiplicative * `unit_stoppable`:可步进概念,组合了incrementable和decrementable 使用复合运算概念,point类只需要很少的代码就可以很容器的获得完全的算术运算能力: #include <iostream> #include <assert.hpp> #include <boost/assign.hpp> #include <boost/operators.hpp> using namespace boost; class point : //boost::less_than_comparable<point, //boost::equality_comparable<point> > totally_ordered<point, additive<point> > { int x, y, z; public: explicit point(int a=0, int b=0, int c=0):x(a),y(b),z(c){ } void print()const { std::cout << x <<","<< y <<","<< z << std::endl; } friend bool operator<(const point& l, const point& r) { return (l.x*l.x + l.y*l.y +l.z*l.z < r.x*r.x + r.y*r.y +r.z*r.z); } friend bool operator==(const point& l, const point& r) { return r.x == l.x && r.y == l.y && r.z == l.z; } point& operator+=(const point& r) //支持addable概念 { x += r.x; y += r.y; z += r.z; return *this; } point& operator-=(const point& r) //支持subtractable概念 { x -= r.x; y -= r.y; z -= r.z; return *this; } }; int main() { point p0, p1(1,2,3), p2(3,0,5), p3(3,2,1); using namespace boost::assign; std::vector<point> v = (list_of(p0), p1, p2, p3); auto pos = std::find(v.begin(), v.end(), point(1, 2, 3)); // find使用了== pos->print(); (p1 + p2).print(); (p3 - p1).print(); assert((p2 - p2) == p0); return 0; } ## 相等与等价 ## 相等(equality)与等价(equivalent)是两个极易被混淆的概念。一个简单快速的解释是:相等基于操作符`==`,即`x == y`;而等价基于`<`,即`!(x < y) && !(x > y)`,两者在语义上有很大差别 对于简单类型,比如int,相等和等级是完全一致的。但对于大多数复杂类型和自定义类型,由于`==`和`<`操作符是两个不同的运算,比较原则可能不同,从而两者具有不同的语义。 **operators库使用equality\_comparable(`==`)和equivalent(`<`)明确的区分了相等和等价这两个概念**。令人困扰的是它们最终都提供了操作符==,表现相似但含义非常不同。 了解相等和等价的区别非常重要,特别是当自定义类被当做容器的元素的时候。标准库中的关联容器(set、map)和排序算法使用的是等价关系`<`操作符,而unordered\_set/map和各种find查找算法用的是相等关系操作符(`==`)。 请谨慎考虑自定义类需要什么语义,如果只关系类的等价语义,那么就用`equivalent`,如果想要精确的比较两个对象的值,就使用equality\_comparable ## 解引用操作符 ## `operators`库使用dereferenceable提供了对解引用操作符`*`、`->`的支持,其类摘要如下: ![在这里插入图片描述][5a6633a43bf441709c0dd14d29e22c3b.png] dereferenceable有三个模板参数: * 第一个参数T是要实现operator->的子类,它的含义与算法操作符类相同 * 第二个参数P是operator->所返回的类型,也就是指针类型,通常应该是T\* * 最后一个参数B是用于基类链技术的父类,实际使用时我们并不关心 dereferenceable类要求子类提供operator\*,会自动实现operator->。注意它的operator->函数的定义,不是如其他算术操作符类那样的友元函数,所以必须使用public来继承dereferenceable,否则operator->将会称为类的私有函数,外界无法访问。 由于dereferenceable实现了解引用操作符的语义,因此它可以用于实现自定义的智能指针类,或者是实现代理模式,包装代理某些对象。 比如,下面的代码实现了一个简单的智能指针类my\_smart\_prt,它public继承了dereferenceable,重载operator\*并自动获得了operator->的定义: template<typename T> class my_smart_ptr: public dereferenceable<my_smart_ptr<T>, T* > { T *p; public: my_smart_ptr(T *x):p(x){ } ~my_smart_ptr(){ delete p;} T& operator*() const { return *p; } }; void case5() { my_smart_ptr<string > p(new string("123")); assert(p->size() == 3); } ## 下标操作符 ## operators库使用indexable提供了下标操作符`[]`的支持,它也属于解引用的范畴,用法和dereferenceable很相似,类摘要如下: ![在这里插入图片描述][70dab19a152c4831ae3f4f10588b9af5.png] indexable目标参数列表中T和B含义与dereferenceable的T和B含义相同,分别是子类类型和基类链的父类类型。 参数I是下标操作符的值类型,通常应该是整数,但也可以是其他类型,只要它能够与类型T做加法操作。参数R是operator\[\]的返回值类型,通常应该是一个类型的引用。 indexable要求子类提供一个operator+(T, I)的操作定义,类似于一个指针的算术运算,它应该返回一个迭代器类型,能够使用operator\*解引用得到R类型的值。 template<typename T> class my_smart_array: public indexable<my_smart_array<T>, int, T& > { T *p; public: typedef my_smart_array<T> this_type; typedef T* iter_type; my_smart_array(T *x):p(x){ } ~my_smart_array(){ delete[] p;} friend iter_type operator+(const this_type& a, int n) { return a.p + n; } }; void case6() { my_smart_array<double> ma(new double[10]); ma[0] = 1.0; *(ma + 1) = 2.0; cout << ma[1] << endl; } ## bool转型操作符 ## 转型操作符是C++中的一类特殊操作符,而operator bool则更具有特殊性,如果简单的实现bool转型,那么会因为隐式转换在比较操作时会发生意想不到的问题。 ### 文章目录 ### * * 基本运算概念 * 算术操作符 * 基类链 * 复合运算的概念 * 相等与等价 * 解引用操作符 * 下标操作符 * bool转型操作符 [46160cfa7b394626ae576caa80ad021a.png]: /images/20220829/8330e0e9a6dd47699e0a9bcbef983c53.png [9f430cd052a24906807f7a7f6a7929c2.png]: /images/20220829/2c00d0c1e88d4c87800b4fa3d1146367.png [5a6633a43bf441709c0dd14d29e22c3b.png]: /images/20220829/692644b484324477ac079410539df482.png [70dab19a152c4831ae3f4f10588b9af5.png]: /images/20220829/f944054f347c41b9a30a55b54f8700ba.png
还没有评论,来说两句吧...