面向对象高级编程（上）-- 第一周学习笔记（Boolan）
培养正规的、大气的编程习惯
一、C++简介
1，分类
C++分为基于对象和面向对象两种
基于对象是指简单的类定义，数据封装，没有类与类的联系，面对的是单一class的设计。又可细分为不带指针的类和带指针的类
面向对象是指包含类与类之间的联系，面对的是多重class的设计。主要包括继承，复合，委托等。
2，历史和演化
1983年开发
重要版本：C++(98) 1.0 --> C++(03) TR1 --> C++(11) 2.0 --> C++(14)
3，经典书籍
1，《C++ Primer》Fifth Edition ---Stanley B.Lippman ----> C++语言的发明者
2，《The C++ Programming Language》 Fourth Edition ---Bjarne Stroustrup -----> C++第一个编译器的作者
3，《Effective C++》Scott Meyers
4，《Effective C++》中文版 侯捷
5，《The C++ Standard Library》Second Edition --- Nicdlai M.Josuttiy
6，《STL源码剖析》侯捷
二、不成文规范
1，防卫式声明
对于大型程序往往有许多文件，在头文件相互包含时容易造成重复定义，采用以下的宏定义形式可避免重复定义的错误。
#ifndef __COMPLEX__ #define __COMPLEX__ // write your code #endif
2，头文件的布局--三段式
前置声明-类声明-类定义
3，类模板--避免了由于变量类型不同编写大量冗余的代码
1 template<typename T> 2 complex<double> c1(2.5, 1.5) // complex类中的T都替换成double 3 complex<int> c2(2,6) // complex类中的T都替换成int
4，inline
1，简单的函数可在类体中直接定义，默认为inline
2，在类体外定义的函数需要显式声明inline
3，inline只是建议编译器优化，但是对于复杂的函数编译器没有能力优化
5，构造函数 complex(double r = 0, double i = 0):re(r),im(i){}
1，创建对象时，自动调用
2，参数可设置默认值
3，采用初值列初始化，比大括号中赋值效率高，构造函数特有初始化方式
4，没有返回值
6，创建对象的三种方法
1，complex c1(2, 1); // 采用传入的2，1进行初始化
2，complex c2; // 采用默认值0，0进行初始化
3，complex *p = new complex(4); // new申请一块内存空间，返回首地址，采用4，0进行初始化
7，不带指针的类多半不需要析构函数
8，构造函数可以有很多个--重载
反例--以下两个构造函数不可以同时声明,因为假如实例化一个对象complex c1;编译器不知道选择哪一个构造函数
complex(double r = 0, double i = 0):re(r),im(i){} complex():re(0),im(0){}
9，构造函数放在private区域--singleton
1 class A 2 { 3 public: 4 static A& getInstance(); 5 setup(){...} 6 private: 7 A(); 8 A(const A& rhs); 9 ... 10 } 11 12 A& A::getInstance() 13 { 14 static A a; 15 return a; 16 }
10，常量成员函数
如下函数只是取数据而不会改变数据，需要加上const
double real() const {return re;}
如果不加const，说明使用者可以改变re，而使用者在创建对象时加const，说明是常量，不可以改变，前后矛盾，编译会不通过
1 const complex c1(2,1); 2 cout << c1.real(); 3 cout << c1.image();
11，参数传递 pass by value vs. pass by reference (to const)
1，尽量pass by reference (to const)
2，pass by value可能数据量大，传输速度慢
3，pass by reference传输的是一个指针，传输速度快
4，传引用一旦被修改会影响到原变量，此时加const表示不可以修改
complex& operator += (const complex&);
12，返回值传递 return by value vs. return by reference (to const)
1，尽量return by reference (to const)
13，友元--直接拿数据
1，缺点：破坏了封装性
2，优点：获取数据更快
3，疑问：第四讲26:50
侯杰老师讲友元函数破坏了封装性但是获取数据更快，所以doapl设置成了friend，我在想doapl如果只是在类的方法里调用的话，doapl设置成private是不是更好呢，既不破坏封装性又可以直接拿数据 （直接拿数据的意思是直接使用re，im）
Ans：由于其他地方也有可能用到
14，相同class的各个objects互为友元
1 public: 2 int func(const complex& param) 3 { return param.re + param.im } 4 usage: 5 { 6 complex c1(2,1); 7 complex c2; 8 c2.func(c1); 9 }
15，指导原则
1，数据都放在private里
2，参数尽可能传reference
3，返回值尽可能传reference
4，参数考虑是否加const
5，构造函数使用初始列
16，什么情况下可以使用 return by reference
函数外部传入的变量返回可以使用，函数内部定义的变量返回不可以使用，关键点在于变量的作用域，函数内部的变量执行完成被销毁了就不存在地址了
1 inline complex& // 接受的是value的地址 2 __doapl(complex* ths, const complex& r) // 传递者无需知道接收者是以reference形式接受 3 { 4 ths->re += r.re; 5 ths->im += r.im; 6 return *ths; // 返回的是value 7 } 8 inline complex& 9 complex::operator += (const complex& r) 10 { 11 return __doapl(this, r); 12 }
17，操作符重载
1，成员函数--所有的成员函数都带着一个隐藏的参数this，指向调用者
此处返回值可以是void，但是不适用于c1 += c2 += c3
1 inline complex& 2 complex::operator += (const complex& r) 3 { 4 return __doapl(this, r); 5 }
2，非成员函数
1 c2 = c1 + c2; 2 inline complex 3 operator + (const complex& x, const complex& y) 4 { 5 return complex(real(x) + real(y),imag(x)+imag(y)); 6 } 7 c2 = c1 + 5; 8 inline complex 9 operator + (const complex& x, double y) 10 { 11 return complex(real(x) + y, imag(x)); 12 } 13 c2 = 7 + c1; 14 inline complex 15 operator + (double x, const complex& y) 16 { 17 return complex(x + real(y), imag(y)); 18 }
此处返回值类型绝对不可以是reference,由于不是外部传入的变量
创建临时对象complex(),下一行即失效---typename()
定义成非成员函数，int+c1调用的是double+c2的情况，int自动类型转换为double
当我们把运算符定义成成员函数时，它的左侧运算对象必须是运算符所属类的一个对象
-----------------------------------------------------------------------------------------------------------------------
内置类型里面+通常设计成非成员函数，+=通常设置成成员函数。我们自定义类型的时候，
+=和+模仿内置类型会符合用户一直以来的习惯
