C运算符重载各类详细介绍.ppt

《C运算符重载各类详细介绍.ppt》由会员分享，可在线阅读，更多相关《C运算符重载各类详细介绍.ppt（60页珍藏版）》请在三一办公上搜索。

1、第7章 运算符重载,本章主要内容7.1 引入运算符重载的原因及运算符重载的规则7.2 运算符重载函数的两种形式7.3 几种常用运算符的重载7.4 类型转换本章重点几种常用运算符的重载与类型转换本章难点单目运算符“+”与“”的重载本章所需学时:4学时,7.1 运算符重载概述,引入运算符重载的原因例如：int a=1,b=2;float c=1.1,d=2.4;int e=a+b;float f=c+d;float g=f+e;为什么同一个运算符“”可以用于完成不同类型的数据的加运算呢？原来C+语言针对预定义数据类型已经对某些运算符做了适当的重载。C+语言提供的预定义数据类型终究是有限的，我们在解

2、决多种多样的实际问题 时，往往需要使用许多的自定义数据类型。例如，在解决科学与工程计算问题时，往往要使用复数、矩阵等。,下面定义一个简化的复数类complexclass complexpublic:double real,imag;complex(double r=0,double i=0)real=r,imag=i;main()complex com1(1.1,2.2),com2(3.3,4.4),total;total=com1+com2;/错误/return 0;,错误原因在于complex类类型不是预定义的基本数据类型，而是用户自定义的数据类型。C+知道如何相加两个int数据，或相加两

3、个float型数据，甚至知道如何把一个int型数据与一个float型数据相加，但是C+并不知道怎样将两个complex类类型的对象进行相加，这样需要我们来重载“+”运算符来解决两对象相加的问题,运算符重载的定义格式：operator（）；在编译时遇到operator的运算符函数，就检查传递给函数的参数的类型。如果编译器在一个运算符的两边有自定义的数据类型。就执行用户自己的函数，而不是内部运算符的常规程序。那么上例中的错误，就是需要重载重载+运算符，其运算符函数operator+()如下：,complex operator+(complex com1,complex com2)complex t

4、emp;temp.real=com1.real+com2.real;temp.real=com1.imag+com2.imag;return temp;其中主函数的 total=com1+com2；（隐式调用）语句也可以写成：total=operator+(com1,com2);（显式调用）从中可以看出运算符重载进一步提高了面向对象软件系统的灵活性、可扩充性和可读性,运算符重载的规则重载运算符与预定义运算符的使用方法完全相同，被重载的运算符不改变原来的操作数个数、优先级和结合性。重载的运算符只能是运算符集中的运算符，不能另创新的运算符。运算符的含义可以改变，但最好不改变。如实数的加法运算可以用

5、乘法运算符来实现在C+中，大多数系统预定义运算符可以把被重载，但也有些运算符不能被重载如：类属关系运算符“”、成员指针运算符“”、作用域分辨符“：”、sizeof运算符和 三目运算符“？：”不能改变运算符对预定义类型的操作方式,7.2 运算符重载两种形式,运算符重载与函数重载相似，其目的是设置某一运算符，让它具有另一种功能，尽管此运算符在原先C+语言中代表另一种含义，但他们彼此之间并不冲突。C+会根据运算符中的操作数来辨别应使用哪一种功能进行运算。在类外定义运算符重载函数，只能对类公有数据成员进行操作。实际上，运算符的重载有两种形式：定义为类的类友元函数；定义为它将要操作的类的成员函数。前者称

6、为友元运算符函数，后者为成员运算符函数。,友元运算符函数概念友元运算符函数定义的语法形式声明friend type operator(形数表);定义 type operator(形数表）/函数体其中，type（)指定了重载运算符的返回值类型，operator是定义运算符重载函数的关键词，()给定了要重载的运算符名称，是C+中可重载的运算符，形参表中给出重载运算符所需要的参数和类型由于友元运算符函数不是类的成员函数，所以没有this指针。如果重载的运算符函数是双目的运算符，则参数表中有两个操作数，若为单目运算符，则参数表中有一个操作数,双目运算符重载当用友元函数重载双目运算符时，两个操作数都要传

