第10章运算符重载讲

算术运算符：加（+）、减strings1,s2;//s1,s2为字符串对象s1+s2//?Complexa,b;//复数类对象a+b//???a-b//???x+y//x,y为int,float,double,char….问题引出：运算符重载问题引出：自定义类型的运算#include<iostream.h>classComplex{public: Complex(doublert=0,doubleit=0){r=rt;i=it;} voiddisp(); Complexadd(Complex&); Complexdec(Complex&);private: doubler,i;};voidComplex::disp(){if(i>0)cout<<r<<"+"<<i<<"i"<<endl;elseif(i<0)cout<<r<<i<<"i"<<endl;elsecout<<r<<endl;}ComplexComplex::add(Complex&t){ doublert=r+t.r; doubleit=i+t.i; returnComplex(rt,it); }ComplexComplex::dec(Complex&t){ returnComplex(r-t.r,i-t.i);}voidmain(){ Complexa(10,10),b(15,15),c; a.disp(); b.disp(); c=a.add(b); c.disp(); c=a.dec(b); c.disp();}10+10i15+15i25+25i-5-5ic=a+b;c=a-b;#include<iostream.h>classComplex{public: Complex(doublert=0,doubleit=0){r=rt;i=it;} voiddisp(); Complexoperator+(Complex&); Complexoperator-(Complex&);private: doubler,i;};voidComplex::disp(){if(i>0)cout<<r<<"+"<<i<<"i"<<endl;elseif(i<0)cout<<r<<i<<"i"<<endl;elsecout<<r<<endl;}ComplexComplex::operator+(Complex&t){ doublert=r+t.r; doubleit=i+t.i; returnComplex(rt,it); }ComplexComplex::operator-(Complex&t){ returnComplex(r-t.r,i-t.i);}voidmain(){ Complexa(10,10),b(15,15),c; a.disp(); b.disp(); c=a+b; c.disp(); c=a-b; c.disp();}编译器将其解释为函数调用：c=a.operator+(b);c=a.operator-(b);定义了两个重载运算符的成员函数，它们的名字是：operator+operator–#include<iostream.h>classCPoint{public: CPoint(intxx=0,intyy=0) { x=xx; y=yy; } voiddisp() { cout<<"("<<x<<','<<y<<")"<<endl; } CPointoperator+(CPoint&q) { returnCPoint(x+q.x,y+q.y); } CPointoperator-(CPoint&q) { returnCPoint(x-q.x,y-q.y); }private: intx,y;}; 定义了两个重载运算符的成员函数，它们的名字是：operator+operator–voidmain(){

CPointa(10,10),b(15,15),c;

a.disp();b.disp();c=a+b;//c=a.operator+(b);c.disp();c=a-b;//c=a.operator-(b);c.disp();

a=a+a;//a=a.operator+(a);

a.disp();}对表达式a+b、a-b，编译器将其解释为函数调用：

a.operator+(b);a.operator–(b);运算符重载C++提供了运算符重载的机制，程序员可对自定义的数据类型使用C++本身提供的标准运算符进行运算，运算的实现由重载运算符的特殊函数来完成。这些函数有特殊的函数名(operator+)，可使用运算符方式进行调用，也可以使用传统的函数调用方式进行调用。运算符重载：赋予已有的运算符多重含义，如运算符“>>”既作为流的插入运算符，又作为移位运算符，根据其操作对象的不同，执行其不同的功能。在c++中，允许对大多数的运算符进行重载，通过定义重载运算符的函数使它能够用于特定类的对象。运算符重载的实现运算符重载实际上是将运算符重载为一个函数，在重载某个运算符时，实际上就是定义一个重载运算符的函数，函数名为operator运算符。在执行被重载的运算符时，系统自动调用该函数以实现相应的运算对表达式a+b、a–b，编译器将其解释为函数调用：

a.operator+(b); a.operator–(b);运算符重载是通过定义函数实现的，运算符重载实质上是函数的重载（遵循函数重载的原则）。对于重载的运算符可以使用运算符方式调用，也可以使用函数调用方式调用。ComplexComplex::operator+(Complex&t){ returnComplex(r+t.r,i+t.i); }ComplexComplex::operator-(Complex&t){ returnComplex(r-t.r,i-t.i);}重载运算符的函数的定义形式[friend]返回类型[类名::]operator

