操作符重载
百科名片
操作符重载，
计算机学科概念，就是把已经定义的、有一定功能的操作符进行重新定义，来完成更为细致具体的运算等功能。操作符重载可以将概括性的抽象操作符具体化，便于外部调用而无需知晓内部具体运算过程。
定义
操作符重载就是把操作符（比如'+，-，*，/'这些
运算符）赋于新的意思
目的
C++有许多内置的
数据类型，包括int，char，double等，每一种类型都有许多
运算符，例如加+，减，乘，除等。当用户定义了类的对象时，两个对象之间是不能进行这些操作的，比如hyong类的对象a+b，这样的语句如果没有重载+
运算符就会出错。但C++允许用户把这些
运算符添加到自已的类中以方便类对象之间的运算就像
内置类型的运算一样方便，比如对象a+b这样就很明白更容易懂，当然也可以在类中定义一个对象间相加的函数，比如a.add(b)调用函数add()以实现两个对象a和b相加，但是这条语句没有比a+b更容易让人理解。
实现
要实现操作符重载就要使用操作符
重载函数，操作符重载函数用关键字operator实现，其形式为：返回类型 operator 操作符 (
参数列表){}。操作符重载函数是一个函数，只不过这个函数的函数名为operator再加上后面要重载的操作符而已，比如要重载+号，则：hyong operator +(hyong m){}这就声明了一个返回类型为hyong的操作符函数，其函数名为operator +
作为类的成员和友元或者独立于类的区别
当操作符
重载函数作为
类的成员函数时，操作符重载函数的参数会比作为友元或者独立于类的操作符重载函数少一个参数，因为操作符重载类成员函数把调用该函数的对象作为函数的第一个参数，也就是隐含的this
指针指向调用该函数的第一个对象，所以会少一个参数。
调用操作符重载函数的方式
需把其作为类的友元或者类的成员
一般来说操作符
重载函数一般不要求作为类的成员函数或者是友元函数，一般情况下可以将操作符重载函数作为类的成员函数。但是有一种情况必须要求操作符函数作为类的
友元函数或者是独立的函数，就是一个
内置类型和对象相加的情况。比如有语句m+1和1+m第一条可以在类中定义操作符函数的形式为hyong operator +(int i){}，语句m+1可以调用这个函数是正确的，但对于1+m就不能调用这个函数了，因为类中的操作符
重载函数是最左边的对象是调用该函数的对象，但1+m最左边的是一个内置
整型类型1，所以不会调用这条语句，对于这种语句就只能把操作符重载函数定义为独立的函数或类的
友元函数即形如hyong operator +(int i,hyong a){}这样1+m就会转换成operator +（1,m)这样就是正确的。当然如果这个操作符
重载函数需要访问类中的私有成员时，就应把该函数定义为类的
友元函数，如果不需要访问类中的私有成员，则可以定义为友元也可以定义为独立函数。
必须把它作为类成员函数的运算符有
()，[]，->；和任何赋值运算符，重载这些运算符时必须把操作符函数声明为
类的成员函数。
重载操作符的限制
-
1 并不是所有的操作符都能被重载。除了. ，.* ，：： ，? : ，sizeof，typeid这几个运算符不能被重载，其他运算符都能被重载
⒏2 重载不能改变该
运算符用于内置类型时的函义，程序员不能改变运算符+用于两个int型时的含义。
⒏4 重载不能改变
运算符的优先级。
⒏5 重载不能改变
运算符的结合律。
返回类型问题
在某些情况下操作符函数必须返回一个对象类型作为返回值，比如有hyong的对象a,b,c则语句a=b+c其中重载的+操作符就必须返回一个hyong类型的一个对象，以便赋给对象a，不然该语句就会出错。当然你可以在语句中返回一个临时对象，也可以返回一个对象的引用，或者返回this
指针，不过返回临时对象会浪费内存开销，所以最好返回类对象的一个引用。
参数传递问题
操作符函数可以按值传递也可以按引用传递，这根据操作符而定，比如对于+
运算符既可以把对象按值传递给操作符函数也可以按引用传递给操作符函数，而且+操作符不会改变原
操作数的值，所以应把传递类型声明为const，比如hyong operator +(const hyong &a,const hyong &b){}。但对于要改变其自身值的操作符比如++运算符，就必须传递引用，且不能把该引用声明为const类型，因为如果
操作数按值传递的话，传递给操作数函数的将是一个对象的副本，两个副本是独立的，不能改变到原对象的值，所以应按引用传递对象，比如hyong operator ++(hyong &a){}。
重载一元运算符++
2． 默认的带有一个参数的++运算符函数是前缀++运算符，要重载后缀的++运算符必须采用另一种方式实现。
重载后缀的++
运算符时应给函数多增加一个int参数，该int参数不会使用，应忽略他，该参数只是为了让
编译器区分++运算符的前缀和后缀形式之间的区别。比如重载后缀++
运算符的
友元函数形式为hyong operator ++(hyong &a,int i){}后面的参数int i没有实际意义，应忽略他。
例：重载++运算符的例子
class A
{public: int b; A(){b=0;} A(int i){b=i;} ~A(){cout<<"xi"<<"\n";}
const A & operator ++(){ ++b; return *this;} }; //定义前缀形式的++运算符，函数的返回类型既可以返回引用也可以是返回值，但返回引用不会增加内存开销。返回类型可以是任意的，比如可以是int型，也可以是void，即没有返回值，但这里的返回类型必须是类类型A，因为在main函数中
表达式用于
赋值运算符的左边，且把结果赋给了一个类A的对象。返回const的原因是防止++++k这样的情况出现，有const就不能再改变返回对象的值即不能再对++k作增量运算。
const A & operator ++(A &j,int i) //定义独立的后缀形式的++运算符，这里必须把第一个参数声明为对对象的引用，因为++运算符会改变原始对象的值，如果不是引用就不能改变原始对象的值，也就达不到++运算符的效果。注意int i参数是不使用的，只是让
编译器区分是前缀还是后缀的++运算符。
{A t(j); //定义一个A类对象t，因为后缀形式的++运算符是先执行
表达式后进行增量运算，所以这里应生成一个临时对象以便返回对象的原始值
return t;} //返回对象t，这里会生成一个临时对象。
int main()
{ A m,n,k;
m=++k; //调用前缀形式的++类成员运算符函数，语句等价于m=k.operator ++()；因为前缀的++是类的成员，所以只能用点运算符调用，形如operator ++(k)将是错误的。
n=k.operator ++ (); //显示调用前缀的++类成员运算符函数。同m=++k。
cout<<n.b<<k.b; //输出22。
n=k++; //调用后缀形式的独立++运算符函数，该语句等价于n=operator ++(k,1），其中后面的是没有意义的参数，只是为了让
编译器区别是前缀还是后缀
n= operator ++(k,1）； //显示调用后缀的++独立运算符函数，同n=k++。注意整形
实参在这里没有实用价值，但必须得有，以便指明是调用的后缀++形式。
cout<<n.b<<k.b; } //输出34。
重载二元运算符+
要注意重载二元运算符时如果有形如1+m这种类型的
表达式就必须把该操作符函数定义为非类的成员的形式。因为类中的操作符重载函数是最左边的对象是调用该函数的对象
class A
{public: int b; A(){b=0;} ~A(){cout<<"xi"<<"\n";}
explicit A(int i){b=i;} //这里需要explicit关键字以防止自动的隐式类型转换，不然语句const A &operator +(const A &j)和friend const A &operator +(const A &j,const int i)将出错二义性问题。也就是第一个操作符函数可以用隐式类型转换用语句m+3来调用。
//const A & operator +(const A &j){b=b+j.b;return *this;} //对于+操作符不会改变被加的
操作数的值，但这里改变了调用该函数的对象的值，最好不要这样做。
const A &operator +(const A &j){A t; t.b=b+j.b; return t;} //定义一个临时对象t以防止修改调用该函数的两个
操作数的值。
friend const A &operator +(const A &j,const int i); };//+操作符函数不应该改变调用该函数的两个
操作数的值，所以这里将参数声明为const
const A &operator +(const A &j,const int i){A t;t.b=j.b+i; return t;} //定义友元函数以实现"对象+内置类型"这种类型的运算
const A &operator +(const int i,const A &j) {A t; t.b=j.b+i;return t;} //因为类A没有私有成员，该函数也不访问类中的私有成员所以可以不用定义为类的
友元，这个函数将实现，"内置类型+对象"的这种运算
//对于这种操作符
重载函数不能定义为
类的成员函数，因为类的成员函数的第一个参数是指向类对象的一个this
指针，在这里第一个参数是内置类型不是类的对象，所以必须把这种操作符函数定义为非成员的形式。
int main()
{ A m⑴，n⑵，k;
k=m+3; //调用operator +(const A &j,const int i)这个类的
友元操作符函数，以实现对象和内置类型相加，该语句和operator +(m,3）一样。
cout<<m.b<<k.b; //输出14，这里没有改变对象m的值，这是应该的。
k=operator +(m,3）； cout<<m.b<<k.b;// 输出14。和上面m+3的语句一样，这是显示调用操作符函数的形式，记住操作符
重载函数是一个函数，只是他的名字比较特别，名字为operator加上后面的操作符而已
k=m+n; //调用类成员操作符函数operator +(const A &j)，实现两个对象相加，这条语句会自动转换为m.operator +(n)的形式调用操作符函数。记住最左边的对象是调用类成员操作符函数的对象。cout<<m.b<<n.b<<k.b; //输出123，这里没有改变对象m和n的值，实现了对象m和n相加 k=n.operator +(m); cout<<m.b<<n.b<<k.b; //显示调用成员操作符函数operator +(const A &j)的形式，这种形式和语句n+m等价。
k=4+m; //调用操作符函数operator +(const int i,const A &j)以实现内置类型和一个对象相加，语句和operator +（3,m)等价。cout<<m.b<<k.b; //输出15。k=operator +（4,m); cout<<m.b<<k.b; } //输出15，语句和+m相同。
重载赋值运算符=
1． 注意重载赋值运算符和[]，()，->；运算符必须定义为
类的成员函数。
2． 注意：如果程序不提供显示的
赋值运算符则系统会提供一个默认的赋值运算符。
4． 重载
赋值运算符时应有处理语句m=m的情况。其中m是某一个类的对象。如果不处理这样的语句有时会出现问题，具体什么问题有待调查。可以用this
指针来做处理，比如有语句const A & operator(A &j)则可以用if(this==&j) return *this；这样的语句来处理，即比较当前调用
赋值运算符函数的对象的地址和被赋值的对象的地址，如果地直相等说明是同一个对象。
class A
{
public:
int b;
A(){b=1;}
A(int i){ b=i;}
const A & operator =(const A & j) //返回一个类的对象的引用
{
/* 用this和j的地址来检查是否是对自身的赋值的情况，如果调用
赋值运算符函数的地址和
被赋值的对象的地址相等，则说明是同一个对象，就返回当前对象。
*/
if(this==&j) return *this;
b=j.b;
return *this;
}
};
int main()
{
A m⑵； A n; n=m; cout<<n.b;
n=n; //对象对自已赋值的情况。
cout<<n.b;
}
8436
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
