C++多态性——运算符重载

1、在类外定义的运算符重载函数

例如重载运算符+：

#include<iostream>
using namespace std;
//定义一个复数类
class Complex 
{
public:
	double real;//实部
	double imag;//虚部
	Complex(double r = 0, double i = 0) //构造函数（初始化）
	{
		real = r;
		imag = i;
	}
};
//定义运算符+的重载函数（针对复数类对象的）
Complex operator+(Complex co1, Complex co2) 
{
	Complex temp;
	temp.real = co1.real + co2.real;//实部相加
	temp.imag = co1.imag + co2.imag;//虚部相加
	return temp;
}
//主函数里调用
int main()
{
	Complex com1(1, 2), com2(3, 4), sum1, sum2;
	//以下两种调用方式均可
	sum1 = com1 + com2;
	sum2 = operator+(com1, com2);
	cout << "real=" << sum1.real << endl << "imag=" << sum1.imag << endl;
	return 0;
}

运行结果：

real=4
imag=6

2、友元运算符重载函数

（PS:某个类的友元函数可以访问该类的对象的私有成员）

a.双目运算符重载

例如重载运算符+

#include<iostream>
using namespace std;
//定义一个复数类
class Complex
{
public:
	Complex(double r = 0, double i = 0)
	{
		real = r;
		imag = i;
	}
	friend Complex operator+(Complex co1, Complex co2);//声明运算符+的重载函数
	void display()//显示复数
	{
		cout << real;
		if (imag > 0) cout << "+";
		if (imag != 0) cout << imag << "i" << endl;
	}
private:
	double real;//实部
	double imag;//虚部
};
Complex operator+(Complex co1, Complex co2)//定义运算符+的重载函数
{
	Complex temp;
	temp.real = co1.real + co2.real;
	temp.imag = co1.imag + co2.imag;
	return temp;
}
int main()
{
	Complex com1(1, 2), com2(3, 4), sum1, sum2;
	//以下两种方式均可调用
	sum1 = com1 + com2;
	sum2 = operator+(com1, com2);
	sum1.display();
	return 0;
}

结果：

4+6i

b.单目运算符重载

例如：重载运算符前缀++

#include<iostream>
using namespace std;
//定义一个复数类
class Complex
{
public:
	Complex(double r = 0, double i = 0)
	{
		real = r;
		imag = i;
	}
	friend Complex operator++(Complex &com);//声明运算符(++p)的重载函数
	void display()//显示复数
	{
		cout << real;
		if (imag > 0) cout << "+";
		if (imag != 0) cout << imag << "i" << endl;
	}
private:
	double real;//实部
	double imag;//虚部
};
//定义运算符(++p)的重载函数
Complex operator++(Complex &com)
{	
	++com.real;
	++com.imag;
	return com;
}
int main()
{
	Complex com1(1, 2), com2(3, 4);
	//以下两种方式均可调用
	++com1;
	operator++(com2);
	com1.display();
	com2.display();
	return 0;
}

结果：

2+3i
4+5i

3、成员运算符重载函数

a.双目运算符重载

（PS：是成员函数的情况下，参数表中只有一个操作数）
例如：重载运算符+

#include<iostream>
using namespace std;
//定义一个复数类
class Complex
{
public:
	Complex(double r = 0, double i = 0)
	{
		real = r;
		imag = i;
	}
	Complex operator+(Complex c);//声明运算符+的重载函数
	void display()//显示复数
	{
		cout << real;
		if (imag > 0) cout << "+";
		if (imag != 0) cout << imag << "i" << endl;
	}
private:
	double real;//实部
	double imag;//虚部
};
//定义运算符+的重载函数
Complex Complex::operator+(Complex c)
{	
	Complex temp;
	temp.real = real + c.real;       //在类的成员函数中可以访问同类型对象的私有数据（比如这里的c.real、temp.real...）
	temp.imag = imag + c.imag;        
	return temp;
}
int main()
{
	Complex com1(1, 2), com2(3, 4),sum1,sum2;
	//以下两种方式均可调用
	sum1 = com1 + com2;
	sum2 = com1.operator+(com2);
	sum1.display();
	sum2.display();
	return 0;
}

结果：

4+6i
4+6i

b.单目运算符重载

（PS：是成员函数的情况下，参数表中没有操作数）
例如：重载运算符前缀++

#include<iostream>
using namespace std;
//定义一个复数类
class Complex
{
public:
	Complex(double r = 0, double i = 0)
	{
		real = r;
		imag = i;
	}
	Complex operator++();//声明运算符(++p)的重载函数
	void display()//显示复数
	{
		cout << real;
		if (imag > 0) cout << "+";
		if (imag != 0) cout << imag << "i" << endl;
	}
private:
	double real;//实部
	double imag;//虚部
};
//定义运算符(++p)的重载函数
Complex Complex::operator++()
{	
	++real;
	++imag;
	return *this;
}
int main()
{
	Complex com1(1, 2), com2(3, 4);
	//以下两种方式均可调用
	++com1;
	com2.operator++();
	com1.display();
	com2.display();
	return 0;
}

结果：

2+3i
4+5i

补充：前置++（–）与后置++（–）

a. 前置
声明：类 operator++();
调用：++对象; 或 对象.operator++();
b. 后置
声明：类 operator++(int);
调用：对象++; 或 对象.operator(0);
以成员函数为例：

#include<iostream>
using namespace std;
//定义一个复数类
class Complex
{
public:
	Complex(double r = 0, double i = 0)
	{
		real = r;
		imag = i;
	}
	Complex operator++();//声明运算符(++p)的重载函数
	Complex operator++(int);//声明运算符(p++)的重载函数
	void display()//显示复数
	{
		cout << real;
		if (imag > 0) cout << "+";
		if (imag != 0) cout << imag << "i" << endl;
	}
private:
	double real;//实部
	double imag;//虚部
};
//定义运算符(++p)的重载函数
Complex Complex::operator++()
{	
	++real;
	++imag;
	return *this;//返回自加后的当前对象
}
//定义运算符(p++)的重载函数
Complex Complex::operator++(int)
{
	Complex temp(*this);//拷贝一份自加前的对象
	++real;
	++imag;
	return temp;//返回自加前的当前对象
}
int main()
{
	Complex com1(1, 2),com2(1,2),temp1,temp2;
	temp1 = ++com1;//前置++
	temp2 = com2++;//后置++
	//显示
	cout << "temp1 = ";
	temp1.display();
	cout << "com1 = ";
	com1.display();

	cout << "temp2 = ";
	temp2.display();
	cout << "com2 = ";
	com2.display();
	return 0;
}

结果：

temp1 = 2+3i
com1 = 2+3i
temp2 = 1+2i
com2 = 2+3i