重载的运算符（参数列表）{

相关操作；}参数的个数由以下两个因素决定：1操作符是单目还是双目运算符2定义为友元函数还是成员函数友元函数成员函数单目运算符1个参数0个参数双目运算符2个参数1个参数在C++中提供了两种形式的运算符重载，即重载为：成员函数、友元函数如果是友元函数，那么对于单目运算符，它的参数个数就是1个，双目运算符的参数个数是2个；如果是成员函数，那么对于单目运算符的参数个数为0，双目运算符的参数个数是1个（这是由于该类本身也作为一个操作数参与计算）。一、重载为类的成员函数类中的函数原型声明：返回类型operator

重载的运算符（参数类型列表）;程序中出现（以双目运算符为例）C1运算符C2C1.

operator运算符(C2)编译程序解释为函数调用：其中，C1和C2是类的对象，operator运算符则是运算符重载函数名。1、双目运算重载为成员函数定义形式：返回类型[类名::]operator重载的运算符（参数列表）{

相关操作；}对表达式a+b、a–c，编译器将其解释为函数调用：

a.operator+(b); a.operator–(c);ComplexComplex::operator+(Complex&t){ returnComplex(r+t.r,i+t.i); }ComplexComplex::operator-(Complex&t){ returnComplex(r-t.r,i-t.i);}Complexoperator+(Complex&t);Complexoperator-(Complex&t);#include<iostream.h>classComplex{public: Complex(doublea=0,doubleb=0) { r=a,i=b; } voiddisp() { if(i>0)cout<<r<<"+"<<i<<"i\n"; elseif(i<0) cout<<r<<i<<"i\n"; else cout<<r<<endl; } Complexoperator+(Complex&b) { returnComplex(r+b.r,i+b.i);} Complexoperator-(Complex&b) { returnComplex(r-b.r,i-b.i);} Complexoperator+=(Complex&b) { r+=b.r; i+=b.i; return*this;}private: doubler,i;};voidmain(){ Complexa(2,3),b(4,5); Complexc(a+b); a.disp(); b.disp(); c.disp(); c=a-b; c.disp(); a+=c; a.disp();}复数的运算符重载(成员函数)2+3i4+5i6+8i-2-2i0+1ia.operator+(b)a.operator-(b)a.operator+=(c)#include<iostream.h>#include<string.h>classstring{public: string(constchar*); string(string&s); ~string(); intstrlength(); voiddisp(); stringoperator=(string&sp); stringoperator+(string&sp); intstrcomp(string&sp); intoperator>(string&sp);private: char*pstr; intlength;};string::string(constchar*sp){ length=strlen(sp); pstr=newchar[length+1]; strcpy(pstr,sp);}string::string(string&sp){ length=sp.length; pstr=newchar[length+1]; strcpy(pstr,sp.pstr);}string::~string(){ delete[]pstr;}intstring::strlength(){ returnlength;}voidstring::disp(){ cout<<pstr<<endl;}字符串的运算符重载(成员函数)stringstring::operator=(string&sp){ length=sp.length; delete[]pstr; pstr=newchar[length+1]; strcpy(pstr,sp.pstr); return*this;}stringstring::operator+(string&sp) { char*s=newchar[length+sp.length+1]; strcpy(s,pstr); strcat(s,sp.pstr); stringt(s); delete[]s; returnt;}intstring::strcomp(string&sp){ intcmp=strcmp(pstr,sp.pstr); returncmp;}intstring::operator>(string&sp){ if(strcomp(sp)>0) return1; else return0;}voidmain(){ strings1("1234567890"),s2("abcdefg"); s1.disp(); s2.disp(); intk=s1>s2; cout<<k<<endl; k=s2>s1; cout<<k<<endl;

s1=s1+s2;

