一、笔记
1.C++编程简介
2.头文件与类的声明
防卫式声明
#ifndef __COMPLEX__
#define __COMPLEX__
……
#endif
头文件的布局
模板简介
template
3.构造函数
inline函数：函数若在class body内定义完成，便自动成为inline候选人
访问级别：
public private
被外部访问的函数设为public
构造函数
complex (doble r=0,double i=0)
:re(r),im(i)
{ }
先初始化，后赋值
这种写法效率高
构造函数可以有很多个——重载
单例模式，构造函数放在private里，不允许外部创
4.参数传递与返回值
在函数后头加const
double real () const{return re;}
参数传递： pass by value vs. pass by reference(to const)
参数尽量传引用，如果不希望对方改加const
内化成习惯
返回值传递：return by value vs. return by reference(to const)
返回值也尽量传引用
friend（友元）
自由取得friend的private成员
相同class的各个objects互为friends（友元）
class body外的各种定义
什么情况可以传和返回引用，什么情况不可以：
两个参数相加，得到一个新的结果时不能传引用
5.操作符重载与临时对象
操作符重载之一，成员函数
操作符重载之二，非成员函数
临时对象
重载<<
二、代码
1.complex.h
1 #ifndef __MYCOMPLEX__
2 #define __MYCOMPLEX__
3
4 class complex;
5 complex&
6 __doapl (complex* ths, const complex& r);
7 complex&
8 __doami (complex* ths, const complex& r);
9 complex&
10 __doaml (complex* ths, const complex& r);
11
12
13 class complex
14 {
15 public:
16 complex (double r = 0, double i = 0): re (r), im (i) { }
17 complex& operator += (const complex&);
18 complex& operator -= (const complex&);
19 complex& operator *= (const complex&);
20 complex& operator /= (const complex&);
21 double real () const { return re; }
22 double imag () const { return im; }
23 private:
24 double re, im;
25
26 friend complex& __doapl (complex *, const complex&);
27 friend complex& __doami (complex *, const complex&);
28 friend complex& __doaml (complex *, const complex&);
29 };
30
31
32 inline complex&
33 __doapl (complex* ths, const complex& r)
34 {
35 ths->re += r.re;
36 ths->im += r.im;
37 return *ths;
38 }
39
40 inline complex&
41 complex::operator += (const complex& r)
42 {
43 return __doapl (this, r);
44 }
45
46 inline complex&
47 __doami (complex* ths, const complex& r)
48 {
49 ths->re -= r.re;
50 ths->im -= r.im;
51 return *ths;
52 }
53
54 inline complex&
55 complex::operator -= (const complex& r)
56 {
57 return __doami (this, r);
58 }
59
60 inline complex&
61 __doaml (complex* ths, const complex& r)
62 {
63 double f = ths->re * r.re - ths->im * r.im;
64 ths->im = ths->re * r.im + ths->im * r.re;
65 ths->re = f;
66 return *ths;
67 }
68
69 inline complex&
70 complex::operator *= (const complex& r)
71 {
72 return __doaml (this, r);
73 }
74
75 inline double
76 imag (const complex& x)
77 {
78 return x.imag ();
79 }
80
81 inline double
82 real (const complex& x)
83 {
84 return x.real ();
85 }
86
87 inline complex
88 operator + (const complex& x, const complex& y)
89 {
90 return complex (real (x) + real (y), imag (x) + imag (y));
91 }
92
93 inline complex
94 operator + (const complex& x, double y)
95 {
96 return complex (real (x) + y, imag (x));
97 }
98
99 inline complex
100 operator + (double x, const complex& y)
101 {
102 return complex (x + real (y), imag (y));
103 }
104
105 inline complex
106 operator - (const complex& x, const complex& y)
107 {
108 return complex (real (x) - real (y), imag (x) - imag (y));
109 }
110
111 inline complex
112 operator - (const complex& x, double y)
113 {
114 return complex (real (x) - y, imag (x));
115 }
116
117 inline complex
118 operator - (double x, const complex& y)
119 {
120 return complex (x - real (y), - imag (y));
121 }
122
123 inline complex
124 operator * (const complex& x, const complex& y)
125 {
126 return complex (real (x) * real (y) - imag (x) * imag (y),
127 real (x) * imag (y) + imag (x) * real (y));
128 }
129
130 inline complex
131 operator * (const complex& x, double y)
132 {
133 return complex (real (x) * y, imag (x) * y);
134 }
135
136 inline complex
137 operator * (double x, const complex& y)
138 {
139 return complex (x * real (y), x * imag (y));
140 }
141
142 complex
143 operator / (const complex& x, double y)
144 {
145 return complex (real (x) / y, imag (x) / y);
146 }
147
148 inline complex
149 operator + (const complex& x)
150 {
151 return x;
152 }
153
154 inline complex
155 operator - (const complex& x)
156 {
157 return complex (-real (x), -imag (x));
158 }
159
160 inline bool
161 operator == (const complex& x, const complex& y)
162 {
163 return real (x) == real (y) && imag (x) == imag (y);
164 }
165
166 inline bool
167 operator == (const complex& x, double y)
168 {
169 return real (x) == y && imag (x) == 0;
170 }
171
172 inline bool
173 operator == (double x, const complex& y)
174 {
175 return x == real (y) && imag (y) == 0;
176 }
177
178 inline bool
179 operator != (const complex& x, const complex& y)
180 {
181 return real (x) != real (y) || imag (x) != imag (y);
182 }
183
184 inline bool
185 operator != (const complex& x, double y)
186 {
187 return real (x) != y || imag (x) != 0;
188 }
189
190 inline bool
191 operator != (double x, const complex& y)
192 {
193 return x != real (y) || imag (y) != 0;
194 }
195
196 #include
197
198 inline complex
199 polar (double r, double t)
200 {
201 return complex (r * cos (t), r * sin (t));
202 }
203
204 inline complex
205 conj (const complex& x)
206 {
207 return complex (real (x), -imag (x));
208 }
209
210 inline double
211 norm (const complex& x)
212 {
213 return real (x) * real (x) + imag (x) * imag (x);
214 }
215
216 #endif //__MYCOMPLEX__
2.complex_test.cpp
1 #include
2 #include "complex.h"
3
4 using namespace std;
5
6 ostream&
7 operator << (ostream& os, const complex& x)
8 {
9 return os << '(' << real (x) << ',' << imag (x) << ')';
10 }
11
12 int main()
13 {
14 complex c1(2, 1);
15 complex c2(4, 0);
16
17 cout << c1 << endl;
18 cout << c2 << endl;
19
20 cout << c1+c2 << endl;
21 cout << c1-c2 << endl;
22 cout << c1*c2 << endl;
23 cout << c1 / 2 << endl;
24
25 cout << conj(c1) << endl;
26 cout << norm(c1) << endl;
27 cout << polar(10,4) << endl;
28
29 cout << (c1 += c2) << endl;
30
31 cout << (c1 == c2) << endl;
32 cout << (c1 != c2) << endl;
33 cout << +c2 << endl;
34 cout << -c2 << endl;
35
36 cout << (c2 - 2) << endl;
37 cout << (5 + c2) << endl;
38
39 return 0;
40 }