7、递给运算符函数。一般而言，采用友元函数重载双目运算符后，也可以采用两种方法使用：aabb/隐式调用aa.operator(bb)/显式调用双目友元运算函数operator所需的两个操作数都在参数表中由对象aa和bb显式提供用友元运算符函数进行复数运算，见例7-2,#includeclass complexpublic:complex(double r=0.0,double i=0.0);void print();friend complex operator+(complex a,complex b);friend complex operator-(complex a,complex b);

8、friend complex operator*(complex a,complex b);friend complex operator/(complex a,complex b);private:double real;double imag;,complex:complex(double r,double i);real=r;imag=i;complex operator+(complex a,complex b);complex temp;temp.real=a.real+b.real;temp.imag=a.imag+b.imag;return temp;complex operat

9、or-(complex a,complex b);complex temp;temp.real=a.real-b.real;temp.imag=a.imag-b.imag;return temp;complex operator*(complex a,complex b);complex temp;temp.real=a.real*b.real-imag*b.imag;temp.imag=a.real*b.imag+imag*b.real;return temp;complex operator/(complex a,complex b);complex temp;double t;t=1/(

10、b.real*b.real+b.imag*b.imag);temp.real=(a.real+b.real+a.imag*b.imag)*t;temp.imag=(b.real+a.real-a.imag*b.imag)*t;return temp;void complex:print()cout0)cout+;if(imag!=0)coutimagin;,int main()complex A1(2,3,4.6).A2(3.6,2.8),A3,A4,A5,A6;A3=A1+A2;A4=A1-A2;A5=A1*A2;A6=A1/A2;A1.print();A2.print();A3.print

11、();A4.print();A5.print();A6.print();return 0;,说明complex operator+(complex com1,complex com2)complex temp;temp.real=com1.real+com2.real;temp.real=com1.imag+com2.imag;return temp;在这个函数中，先用类的构造函数来生成一个临时对象temp，执行return 语句时会调用拷贝构造函数，把temp的值拷贝到主调函数中的一个无名对象中。当函数operator+()结束时，会调用析构函数析构对象temp。这个过程程序开销较大，于是可

12、以将上述程序改为：直接用类的构造函数来生成一个临时对象，而不对该对象进行命名。则上述程序段可以改为：,complex operator+(complex com1,complex com2)return complex(com1.real+com2.real,com1.imag+com2.imag;这种方法是直接将一个无名临时对象创建到主调函数中，那么运行效率高于前一种。,单目运算符重载用友元函数重载单目运算符时，需要一个显式的操作数，例7-3中，用友元函数重载单目运算符“-”#includeclass nclassint a,b;public:nclass(int x=0,int y=0)a

13、=x;b=y;friend nclass operator-(nclass obj);void show();,nclass operator-(nclass obj)obj.a=-obj.a;obj.b=-obj.b;return obj;void nclass:show()couta=a bb;main()nclass ob1(10,20),ob2;ob1.show();ob2=-ob1;ob2.show();return 0;,使用友元函数重载“+”，“-”单目运算符时，可能会出现一些错误。如7-4#includeclass coord public:coord(int i=0,int

14、j=0);void print();friend coord operator+(coord op);private:int x,y;,coord:coord(int i,int j)x=i;y=j;void coord:print()cout x:x y yendl;coord operator+(coord op)+op.x;+op.y;return op;main()coord ob(10,20);ob.print();operator+(ob);ob.print();+ob;ob.print();return 0;,由于友元函数不是类的成员，所以没有this指针。如果该函数采用传值的方

15、法传递参数，函数中对对象的任何修改均不影响调用该函数的对象本身。即在operator+()函数中，任何内容的改变不会影响产生调用的操作数，也就是对象的数据成员x和y并未增加。为了解决这个问题可采用引用参数传递操作数。那么例7.4怎么进行修改呢？有关友元函数重载单目运算符后缀方式的表示方法，将在后面介绍,说明运算符重载函数 operator()可以返回任何类型，甚至可以是 void类型，但通常返回类型与它所操作的类的类型相同，这样可使重载运算符用在复杂的表达式中。例如，在例7-2中，可以将几个复数连续进行加、减、乘、除的运算。在重载运算符时，运算符函数所作的操作不一定要保持C+中该运算符原有的含