s1.disp(); s1=s2; s1.disp();}s1.operator=(s1.operator+(s2))s1.operator=(s2)注意关于“＝”赋值运算：C++允许同类对象间的赋值，将其对应的数据成员赋值；如果在构造函数中有资源申请，则不能使用系统的赋值方式，而必须重载赋值运算符，如string类；没有资源分配，可不重载赋值运算符，如Complex类。不能自造运算符：如字符串的比较函数，没有相应的运算符，不能用户自己定义。classComplex{public:Complex(doubler=0,doublei=0);voidShow();Complexoperator-();//对单目负号重载private:doubler,i;};ComplexComplex::operator-()//对单目负号重载//第一个Complex为函数返回值类型，第二个Complex为类名{returnComplex(-r,-i);}返回类型类名::operator

-(){

相关操作；}2、单目运算重载为成员函数1）负号运算符++分：先增和后增返回类型类名::operator

++（）{

相关操作；}先增：后增：返回类型类名::operator

++（int）{

相关操作；}int只是为了标志前后的区别，没有其他作用。2、单目运算重载为成员函数2）自增++、自减--#include<iostream.h>classCPoint{public: CPoint(intxx=0,intyy=0){ x=xx; y=yy; } voiddisp(){ cout<<"("<<x<<','<<y<<")"<<endl; } CPointoperator+(CPointq){ returnCPoint(x+q.x,y+q.y); } CPointoperator-(CPointq){ returnCPoint(x-q.x,y-q.y); } CPointoperator++() //先增{ x++; y++; return*this; } CPointoperator++(int) //后增{ CPointt(x,y); x++; y++; returnt;} CPointoperator--(){ x--; y--; return*this; } CPointoperator--(int){ CPointt(*this); x--; y--; returnt;}private: intx,y;};voidmain(){CPointa(10,10),b;a.disp();b=a++; a.disp();b.disp();b=++a; a.disp();b.disp();b=a--; a.disp();b.disp();b=--a; a.disp();b.disp();}(10,10)(11,11)(10,10)(12,12)(12,12)(11,11)(12,12)(10,10)(10,10)this指针是一个无需定义的特殊指针，它隐含于每一个类的成员函数中，指向正在被某个成员函数操作的对象。如果某个对象调用了一个成员函数，则系统首先将这个对象的地址赋给this指针，然后再调用成员函数，因此也可以用*this来标识调用该成员函数的对象。通常情况下，程序不显式地使用this指针。2、单目运算重载为成员函数3）下标运算符[]#include<iostream.h>classCArray{public:CArray(intsize); CArray(CArray&); ~CArray(); int&operator[](int);intgetAt(intnIndex);voidsetAt(intnIndex,intnewElement);private:int*data;//整型数组首地址intsize; //数组中的元素个数};CArray::CArray(ints){ size=s; data=newint[size];}CArray::CArray(CArray&a){size=a.size;data=newint[size];for(inti=0;i<size;i++) data[i]=a.data[i];}CArray::~CArray() { delete[]data; }int&CArray::operator[](intnIndex){ returndata[nIndex];}intCArray::getAt(intnIndex){ returndata[nIndex];}voidCArray::setAt(intnIndex,intnewElement){ data[nIndex]=newElement;}voidmain(){ CArraya(10); for(inti=0;i<10;i++) a[i]=i*2+1; for(i=0;i<10;i++) cout<<a[i]<<'\t'; cout<<endl;}classstring{public: string(constchar*); string(string&s); ~string(); voiddisp(); charoperator[](int);private: char*pstr; intlength;};charstring::operator[](inti){ returnpstr[i];}下标运算符[]voidmain(){ strings1("1234567890"); s1.disp(); cout<<s1[5]<<endl;}二、重载为友元函数在类中声明为友元函数：friend返回类型operator重载的运算符（参数类型列表）；程序中出现形式：（以双目运算符为例）C1运算符C2operator运算符(C1,C2)编译程序解释形式：其中，C1和C2是类的对象，operator运算符则是运算符重载函数名。定义形式：返回类型operator重载的运算符（参数列表）{

相关操作；}1、双目运算重载为友元函数输入>>输出<<必须重载为友元复数的双目运算符重载(友元函数)2+3i4+5i6+8i-2-2i0+1iinclude<iostream.h>classComplex{public: Complex(doublea=0,doubleb=0){r=a,i=b; } voiddisp(){if(i>0)cout<<r<<"+"<<i<<"i\n"; elseif(i<0) cout<<r<<i<<"i\n"; else cout<<r<<endl; } friendComplexoperator+(Complex&,Complex&); friendComplexoperator-(Complex&,Complex&); friendComplexoperator+=(Complex&,Complex&);private: doubler,i;};Complexoperator+(Complex&a,Complex&b){ returnComplex(a.r+b.r,a.i+b.i); }Complexoperator-(Complex&a,Complex&b){ returnComplex(a.r-b.r,a.i-b.i); }Complexoperator+=(Complex&a,Complex&b){ a.r+=b.r; a.i+=b.i; returna; }voidmain(){Complexa(2,3),b(4,5); Complexc(a+b); a.disp(); b.disp(); c.disp(); c=a-b; c.disp(); a+=c; a.disp();}operator-(a,b)operator+=(a,c)operator+(a,b)2、复数的单目运算符重载(友元函数)include<iostream.h>classComplex{public: Complex(doublea=0,doubleb=0){r=a,i=b; } voiddisp(){ if(i>0)cout<<r<<"+"<<i<<"i\n"; elseif(i<0) cout<<r<<i<<"i\n"; else cout<<r<<endl; } friendComplexoperator++(Complex&a); friendComplexoperator++(Complex&a,int); friendComplexoperator--(Complex&a); friendComplexoperator--(Complex&a,int);private: doubler,i;};Complexoperator++(Complex&a){ a.r++; a.i++; returna; }Complexoperator++(Complex&a,int){ Complext(a.r++,a.i++); returnt; }Complexoperator--(Complex&a){ a.r--; a.i--; returna; }Complexoperator--(Complex&a,int){ Complext(a.r--,a.i--); returnt; }Complexa(10,10),b;a.disp();b=a++; a.disp();b.disp();b=++a; a.disp();b.disp();b=a--; a.disp();b.disp();b=--a; a.disp();b.disp();10+10i11+11i10+10i12+12i12+12i11+11i12+12i10+10i10+10i-22->>和<<运算符C++预定义了cout和cin输入输出流对象。cout为内置数据类型提供了重载的<<运算符，支持对它们的输出操作，cin重载了>>运算符，支持对它们的输入操作。如果希望自定义类支持cout和cin的<<和>>操作，需要重载这些运算符。-23-classCounter{public:

friendstd::ostream&operator<< (std::ostream&out,constCounter&c);…….};重载输出运算符operator<<必须重载为友元函数，参数为输入流对象

