C++ 操作符重载(2) 复数加减乘除

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

类定义如下:

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. }