源码

（因为是昨晚写的，分析过程忘了，大家就直接看源码好了，反正还蛮简单的hhh）

#include <iostream>
using namespace std;
class complex
{
public:
	complex(int i = 0, int j = 0) :a(i), b(j) {}
	~complex() {};
	complex operator+(complex y)
	{
		complex temp;
		temp.a = a + y.a;
		temp.b = b + y.b;
		return temp;
	}
	complex operator-(complex y)
	{
		complex temp;
		temp.a = a - y.a;
		temp.b = b - y.b;
		return temp;
	}
	complex operator*(complex y)
	{
		complex temp;
		temp.a = a * y.a - b * y.b;
		temp.b = a * y.b + b * y.a;
		return temp;
	}
	complex operator/(complex y)
	{
		complex temp;
		temp.a = (a * y.a + b * y.b) / (y.a * y.a + y.b * y.b);
		temp.b = (b * y.a + a * y.b) / (y.a * y.a + y.b * y.b);
		return temp;
	}
	void getcomplex(float& aa, float& bb)
	{
		aa = a;
		bb = b;
	}

private:
	float a, b;
};
ostream& operator<<(ostream& os, complex& s)
{
	float a, b;
	s.getcomplex(a, b);
	os << a << "+" << b << "i";
	return os;
}
int main()
{
	complex x(1,1),y(1,1),z;
	z = x + y;
	cout << z << endl;
	z = x - y;
	cout << z << endl;
	z = x * y;
	cout << z << endl;
	z = x / y;
	cout << z << endl;
	return 0;
}

复数由实部和虚部组成 复数间的运算通过实部和虚部,我们构建一个复数类来模拟复数间的操作

类定义如下:

1. //复数的运算
2. class Complex {
3. private:
4. int real; //复数的实部
5. int image; //复数的虚部
6. public:
8. void myPrint() {
9. cout << this->real << " " << this->image << "i" << endl; //显示复数
10. }
12. Complex( int real= 0, int image= 0) { //构造函数
13. this->real = real;
14. this->image = image;
15. }

加号的重载:

1. //重载加号
2. Complex operator+( const Complex &obj) {
3. Complex res;
4. res.real = this->real + obj.real;
5. res.image = this->image + obj.image;
6. return res;
7. }

1)为了能实现操作符重载,至少得有一个对象是用户自定义的对象,如上述加号重载是基于Complex类对象

2)赋值操作符: 编译器会自动的给每个类创建一个默认的赋值操作符。它会将所有成员从右边赋给左边，大多数情况下可以正常工作(不正常的地方与拷贝构造一样)。

全局运算符重载函数:

运算符函数与普通函数一样。唯一的不同在于，运算符函数的名字通常由operator关键字加上运算操作符组成。

我们可以把操作符函数定义为全局的

1. Complex operator * ( const Complex &obj1, const Complex &obj2) {
2. Complex res;
3. res.real = obj1.real * obj2.real;
4. res.image = obj1.image * obj2.image;
5. return res;
6. }

friend Complex operator * (const Complex &obj1, const Complex &obj2);

类型转换的重载:

我们可以自定义类型转换操作符,把一个类型转换成另一个类型

1. operator float() const {
2. return float( this->real) / float( this->image);
3. }

1. float val = C;
3. cout << val << endl;

整个程序如下:

1. #include<iostream>
2. using namespace std;
5. //复数的运算
6. class Complex {
7. private:
8. int real; //复数的实部
9. int image; //复数的虚部
10. public:
12. void myPrint() {
13. cout << this->real << " " << this->image << "i" << endl; //显示复数
14. }
16. Complex( int real= 0, int image= 0) { //构造函数
17. this->real = real;
18. this->image = image;
19. }
21. //重载加号
22. Complex operator+( const Complex &obj) {
23. Complex res;
24. res.real = this->real + obj.real;
25. res.image = this->image + obj.image;
26. return res;
27. }
30. //重载减号
31. Complex operator-( const Complex &obj) {
32. Complex res;
33. res.real = this->real - obj.real > 0 ? this->real - obj.real : 0;
34. res.image = this->image - obj.image > 0 ? this->image - obj.image : 0;
35. return res;
36. }
38. //重载乘号
39. //使全局函数可以使用私有的类
40. friend Complex operator * ( const Complex &obj1, const Complex &obj2);
42. operator float() const {
43. return float( this->real) / float( this->image);
44. }
47. };
50. //全局的乘号重载
51. Complex operator * ( const Complex &obj1, const Complex &obj2) {
52. Complex res;
53. res.real = obj1.real * obj2.real;
54. res.image = obj1.image * obj2.image;
55. return res;
56. }
60. int main() {
62. Complex A(10, 20);
63. Complex B(20, 30);
65. A.myPrint();
66. cout << endl << endl;
67. B.myPrint();
68. cout << endl << endl;
70. Complex C = A + B; //重载的加号
71. C.myPrint();
73. C = B - A; //重载的减号
74. C.myPrint();
76. C = B * A; //重载的乘号
77. C.myPrint();
79. float val = C;
81. cout << val << endl;
83. system( "PAUSE");
84. return 0;
85. }