和被输出对象，返回输出流对象，以支持连续输出。std::ostream&operator<<(std::ostream&out, constCounter&c){ out<<c.getValue()<<std::endl; returnout;}operator<<运算符函数，将c的内容输出到传入的输出流

中，并返回out的引用。以支持形同cout<<c1<<c2的级联式输出。当运算符重载函数为：成员函数--：双目运算符的参数个数是1个；单目运算符的参数个数为0友元函数---单目运算符的参数个数就是1个，双目运算符的参数个数是2个这是因为重载为成员函数时，总是隐含了一个参数，该参数是this指针，它是指向调用该成员函数对象的指针，而重载为友元函数时则没有隐含的this指针。运算符重载的原则运算符重载不改变运算符的优先级和结合性，不改变其语法结构，也就是不能改变操作数的个数。即单目的只能重载为单目运算符，双目的只能重载为双目运算符。只能对已有运算符重载，不能自定义运算符。可重载的运算符运算符名称运算符名称，逗号运算符<小于！=不等<<左移%取模<<=左移/赋值%=取模/赋值<=小于等于&=赋值&&逻辑与==等于&=按位与/赋值>大于*乘>=大于等于*=乘/赋值>>右移+加>>=右移/赋值+=加/赋值^异或-减^=异或/赋值-=减/赋值|按位或->成员选取|=按位或/赋值/除||逻辑或/=除/赋值

按位与不可重载的运算符5个：

..*::?:sizeof作业1、定义复数类，实现复数的+、-、+＝、++先、++后、--先、--后运算符重载：成