16、义。例如，可以把加运算符重载成减操作，但这样容易造成混乱。所以保持原含义，容易被接受，也符合人们的习惯。在C+中，用户不能定义新的运算符，只能从C+己有的运算符中选择一个恰当的运算符重载。,C+编译器根据参数的个数和类型来决定调用哪个重载函数。因此，可以为同一个运算符定义几个运算符重载函数来进行不同的操作。不能用友元函数重载的运算符是：=，(),-由于单目运算符“”可不改变操作数自身的值，所以在例7.3重载单目运算符“”的友元运算符函数的原型可写成：friend AB operator（AB obj）；通过传值的方式传送参数。,成员运算符函数定义成员运算符函数定义的形式与类外的运算符函数定义基

17、本相同，只是前者定义在类中。如 class X/type operator(参数表）/.;如果成员运算符函数声明在类中，而定义在类外，其格式为：type X:operator(参数表）/函数体,其中，type（)指定了重载运算符的返回值类型，operator是定义运算符重载函数的关键词，()给定了要重载的运算符名称，是C+中可重载的运算符，形参表中给出重载运算符所需要的参数和类型根据运算符函数中重载操作数的不同，可将运算符分为单目运算符与双目运算符。若为双目运算符，则成员运算符函数的参数表中，则只有一个参数，若为单目运算符，则参数表中为空。双目运算符而言，成员运算符函数的参数中表仅有一个参数，

18、它作为运算符的右操作数，此时当前对象作为运算符的左操作数。它是通过this指针隐含地传递给函数的。例如：class X/;type operator+(X a);例7.6(双目运算符函数的重载来完成7.2中的工作）,#include class complexdouble real;double imag;public:complex(double r=0,double i=0)real=r;imag=i;void print();complex operator+(complex c)complex temp;temp.real=real+c.real;temp.imag=imag+c.im

19、ag;return temp;complex operator-(complex c)complex temp;temp.real=real-c.real;temp.imag=imag-c.imag;return temp;complex operator*(complex c)complex temp;temp.real=(real*c.real-imag*c.imag);temp.imag=(real*c.imag+c.real*imag);return temp;complex operator/(complex c);,complex complex:operator/(complex

20、 c)complex temp;double t;t=1/(c.real*c.real+c.imag*c.imag);temp.real=(real*c.real+imag*c.imag)*t;temp.imag=(imag*c.real-real*c.imag)*t;return temp;void complex:print()cout0)cout+;if(imag!=0)coutimagiendl;int main()complex A1(2.3,4.6),A2(3.6,2.8),A3,A4,A5,A6;A3=A1+A2;A4=A1-A2;A5=A1*A2;A6=A1/A2;A1.pri

21、nt();A2.print();A3.print();A4.print();A5.print();A6.print();return 0;,在主函数中A3=A1+A2;A4=A1-A2;A5=A1*A2;A6=A1/A2;程序执行到这四条语句时，C+将其解释为 A3=A1.operator+(A2);A4=A1.operator-(A2);A5=A1.operator*(A2);A6=A1.operator/(A2);由此可知，成员运算符函数operator 实际上是由双目运算符的 左边对象A1调用的。尽管参数表中只有一个操作数A2，但另一个操作数是由对象A1通过this指针隐含地传递的。一般

22、而言，采用成员函数重载双目运算符后，可以用两种方法来使用：aabb/隐式调用 aa.operator(bb)/显式调用 成员运算符函数operator所需要的一个操作数由当前调用成员运算符函数的对象aa通过this指针隐含地传递。因此，它的参数表中只有一个操作数bb,单目运算符函数重载对单目运算符而言，成员运算符函数的参数表中没有参数，此时当前对象作为运算符的一个操作数，如下例：#include class coordint x,y;public:coord(int i=0,int j=0);void print();coord operator+();coord:coord(int i,in

23、t j)x=i;y=j;void coord:print()cout“x=x,y=yendl;coord coord:operator+()+x;+y;return*this;,main()coord ob(10,20);ob.print();+ob;ob.print();ob.operator+();ob.print();return 0;,从本例可以看出，当成员函数重载单目运算符时，没有参数被显式地传递给成员运算符函数。参数是通过this指针隐含地传递给函数的。一般而言，采用成员函数重载单目运算符后，可以用两种方法来使用：aa/隐式调用 aa.operator()/显式调用 成员运算符函数

