运算符重载

运算符重载的两种方法

有两种方法可以使运算符重载：一是使重载运算符成为该类的成员函数，这允许运算符函数访问类的私有成员，它也允许函数使用隐式的this指针形参来访问调用对象；二是使重载的成员函数成为独立分开的函数，当以这种方式重载时，运算符函数必须声明为类的友元才能访问类的私有成员。某些运算符（如流输入运算符>>和流输出运算符<<）必须作为独立函数重载，其他运算符既可以作为成员函数也可以作为独立函数重载。以Complex类的+运算符为例，重载为成员函数的形式为：

class Complex {
    int real, image;
   public:
    Complex(int r = 0, int i = 0) : real(r), image(i) {};
    Complex operator+(const Complex& c);  // 成员函数形式重载"+"
};
Complex Complex::operator+(const Complex& c) {  // 具体实现
    return Complex(real + c.real, image + c.image);
}

重载为友元函数的形式为：

class Complex {
	int real,image;
   public:
    Complex(int r = 0, int i = 0) : real(r), image(i) {};
	friend Complex operator+(const Complex& c, const Complex& c2);  // 友元函数形式重载"+"
};
Complex operator+(const Complex& c, const Complex& c2) {  // 具体实现 
	return Complex(c.real+c2.real, c.image+c2.image);
}

运算符重载比函数重载多了一个operator关键字，重载为成员函数时有一个参数为类对象本身，而重载为外部函数（友元或者普通函数）时需要将所有参数写出来。

返回类型 operator 运算符（参数列表）{    
    // 实现
}
 
或者重载为成员函数形式： 
返回类型 所在类的类名::operator 运算符（参数列表）{
    // 实现
}

其中参数列表根据重载的运算符定，例如二元运算符重载为友元函数时需要两个参数（两个操作数），重载为成员函数时需要一个参数（另一个参数是该类对象本身）。一般来说，更好的做法是将二元运算符重载为釆用相同类型形参的独立函数。这是因为，与独立运算符的重载不同，成员函数的重载通过使左侧形参变成隐式的，造成了两个形参之间的人为区别，这将允许转换构造函数应用右侧形参，但不应用左侧形参，从而产生了更改形参顺序的情况，导致正确的程序如果换个方式却出现了编译器错误。示例如下：

void main() {
    Complex a(1, 2), b(3, 4), c(0, 0);
    c = a + b;  // 1、运算符重载为友元函数时，相当于 c = operator+(a, b);
                // 2、运算符重载为成员函数时，相当于 c = a.operator+ (b);
    c = a + 2;  // 1、运算符重载为友元函数时，相当于 c = operator+(a, 2); 
                // Complex类的转换构造函数能够为整数形参2创建一个Complex对象。
                // 2、运算符重载为成员函数时，相当于 c = a.operator+ (2);
                // Complex类的转换构造函数能够为整数形参2创建一个Complex对象。
    c = 2 + a;  // 1、运算符重载为友元函数时，能编译，相当于 c = operator+(2, a);
                // 2、运算符重载为成员函数时，不能编译，相当于 c = 2.operator+(a);
}

如果重载一元运算符-（一元的“-”意为取负，不是相减运算符）：

class Complex{
	int real, image;
   public:
    Complex(int r, int i) : real(r), image(i) {};
	friend Complex operator+(const Complex& c, const Complex& c2);  // 友元函数形式重载"+" 
	Complex operator-();  // 重载取负运算符
};
 
Complex operator+(const Complex& c, const Complex& c2) {  // 具体实现 
	return Complex(c.real + c2.real, c.image + c2.image);
}
Complex Complex::operator-() {  // 具体实现 
	return Complex(-real, -image);
}
int main() {
	Complex c1(1, 2);
	Complex c3 = -c1;  // 则“-c1”会被处理成“c1.operator-()”，友元函数形式则是“operator-(c1)”。
	return 0;
} 

那么自增和自减运算符又怎样重载？以自增为例，自减同理。自增又分为前置自增和后置自增，C++规定前置自增重载形式为operator++(void)，后置自增重载为operator++(int)，这是成员函数重载形式，友元函数重载则是operator++(const Complex& c)和operator++(const Complex& c, int)。这两种写法分别是前置和后置自增运算符的重载写法，后置++使用一个int参数来与前置++区分。下面给出重载为成员函数的自增运算符写法，请注意对比前置++和后置++的实现和返回值类型：

#include <iostream>
using namespace std;
class Complex {
    int real, image;
   public:
    Complex(int r = 0, int i = 0) : real(r), image(i) {};
    friend Complex operator+(const Complex& c, const Complex& c2);  // 友元函数形式重载"+"
    Complex operator-();                                            // 重载取负运算符
    Complex& operator++();    // 前置++
   Complex operator++(int);  // 后置++
   void show();              // 测试用，输出整个虚数
};

void Complex::show() {
    cout << real << " + " << image << "i" << endl;
}
Complex operator+(const Complex& c, const Complex& c2) {  // 具体实现
    return Complex(c.real + c2.real, c.image + c2.image);
}
Complex Complex::operator-() {  // 具体实现
    return Complex(-real, -image);
}
Complex& Complex::operator++() {  // 前置++实现
    cout << "前置++" << endl;
    real++;
    image++;
    return *this;
}
Complex Complex::operator++(int) {  // 后置++实现
    cout << "后置++" << endl;
    Complex tmp = *this;
    real++;
    image++;
    return tmp;
}

int main() {
    Complex c;
    c.show();
    // 测试前置++
    ++c;
    c.show();
    // 测试后置++
    Complex c2 = c++;
    c.show();
    c2.show();
    return 0;
}

习惯上来说，前置++应该返回一个左值，应该返回原对象的引用，而后置++则会返回一个未修改前的副本，应该直接返回一个对象，让C++去创建副本返回。类比C++本身的自增运算符，例如对一个int变量分别使用前置++和后置++，可以知道前置++是可以作为左值的，而后置++是不可以作为左值的（后置++返回的是一个临时变量，是不可寻址的，所以不能其赋值），设计Complex类的时候也应该考虑到这些问题。运算符重载只能和自定义类型一起使用，即参数里至少要有一个是类对象，例如试图重载整数运算的+是不被允许的：

int operator+(int a, int b) {
    return a-b; 
}

除上述特别说明的运算符之外的运算符，可以重载为类的成员函数、友元函数、普通的类外函数，不可重载为静态函数。要注意的是，在重载运算符时应该仔细斟酌返回值类型，例如在重载=时，应该返回赋值后的对象的引用，这样就可以实现连续赋值。=运算符系统会帮我们自动生成，当类成员里有指针的时候，系统实现的=只会帮我们把所有成员变量原封不动地赋值，赋值完毕后，=左右两边的对象都指向同一块内存，当其中一个对象先销毁，另一个对象再销毁的时候就会造成重复释放内存的问题，遇到这种情况我们应该自己手动实现一个=的重载，为新对象的指针申请独立的内存，并把内容拷贝过来。此外，还要注意c1 = c1这种写法，在处理=运算符时我们应该先判断一下=左右两边的对象是否相等，相等就直接返回原对象的引用。还要注意的是，在重载=运算符的时候，如果对象本身带有指向用new申请的内存的指针成员变量，要注意“被覆盖的对象 的成员指针内存的销毁问题”，这句话听起来好像有点难懂，其实就是当我们写出c1 = c2这样的代码时，c1对象的成员变量里如果带有用new申请内存的指针变量的话，要注意先释放再赋值，否则会导致内存泄露。