一．关于参数类型不是对象的情况：（非成员函数赞。）
类：
主函数：
重点是倒数第二行，
c = 5.6 + b; //如果我只有类里面的+成员函数，这里是没法匹配的。即使我有double转换成Complex的构造函数，依然没法匹配。
要知道，成员函数的+是和左操作数匹配的，5.6是个double型的数据，那么它会想要把右操作数b也转换成double型，再进行计算。这显然是不现实的，首先，我没有写将Complex型转换成double型的函数；再者，复数类转换成double类根本就没有意义，所以这是一种错误的做法。
正确做法：（c = 5.6 + b;）
有三种方法：
1.将 + 运算符的重载从成员函数改成非成员函数，声明为友元。
说明：这样做是调用了非成员的 + 函数，在传参的时候讲double型隐式转换为Complex型（通过double转Complex的构造函数），再进行计算。
2.直接写一个 + 的非成员函数，参数分别为（double，const Complex& ）
说明：这样就根本用不到 double 转Complex的构造函数了，c = 5.6 + b;直接调用这个函数就可以了。但是有一点，比较麻烦，如果像下面这样：
c = 5.6 + b;
c = b + 5.6;
c= a + b;这样岂不是要写三个 + 运算符重载函数？
Complex operator +(double a,const Complex &b){ }
Complex operator +(const Complex &a,double b){ }
Complex operator +(const Complex &a,const Complex &b){ }Complex operator +(double a,const Complex &b){ }
inline Complex operator + (const Complex &a,double b){
return a + b;
}
Complex operator +(const Complex &a,const Complex &b){ }可是这样依然这样太麻烦。
3.转换运算符
说明：对于复数类，不能将double和Complex随意相互切换，因为Complex型的不是都可以转换成double型的。然而对于有的情况，比如RMB类，就可以RMB和double随意相互切换。这时当运算符的参数是(RMB , double )或(double , RMB )，就可以用转换运算符。
在RMB类里面写：
//double转换成RMB
RMB(double value=0.0){
yuan=value;
jf=(value-yuan)*100+0.5;
}
//RMB转换成double
operator double(){
return yuan+jf/100.0;
}不过这有一个缺点：可能或出现转换的二义性。
总结：个人建议用非成员函数进行双目运算符的重载。这样只要写了相应转换类型的构造函数，就不会出问题，而且简洁，一个运算符重载函数就够了。
二．关于运算符重载里面的引用
写两个例子：1.双目运算符 +
（1）成员函数：
Increase Increase::operator + (Increase & s){
Increase result(value+s.value);
return result;
}Increase operator + (Increase & s1,Increase &s2){
Increase result(s1.value+s2.value);
return result;
}参数用了引用：
为什么不直接将s1,s2作为参数呢？注意这里我们是对类的操作。如果参数类型不是引用，那么传参的时候就需要一个对象副本，将实参复制到形参，这种复制是浅复制，并不会为形参分配内存空间，这就导致如果类中有指针类型，形参和实参的指针就指向同一块内存，再调用析构函数时重复delete，出现错误。
当然你可以用指针，但是指针用了之后可读性不佳：
Increase operator + (Increase* s1,Increase* s2)
//调用时
Increase s1(2);
Increase s1(4);
Increase s3 = &s1 + &s2; //读起来像是地址（1）成员函数：
//前置 ++
Increase& Increase::operator ++(){
value++;
return *this;
}
//后置 ++
Increase Increase::operator ++(int ){
Increase old(*this);
value ++;
return old;
}//前置 ++
Increase& operator ++(Increase& s){
s.value++;
return s;
}
//后置 ++
Increase operator ++(Increase& s,int ){
Increase old(s);
s.value ++;
return old;
}前置++返回值用了引用：（为了提高函数效率，减小开销）
因为需要我这个值本身改变，那么用引用传进来，并且返回值就是它本身。用引用返回值则没有返回值的临时副本，从始至终都是它。
如果不用引用返回，那么就会返回一个s的临时副本，虽然可以达到相同的效果，但是增加了不必要的开销，函数效率下降。
后置++返回值没有用引用：（防止局部变量被引用到全局）
后置++其实就是 ++了但是返回的是旧值。那这个值改变了，所以用引用传进来。但是返回的是一个中间值，不是其本身。因为这个中间变量是一个临时变量，是在局部作用域里面，如果用引用返回，是很危险的。所以不能加引用。
3.赋值运算符
例：
#include <iostream>
using namespace std;
class StupidClass {
int flag;
public:
StupidClass(int flag): flag(flag) {
cout << "Constructor " << flag << endl;
}
~StupidClass() {
cout << "Destructor " << flag << endl;
}
StupidClass(const StupidClass& rhs) {
flag=rhs.flag;
cout << "Copy Constructor *this=" << flag << " rhs=" << rhs.flag << endl;
}
StupidClass& operator=(const StupidClass& rhs) {
cout << "Operator = *this=" << flag << " rhs=" << rhs.flag << endl;
return *this;
}
StupidClass& operator+=(const StupidClass& rhs) {
cout << "Operator += *this=" << flag << " rhs=" << rhs.flag << endl;
flag += rhs.flag;
return *this;
}
};
int main() {
StupidClass var1(1), var2(2);
StupidClass var3 = var1 += var2; // 1
//StupidClass &var3 = var1 += var2; // 2
var3=var1;
return 0;
}(1)用语句1
输出结果：
Constructor 1
Constructor 2
Operator += *this=1 rhs=2
Copy Constructor *this=3 rhs=3
Operator = *this=3 rhs=3
Destructor 3
Destructor 2
Destructor 3
(2)用语句2
输出结果：
Constructor 1
Constructor 2
Operator += *this=1 rhs=2
Operator = *this=3 rhs=3
Destructor 2
Destructor 3
返回值都用了引用：
（1）减小不必要的开销（如果不加引用，则会返回临时副本，这没必要，因为自身本来就改变了，且我们需要这个改变了的值）。
（2）另外，防止++出现问题。
说到这里了，就总结下没有引用返回的运算符重载结果的++出现的问题：
1.如果赋值运算符函数返回值不加引用：RMB operator = (RMB & s){
yuan=s.yuan;
jf=s.jf;
}
RMB a(5.2), b (2.6);
(b = a) ++; //结果b=5.2，而不是5.32.前面已说，后置++运算符重载函数返回是不带引用的。
a=5;
(a++)++; //结果a=6与上面同样的道理. 所以不能连续++,达不到想要的效果.
简单总结：就是返回值不带引用的话，返回的是临时副本。
这时需要警戒存不存在把局部变量扩展到全局的问题； 还有就是++的问题。
赋值运算符重载还有一点要注意：
void fn(A & a){
A a1=a; //这是拷贝构造函数，没有调用=运算符函数
A1=a; //这是赋值运算符，没有调用拷贝构造函数。
}