Object Based（基于对象）
- class without pointer menbers
- class with pointer menbers
Object Oriented（面向对象）
- Classes之间的关系
- 继承（inheritance）
- 复合（composition）
- 委托（delegation）
complex类：
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 <cmath> 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__
complex_test.cpp
1 #include <iostream> 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 }
头文件
- 防卫式声明
类设计
- 数据放在private
构造函数
- initialization list 执行速度比{ }中快
- 以什么方式创建对象，怎么想的就写几种构造函数（overloading）
- 同名的函数可以有不止一个，两个real()，一个取得实部，一个设置实部（函数在编译器中的实际名称是函数名+参数名+参数个数）
- complex(double r = 0, double i = 0):re(r),im(i){...}和complex():re(0),im(0){...} 不能同时存在，编译器无法选择
- complex c1;和complex c2(); 含义相同
- 通常情况，构造函数是public的，只有一个例外，单例模式（外界只能用自己类中创建的一份实例）
const member functions（常量成员函数）
- 对不改变数据的函数，在函数名后加const。如：double real() const { return re; }
- 不加的话，使用者用const型数据调用该函数时会出错。如：const complex c1(2,1) ; cout<< c1.real() ;
- const只能修饰输入参数，成员函数省略了this指针，所以const没地方放，只好放在函数体外了
- 在普通的非 const成员函数中，this的类型是一个指向类类型对象的 const指针，可以改变this所指向的值，但不能改变 this所保存的地址
- 在 const成员函数中，this的类型是一个指向 const类类型对象的 const指针。既不能改变 this所指向的对象，也不能改变 this所保存的地址
参数传递 pass by value vs. pass by reference( to const )
- complex ( double r = 0 ; double i = 0 ) 把数据整包传过去，效率较低（此处传一个double和效率和传引用一样，都是4byte） complex c1(2,1);
- complex& operator += ( const complex& ); 传引用，相当于传指针，尽量采用；若希望传递后变量不更改就加const限制 c2 += c1;
- ostream& operator << ( ostream& os, const complex& x){...} 第一个参数没有加const，是因为函数体中会改变os的值
返回值传递 return by value vs. return by reference( to const )
- double real() const { return re; } 传值
- complex& operator += ( const complex& ); 传引用，尽量采用
friend（友元）
- 朋友可以来拿钱（数据）
- 直接拿数据，打破了封装，也可设计为通过函数拿数据
- friend complex& __doapl ( complex*, const complex& ) ;
- inline complex& __doapl( complex* ths, const complex& r ) { ths->re += r.re ; ths->im += r.im; return *ths ; }
相同class的各个objected互为friends
- int func ( const complex& param ) { return param.re + paream.im ; }
- c2.func ( c1 ) ;
class body 外的各种定义
什么时候可以pass by reference，什么时候可以return by reference
- inline complex& __doapl( complex* ths, const complex& r ) { ths->re += r.re ; ths->im += r.im; return *ths ; }
- 两参数相加后，结果放到第一个参数中，第一个参数被改动，第二个不会被改动
- 这种情况能用return by reference，因为函数结束后第一个参数不会消失
- 在函数中创建一个地方放结果，则不能用return by reference，因为函数结束后local变量会消失
操作符重载（成员函数）
- c2 += c1;
- inline compex& complex::operator += ( const complex& r){...}
- 在编译器中的完整形式：inline compex& complex::operator += ( this, const complex& r){...}
- 编译器在执行时，检查类中定义的运算作用在左值上，c2对应this，c1对应r
- this为调用者（“谁”调用的），编译器自动把c2的地址传入this
- 函数嵌套 60-73 便于复用
- doapl为“do assignment plus”即“做赋值加法”的缩写
return by reference 语法分析
- 60声明中返回值为引用，而66中定义为指针：返回object，接收object的引用
- 传递端无需知道接收端的接收方式（在接收端设计）
- 返回类型写void有隐患，导致使用者不能连续赋值如，c3 += c2 += c1 ;
- 其他如 << 和 >> 也有此问题
操作符重载（非成员函数）
- + 写成全局函数，因为会有复数加其他类型数据的情况（一共写了3个+函数）
- c2 = c1 + c2; c2 = c1 + 5; c2 = 7 + c1;
- 全局函数，无this指针
- return by value，因为返回local object
- 临时变量存储+的结果，之前是把右值加到左值，返回左值
- typename(); 创建临时对象，没有名字，下一行就没了
- 正号运算符虽然没改变参数值，但也不能返回&，编译器会报错
- << 必须写成全局，因为标准库只能识别内置数据类型，无法识别object<<cout
- cout是一个object，type是ostream
- 参数ostream前不可加const，因为os在函数中会改变
- 返回值不是void，便于继续接收右边的输出，如：cout<<c1<<conj(c1)
- 返回值ostream前不可加const，因为连续输出时返回值会改变
- 返回值本来就有，不是local的，所以传引用