24、operator所需要的一个操作数由当前调用成员运算符函数的对象aa通过this指针隐含地传递。因此，它的参数表中没有参数,成员运算符函数与友元运算符函数的比较对双目运算符而言，成员运算符带有一个参数，而友元运算符函数带两个参数；对单目运算符而言，成员函数不带参数，而友元运算符带一个参数双目运算符一般可以重载为友元运算符函数或成员运算符函数。如果运算符函数中两个操作数类型不同，则一般只能从 采用友元运算符函数，用成员函数重载“”运算符：nclass nclass:operator+(int x)nclass temp;temp.a=a+x;temp.b=b+x;return temp;如果在主

25、程序中有ob=100+ob;那么会出现错误，原因是由于100是内部的数据类型，不能产生对成员函数的调用，成员函数的调用一般是通过对象加以调用的，解决这个问题的办法是用两个友元函数来重载运算符函数“”。这样可以将两个参数都显式地传递给运算符函数。这样内部数据类型可以出现在运算符的左边。见例7.8,成员运算符函数和友元运算符函数都有两种方式调用：显式调用与隐式调用运算符的优先级决定怎样将一个表达式改写为函数调用表达形式。如：a+b*c operator+(a,operator*(b,c)/a+b*!c operator+(a,operator*(b,c.operator!()/a*(b+c)ope

26、rator*(a,operator+(b,c)/a+b+c operator+(operator+(a,b),c)/a=b+=c operator=(b.opertaor+=(c)/对同一运算符重载为成员函数总比重载为友元函数少一个参数C+的大部分运算符既可以说明为友元运算符函数，又可为成员运算符函数。一般来讲，单目运算符最好重载为成员函数，而双目运算符则最好重载为友元函数。,7.3 几种常用运算符的重载,单目运算符“+”和“”的重载针对预定义数据类型，C+语言提供了自增运算符“+”和自减运算符“”，这两个运算符都有两种形式：前缀与后缀。但是在早期C+版本虽然能重载这两个运算符。但不能区分他们

27、的两种形式。在后期的C+版本中，编辑器可以通过在运算符函数参数表中是否关键字int来区分前缀与后缀。以“+”重载运算符为例，其语法格式如下：operator+（）；/前缀运算 operator+（int）；/后缀运算 调用时，参数int 一般被传递给值0。,前面说的是前缀与后缀运算符函数重载为类的成员，如果重载为类的友元函数，语法格式则为：operator+（X 例7.9使用成员函数分别以前缀和后缀的方式重载了运算符“+”，使用友元函数分别以前缀与后缀方式重载了运算符“”,#includeclass three_d public:three_d()x=0;y=0;z=0;three_d(int

28、 i,int j,int k)x=i,y=j;z=k;void show(int,three_d three_d:operator+()+x;+y;+z;return*this;three_d three_d:operator+(int)x+;y+;z+;return*this;three_d operator-(three_d,main()three_d ob1(10,10,10);three_d ob2(20,20,20);int x,y,z;ob1.show(x,y,z);cout(ob1)x:x,y:y,z:zn;ob1+;ob1.show(x,y,z);cout(ob1+)x:x,y

29、:y,z:zn;+ob1;ob1.show(x,y,z);cout(+ob1)x:x,y:y,z:zn;cout-endl;ob2.show(x,y,z);cout(ob2)x:x,y:y,z:zn;operator-(ob2);ob2.show(x,y,z);cout(ob2-)x:x,y:y,z:zn;operator-(ob2,0);ob2.show(x,y,z);cout(-ob2)x:x,y:y,z:zn;return 0;,以前缀方式和后缀方式重载了运算符“+”#includeclass Number public:Number(int i)num=i;int operator+(

30、)num+;return num;int operator+(int)int i=num;num+;return i;void print()coutnumendl;private:int num;main()Number n(100);int i=+n;couti=iendl;i=n+;couti=iendl;n.print();return 0;,赋值运算符“=”的重载对任一类X，如果没有用户自定义的赋值运算符函数，那么系统自动地为其生成一个缺省的赋值运算符函数，定义为类X中的成员到成员的赋值，例如：X X：operator=（const X source）成员间赋值 若 Objl和Obj

31、2是类 X的两个对象，Obj2已被创建，则编译程序遇到如下语句：ObjlObj2；就调用缺省的赋值运算符函数，将对象 ObjZ的数据成员的值逐个赋给对象 Objl的对应数据成员中。,指针悬挂问题在某些特殊情况下，如类中有指针类型时，使用缺省的赋值运算符函数会产生错误。请看下例子7.11.#include#includeclass string public:string(char*s)ptr=new charstrlen(s)+1;strcpy(ptr,s);string()delete ptr;void print()coutptrendl;private:char*ptr;,void ma

32、in()string p1(book);string p2(pen);p1=p2;coutp2:;p2.print();coutp1:;p1.print();从这个例子可以看出经使用了缺省的赋值运算符“=”，这个运算符把对象p2的数据成员逐域地拷贝到对象p1的对应数据成员中，从而使得pl的数据成员原先的值被冲掉了。由于pl.ptr和p2.ptr具有相同值，都指向p2的字符串，p1.ptr原先指向的内存区不仅没有释放，而且被封锁起来无法再用，这就是所谓的指针悬挂问题更为严重的是：对于存储“pen”内容的内存在程序结束时，释放了两次，从而导致运行错误。可以通过重载赋值运算符解决指针悬挂问题,见例7

33、.12说明类的赋值运算符“=”只能重载为成员函数，而不能把它重载为友元函数。类的赋值运算符“=”可以被重载，但重载了的运算符函数operator=()不能被继承,下标运算符“”重载C+把下标运算符 看成一个双目运算符，其操作数为和，对应的运算符为operator，必须重载为一个成员函数。对于下标运算符重载定义形式如下：类型 类名：operator(形参)函数体 先看一个例子7.13说明：重载下标运算符“”的一个优点是可以增加C+中数组检索的安全性重载下标运算符“”时，返回一个int的引用，所以可使重载“”用在赋值语句的左边。,#include#includeclass Vector4 publ

34、ic:Vector4(int a1,int a2,int a3,int a4)v0=a1;v1=a2;v2=a3;v3=a4;private:int v4;void main()Vector2 v(1,2,3,4);coutv2;,函数调用运算符“（）”重载C+把函数调用运算符()看成一个双目运算符，其操作数为和，对应的运算符为operator()，必须重载为一个成员函数，则重载运算符()的调用由左边的对象产生对operator函数的调用，this指针总是指向产生调用的对象。重载运算符()的operator函数可以带任何类型的操作数，返回类型也可以是任何有效的类型。对于下标运算符重载定义形式如

35、下：类型 类名：operator（）（形参)函数体 例子7.15介绍了函数调用运算符的重载情况,#includeclass Matrix public:Matrix(int,int);int,运算符new和delete的重载C+提供了new与delete两个运算符用于内存管理，但有些情况下用户需要自己管理内存，为自己所定义的类体系建立一种新的动态内存管理算法，以克服new与delete的不足。这就要重载运算符new与delete，使其按照要求完成对内存的管理。new和delete只能被重载为类的成员函数，不能重载为友元。而且，无论是否使用关键字static进行修饰，重载了的new和delete

36、均为类的静态成员函数。new和delete有两种重载方式：覆盖缺省定义的全局方式；只针对一个类的局部方式。一般重载都采用后一种方式，这是由于不同类有不同的结构和不同的内存需求,在一类中重载new和delete的一般语法形式为：void*class_name:operator new（size_t，size）/分配存储空间/返回空间的起始地址void class_name:operator delete（void*pointer）释放指针pointer所指向的存储空间这里的size_t类型被定义为包含可被分配的最大单片内存的类型，参数size将包含待分配对象所需要的字节数。重载new的函数必须返

37、回一个指向所分配内存的指针，或者在分配发生错误时返回零。除了上述限制，重载new的函数可以完成你想做的其他事情。delete函数接受一个指向一个待释放内存的指针，然后将该指针所指向的内存释放给系统。例7.17给出了new和delete运算符的用法,#include#includeclass Rectpublic:Rect(int l,int w);void disp()cout面积：length*widthendl;void*operator new(size_t size);void operator delete(void*p);private:int length,width;,Rect

38、:Rect(int l,int w)length=l;width=w;void*Rect:operator new(size_t size)cout重载new运算符分配内存!n;return malloc(size);void Rect:operator delete(void*p)cout重载delete运算符释放内存!n;free(p);,void main()Rect*p=new Rect(5,9);p-disp();delete p;说明:当动态建立一个类的对象时,系统首先检查该类是否有一个operator new()函数,若有则调用该函数,否则就调用全局的operator new()

39、函数;类中重载的new和delete只能用于各个对象的动态生成,不能用于数组、静态对象等；也可以重载全局的new和delete，这时需要在类外定义，其定义格式与类中的格式基本相同，只是不带类域作用域。,7.3 类型转换,系统预定义类型间的转换类型间的转换是将一种类型的值转换为另一种类型的值。C+提供了两种系统预定义类型的转换方式：一种是隐式类型转换；显式类型转化隐式类型转换在赋值表达式A=B的情况当char或short类型变量与int类型变量进行运算时，将char或short类型转换为int当两个操作对象类型不一致时，在算术运算前，级别低的自动转换为级别高的类型显式类型转换强制转换法（类型名）

40、表达式 如int i,j;cout(float)(i+j);函数法类型名(表达式)如int i,j;coutfloat(i+j),类类型与系统预定义类型间的转换方法：通过构造函数、通过类类型转换函数通过构造函数进行类型转换构造函数除了为对象分配空间、为私有数据赋初值之外，还具有类型转换的作用，它将其它类型的值转换为它所在类的类型的值。例7.18给出了通过构造函数进行类型转换的情况说明：为了用构造函数完成类型转换，类内至少定义一个参数（或其他参数都带缺省值）的构造函数。,#includeclass examplepublic:example(int);void print();private:i

41、nt num;example:example(int n)num=n;coutIntializing with:numendl;void example:print()coutnum=numendl;,void main()example X=example(3);X.print();cout-n;example Y=6;Y.print();cout-n;Y=8;Y.print();,通过类型转换函数进行类型转换通过构造函数进行类型转换，它只能从基本类型转换为类类型，而不能将类类型转换为基本类型，但可以通过类型转换函数将其用户定义的类型转换为基本类型，类类型转换函数则可以用来把源类型转换成另一

42、种目的类型。其类型转换函数在类中定义中的一般格式为：class 源类类名/operator type()/return type 的数据；/;type为要转换为的目标类型。这个函数既没有参数，又没有返回类型，但在函数体中必须返回具有type类型的一个数据,说明类型转换函数只能定义为一个类的成员函数，而不能为友元函数在类中可以有多个类型转换函数。C+编译器将根据操作数的类型自动地选择一个合适的类型转换函数与之匹配。实际上，类型转换运算符将对象转换成类型名规定的类型。转换时的形式就像强制转换一样。如果没有转换运算符定义，直接用强制转换是不行的，因为强制转换只能对标准数据类型进行操作，对类类型的操作

43、是没有定义的。类类型转换函数没有没有参数，也不显式给出返回类型类类型转换函数中必须有“return 目的类型的数据；”的语句，即必须送回目的类型数据作为函数的返回值。例7.19给出了类类型转换函数显式调用的情况,#includeclass Complexpublic:Complex(float r=0,float i=0)real=r;imag=i;coutConstructing.n;operator float()coutType changed to float.n;return real;operator int()coutType changed to int.n;return in

44、t(real);void print()cout(real,imag)endl;private:float real,imag;,void main()Complex a(2.2,4.4);a.print();coutfloat(a)*0.5endl;Complex b(4,6);b.print();coutint(b)*2endl;上例中，两次调用了类类型转换函数。并且都是采用的显式调用的方式。使用类类型转换函数可以分为显式转换与隐式转换两种形式，下面通过例7.20怎样通过隐式转换来进行的。,#includeclass Complexpublic:Complex(int r,int i)re

45、al=r;imag=i;coutConstructing.n;Complex(int i=0)real=imag=i/2;operator int()coutType changed to int.n;return real+imag;void print()coutreal:realtimag:imagendl;private:int real,imag;,void main()Complex a1(1,2),a2(3,4);a1.print();a2.print();Complex a3;a3=a1+a2;a3.print();从上例中没有在类中重载运算符“”，为何a3=a1+a2成立呢？原因在于C+自动进行了隐式转换，将a1与a2分别都转换成int型，然后调用构造函数将整型数据转换为complex类。,本章作业 7-5、7-6、7-8,