在某些情况下操作符函数必须返回一个对象类型作为返回值，比如有hyong的对象a,b,c则语句a=b+c其中重载的+操作符就必须返回一个hyong类型的一个对象，以便赋给对象a，不然该语句就会出错。当然你可以在语句中返回一个临时对象，也可以返回一个对象的引用，或者返回this指针，不过返回临时对象会浪费内存开销，所以最好返回类对象的一个引用。

操作符函数可以按值传递也可以按引用传递，这根据操作符而定，比如对于+运算符既可以把对象按值传递给操作符函数也可以按引用传递给操作符函数，而且+操作符不会改变原操作数的值，所以应把传递类型声明为const，比如hyong operator +(const hyong &a,const hyong &b){}。但对于要改变其自身值的操作符比如++运算符，就必须传递引用，且不能把该引用声明为const类型，因为如果操作数按值传递的话，传递给操作数函数的将是一个对象的副本，两个副本是独立的，不能改变到原对象的值，所以应按引用传递对象，比如hyong operator ++(hyong &a){}。

注意++有前缀和后缀之别，前缀形式是变量先加1然后执行表达式，而后缀形式则是先执行表达式然后再使变量加1，所以在执行后缀的++运算符时应先返回对象的原始值，然后才对对象加1。

//前缀++返回的是左值，即该对象+1之后的引用。后缀++返回是的右值。类似于{ int tmp = a; a=a+1; return tmp;} 并不是先执行表达式再加1 而是返回+1之前的值。可以通过下面的程序印证： int a =5; (++a) = 10;可以通过编译 (a++) = 10;无法通过编译

默认的带有一个参数的++运算符函数是前缀++运算符，要重载后缀的++运算符必须采用另一种方式实现。

重载后缀的++运算符时应给函数多增加一个int参数，该int参数不会使用，应忽略他，该参数只是为了让编译器区分++运算符的前缀和后缀形式之间的区别。比如重载后缀++运算符的友元函数形式为hyong operator ++(hyong &a,int i){}后面的参数int i没有实际意义，应忽略他。

例：重载++运算符的例子

class A

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，因为后缀形式的++运算符是先执行表达式后进行增量运算，所以这里应生成一个临时对象以便返回对象的原始值

++j.b; //注意，因为独立函数既不是类的友元又不是类的成员，所以这里没有this指针，也不能直接访问类的成员。

return t;} //返回对象t，这里会生成一个临时对象。

int main()

{ A m,n,k;

m=++k; //调用前缀形式的++类成员运算符函数，语句等价于m=k.operator ++()；因为前缀的++是类的成员，所以只能用点运算符调用，形如operator ++(k)将是错误的。

cout<表达式，即对象k的值先加，然后再赋给对象m

n=k.operator ++ (); //显示调用前缀的++类成员运算符函数。同m=++k。

cout<

n=k++; //调用后缀形式的独立++运算符函数，该语句等价于n=operator ++(k,1），其中后面的是没有意义的参数，只是为了让编译器区别是前缀还是后缀

cout<表达式后使变量加。

n= operator ++(k,1）； //显示调用后缀的++独立运算符函数，同n=k++。注意整形实参在这里没有实用价值，但必须得有，以便指明是调用的后缀++形式。

cout<

要注意重载二元运算符时如果有形如1+m这种类型的表达式就必须把该操作符函数定义为非类的成员的形式。因为类中的操作符重载函数是最左边的对象是调用该函数的对象

class A

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 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<

k=operator +(m,3）； cout<重载函数是一个函数，只是他的名字比较特别，名字为operator加上后面的操作符而已

k=m+n; //调用类成员操作符函数operator +(const A &j)，实现两个对象相加，这条语句会自动转换为m.operator +(n)的形式调用操作符函数。记住最左边的对象是调用类成员操作符函数的对象。cout<

k=4+m; //调用操作符函数operator +(const int i,const A &j)以实现内置类型和一个对象相加，语句和operator +（3,m)等价。cout<

1． 注意重载赋值运算符和[]，()，->；运算符必须定义为类的成员函数。

2． 注意：如果程序不提供显示的赋值运算符则系统会提供一个默认的赋值运算符。

3． 什么时候重载赋值运算符：当类中含有指针成员时，一般都要重定义类的赋值运算符。

4． 重载赋值运算符时应有处理语句m=m的情况。其中m是某一个类的对象。如果不处理这样的语句有时会出现问题，具体什么问题有待调查。可以用this指针来做处理，比如有语句const A & operator(A &j)则可以用if(this==&j) return *this；这样的语句来处理，即比较当前调用赋值运算符函数的对象的地址和被赋值的对象的地址，如果地直相等说明是同一个对象。

5． 重载赋值运算符时应返回一个对象。因为赋值运算符的左边是一个对象，所以重载赋值运算符应返回一个类的对象，为了避免不必要的开销，最好是返回一个类的对象的引用。

6． 重载赋值运算符时必须是类的成员函数。

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=n; //对象对自已赋值的情况。

cout<

}