运算符重载

运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算，也就是说，运算符重载是通过定义函数实现的。

运算符重载实质上是函数的重载。

 

运算符重载的函数一般格式如下：

函数类型  operator  运算符名称 （形参表列）

{对运算符的重载处理}

 

C++不允许用于自己定义新的运算符，只能对已有的C++运算符进行重载

C++绝大部分的运算符允许重载。不能重载的运算符只有5个：

. (成员访问运算符）

.* (成员指针访问运算符）

:: （域运算符）

sizeof (长度运算符）

？：（条件运算符）

 

重载不能改变运算符运算对象的个数。

重载不能改变运算符的优先级别。

重载不能改变运算符的结合性。

重载运算符的函数不能有默认的参数。（否则就改变了运算符的运算对象的个数

重载的运算符必须和用户定义的自定义类型的对象一起使用，其参数至少应有一个对象（或对象的引用）。//防止修改C++标准类型的运算符性质

用于类对象的运算符一般必须重载，但是=和&不必重载(当=用于实现深copy时需要重载）

应使重载运算符的功能类似于该运算符作于标准类型数据所实现的功能

运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数也不是类的友元函数的普通函数

 

重载运算符的时候，可以将普通函数定义为一个类的友元函数，或者定义一个类的成员函数。

运算符重载的例子：

#include <iostream>
using namespace std;

class complex {
public:
	complex(int x = 0, int y = 0) {
		this->x = x;
		this->y = y;
	}
public:
	friend ostream& operator<<(ostream &s, complex &c);
	complex operator+(complex &c2) {  //利用成员函数实现运算符重载
		x += c2.x;
		y += c2.y;
		return *this;
	}
	
private:
	int x;
	int y;
};

ostream& operator<<(ostream &s,complex &c) {  //利用友元函数实现运算符重载
	s << "complex is:" << c.x << "+" << c.y << endl;
	return s;
}

int main() {
	complex c1(1, 2);
	complex c2(2, 3);
	complex c3 = c1 + c2;
	cout << c3;
	system("pause");
}

 c1+c2 实际上就等于是 c1.operator+(c2);

 

但是，在重载<< >>操作符的时候，只能通过友元函数的方法。（<<运算符的调用实际上是cout.operator<<(),ostream类的对象调用方法，我们无法将这个函数定义为ostream类的成员函数，只能定义一个普通函数，然后声明为友元函数，返回一个引用）

一个例子：

#include <iostream>
using namespace std;

class Array {  //这个数组类就像是一个顺序表
public:
	Array(int n);
	Array(Array &b);
	~Array();
	friend istream& operator>>(istream &in, Array &a);
	friend ostream& operator<<(ostream &out, Array &a);
	Array& operator=(Array &b);
	int& operator[](int i);
private:
	int *elem;
	int length;
};

Array::Array(int n) { //构造
	elem = new int[n];
	length = n;
}

Array::~Array() { //析构
	delete[] elem;
	length = 0;
}

Array::Array(Array &b) { //copy构造
	elem = new int[b.length];
	length = b.length;
	for (int i = 0;i < length;i++) {
		elem[i] = b.elem[i];
	}
}

istream& operator>>(istream &in, Array &a) {  //返回引用可以链式调用
	for (int i = 0;i < a.length;i++)
		in >> a.elem[i];
	return in;
}

ostream& operator<<(ostream &out, Array &a) {
	for (int i = 0;i < a.length;i++)
		out << a.elem[i];
	return  out;

}


Array& Array::operator=(Array &b) { //重载 =  运算符,对数组进行复制
	if (elem) {
		delete[] elem;
		length = 0;
	}
	elem = new int[b.length];
	length = b.length;
	for (int i = 0;i < length;i++) {
		elem[i] = b.elem[i];
	}
	return *this;
}

int& Array::operator[](int i) {
	return elem[i];
}

int main() {
	Array a(5);
	cin >> a;
	/*Array b = a;
	cout << b;
	*/
	a[3] = a[4];
	cout << a[3];
	system("pause");
	return 0;

}