基础知识
- 基于对象：Object Based 面对的是单一class的设计。
- 面向对象：Object Oriented 面对的是多重classes的设计，涉及到类和类之间的关系。
- 课程中设计到两种不同类设计:没有指针（成员变量）的类和带指针（成员变量）的类设计。
- 头文件一般采用h结尾，源文件一般采用cpp，但是也不一定！（如stl很多没有后缀名）
- 头文件采用防御式声明，采用
#ifndef *** #define *** #endif，避免多次引用。 - 注意声明文件的内容顺序，一般是前置声明、类声明、类定义。（疑问，采用源文件进行类定义，与采用头文件进行类定义有哪些区别）
- 有的函数在类声明时在类的内部直接定义（直接内联），内联只是一种编译提示，是否真的内联取决于函数复杂程度和编译器实现。
- 构造函数的默认参数和初始化列表的使用，初始化列表很重要，和复制不同！能提高程序的初始化性能。
- 构造函数可以有多个重载。
- 如果将构造函数放在private区域，则该类不能在外部构造对象，一般配合设计模式使用，采用工厂模式来构造类，禁止直接构造类的时候使用。例如：定义一个类的静态函数getInstance，该函数返回一个静态的对象。
- 常量成员函数的意义很重要，一般不改变成员变量的函数都声明为常量函数，在函数声明后面添加 const。方便常量对象直接调用。
- 明白参数传递中传值和传引用的意义，传引用与传地址效率一样。在类对象的参数传递中尽可能采用传引用的方式，对于不修改类对象的参数传递尽可能采用常量引用。
- 返回值同样重视传值和传引用，此时注意局部变量考虑到其生命周期，在传引用时要尤其注意，不然会出现野指针。
- 对于友元函数，可以直接访问友元的私有成员变量。相同class的各个对象之间互为友元。
- 关于操作符重载，用于实现带有符号语义的函数，注意其语法要求。
- 对于返回引用的情况，参考对序列化输出和连加连减等操作。
- 明白操作符重载什么时候需要成员函数，什么时候需要非成员函数。
带指针（变量）的类设计
拷贝构造函数、拷贝函数和析构函数
- 三大函数。带指针的类设计一定要重视这三大函数，主要是涉及到危险的指针赋值操作。
堆和栈
- 栈对象（变量）在离开作用域时销毁，调用对象的析构函数。
- 静态栈对象，离开作用于还存在，在整个程序结束的时候析构。
- 全局对象的生命周期，比main函数早存在，在整个生命周期结束之后才结束。
- 堆对象（变量）控制权交给程序员，自己创建（new），自己负责销毁（delete），所以一定要注意指针的赋值（拷贝）操作，容易产生问题，在学习c++11的智能指针后尽可能多使用智能指针。
- 堆对象的生成，使用new，先分配堆空间，再调用构造函数。
new的动作分解：首先分配足够的内存空间，然后将内存进行转型操作，然后调用对象的构造函数void* mem = operator new(sizeof(class));pc = static_cast<class*>(mem);pc->class::class(*); - 堆对象的释放，使用delete，先调用析构函数，然后再释放堆内存。
class::~class(pointer); operatr delete(pointer) - 在String的设计中，在析构函数中调用delete释放字符串。
- 候老师的重点内容，在new复数类（上一课例子），在调试模式下会多得到32个字节，中间是类的大小（两个double），后面还有四个字节，加上一头一尾的小cookie中，一共是8+（32+4）+（4+4）=52个，在vc下分配内存是16的倍数，为64个。为什么？在回收的时候顺利的回收。在relese模式下没有头尾的添加，但是有cookie，8+（4+4）=16。注意小cookie中的地址记录大小和最后一个位比特来表示是借出还是回收。字符串类（String，成员变量只有一个char指针，4比特），在调试模式下4+（32+4）+（4+4）=48，在relese模式下位4+（4+4）=12，变成16的倍数是16。
- 如果分配的是数组：array new对应array delete。
class *p = new class[3];(8X3)+（32+4）+（4X2）+4,最后的加4是VC的做法，用一个整数来记录数组的长度，结果是72，调整到16的倍数为80，其余的模式以此类推。正确的搭配模式下调用array delete时，看到cookie，知道要删除的空间的大小，不会引起内存泄漏，但是会根据记录数组的区域，3次调用析构函数。如果array new不用array delete的话，只会调用一次析构函数，这样剩下的指针所指对象不会调用析构函数。感悟：透彻明了！
字符串String类的实现细节。
- 头文件中添加防卫式定义。
- 字符串里面的类属性，放数组不好因为事先不知道大小，一般放一个指针，大小根据放的内容动态分配；32位平台上一个指针4个byte。
- big three 函数：拷贝构造函数(优先考虑传入引用，不修改变量的值，所以添加const)，拷贝复制函数作为成员函数，在返回时传出引用。析构函数，释放开辟的堆内存。
- 注意String的获取成员变量m_data指针，返回const修辞的char指针。
- 拷贝赋值函数注意首先判断是否是自我赋值。
if(this==&str)return *this;
类模板函数模板
静态static
- 类里面的可以包含static函数和static成员变量
- 每个类对象包含各自的成员变量，一个成员函数要被多个对象调用，需要this指针。
- 对象中静态static成员不变量属于类，只存在一份。（多个对象共用）
- 类的静态函数没有this指针，所以不能访问对象里面的类成员，只能是处理静态数据。
- 静态类成员数据，一定要在类的外面设初值或者叫定义。 注意定义方法
type class::member = ... - 调用static函数的方式有两种，一是通过对象调用，第二种是通过类来调用。
模板技术
template<typename T> class name{};- 编译器会根据不同的参数，生成不同的代码，所以使用类模板可能造成代码的膨胀。
- 了解模板函数的意义和作用处理。
- c++中的算法大量使用模板。
命名空间
- 为避免命名冲突，使用命名空间。（比较简单）
- 命名空间可以分多段定义。
- using namespace *；全开
- using ::;指定打开
组合与继承探讨类与类之间的关系
复合 Composition （has-a）
- （自己的理解）一个类包含（有）另一个类的对象。注意UML类图，采用实心菱形，箭头指向包含的对象，菱形指向包含别人对象的类。
- 适配器模式，一个类调用另外类已有的函数（接口），用来满足新类对接口和名称的要求。
- 从内存的角度来解释复合，层层包含。
- 构造函数之间的关系，container拥有component，外部的构造函数先调用内部的默认构造函数，即构造由内而外。
container：：container(...):compoent（）{……} - 外部的析构函数先执行自己，再调用内部的析构函数，析构由外而内。
container：：~container(...):{……^compoent();}
委托关系（Delegation）按引用的复合
- 一个类包含一个类的指针，UML类图使用空心的菱形代替复合中的实心菱形。Pimpl
- 用指针相连，生命周期就不一致。
- 例子中采用委托实现字符串的引用计数。copy on write
继承 （is-a）
- 一个类从另一个类继承部分属性和方法。
- uml类图，空心三角形指向父类。
- 使用继承，传达一种信息，子类是一种（父类）
- 继承跟虚函数搭配最有价值–重载。
- 从内存的角度来看，子类的对象中有父类的成分。
- 构造由内而外，derived的构造函数首先调用base的默认构造函数。
Derived::Derived(...):Base(){....}; - 析构由外而内，derived的析构函数先执行自己，然后才调用base的析构函数。
Derived::~Derived(...){...~Base();}; - 父类的析构函数必须是虚函数，否则会出现不可预期的情况。
- 非虚函数，你不希望继承的类重新定义（覆盖override）它。
- 虚函数，你希望继承类重新定义（覆盖）它，而且你对它已经有默认定义。
- 纯虚函数，你希望继承类一定要重新定义它。virtual …… = 0；
- 子类对象调用父类的函数，父类的函数中采用虚函数，再调用子类重载的函数。父类中将关键动作延缓到子类中来实现，这种函数的做法叫做Template method，在框架中大量使用。
继承加复合关系下的构造和析构
- 子类从父类继承，子类还包含一个类的对象，构造函数先调用父类构造还是复合的对象？
- 父类包含一个复合对象，子类继承。应该先调用复合构造，父类构造和子类构造。
- 学习文件资源管理类中使用的 Composite 委托加继承的设计方法。
- portotype 设计模式。现在创建未来的类。一个类包含一个静态对象，自身的对象，自己创造了自己。
- 静态成员变量一定记住在类的外面进行定义。
转换函数 conversion function
- 从一种类型转换成另外一种类型，相互转换。
- 定义转换函数：函数不可以有参数，没有返回参数。
operator 转换类型() const {return 类型}
转换函数注意合理性。
non-explicit-one-argument actor
- （一个实参就够了）非explicit的带一个实参的构造函数。从一个实参构建一个对象。可以把别的东西转换成对象。
- 转换函数和non-explicit-one-argument actor在一起的时候，会造成二义性，编译器会报错。
- explicit-one-argument ctor 明确的一参数构造函数，不要不同类型的转换。explicit大部分用在构造函数的前面。
pointer-like classes 关于智能指针
- 像指针的类，比指针再多一些东西。
- 智能指针shared_ptr
- 封装了一个真正的指针，指针所允许的动作该类都支持。
*和->的操作。T& operator*()const { return *px; } T* operator->()const { return px; } - 一个符号作用在对象上就消耗掉了，
->符号除外，得到的指针对象继续用箭头符号。 - 关于标准库STL的迭代器。另外一种类似于指针的类。
reference operator*()const { return (*node).data; }//reference 相当于T&pointer operator->() const { return &(operator*());} //pointer 相当于T*
function-like classes 仿函数
- 函数的特点，函数名称，小括号()-函数调用操作符，可以接受一个小括号作为操作符，那么就可以成为function-like。
const T& operator()(const T& x) const {return x;}- 一定会重载 （）操作。
- 标准库中，仿函数都会去继承奇特的base classes.
namespace 经验谈
- 尽可能使用命名空间，防止变量名和函数名的冲突。
class模板
-
template<typename T> ……T抽象变量类型。
function模板
template<typename T>函数定义
成员模板 member template
- 在模板类中存在一个新的模板，外面的模板是一个允许变化的东西，如果外部变化项确定，里面的变量又可以变化。
- 把两个继承类构成的pair放进一个有两个基类的pair中是可行的。反之不可以。
- 父类的指针可以指向子类的对象。up-cast。
- 智能指针模板为了实现up-cast，必须使用成员模板。
模板特化 specialization
- 泛化，在用的时候进行类型化。
- 设计模板之后，想绑定某种类型，就叫做特例化。指定了特定类型后编译器会根据参数选择相关代码。
partial specialization 偏特化
- 个数上的偏。模板有多个模板参数，对部分参数进行特例化
- 范围上的偏。从任意类型，特例化到指针这一种类型。
template temeplate parameter 模板模板参数
template<typename T, template<typename T> class Container> class XCls{private: Container<T> c;……}XCls<string, list> mylst1; 错误template<typename T> using Lst=list<T, allocator<T>>>; XCls<string, Lst> mylst2; 正确
关于c++标准库
- 数据结构容器和算法。
- 多使用标准库，写小例子测试标准库。
- 测试是否支持c++11,
cout<<__cplausplus <<endl;
三个主题（标准库中的新语法）
- 数量不定的模板参数
- auto关键字。auto自动确定变量类型。
- ranged-base for for（decl: coll）{statement}，注意传值和传引用。
for（auto& elem： vec）{elem*=3;}
对象模型 关于vptr和vtbl
- 虚指针和虚表，一个类的对象内存占用什么样的内存？当一个类有虚函数的时候，对象里面就会多一个指针。一个虚函数和一万个虚函数是一样的。
- 继承会把成员变量继承也会把函数继承下来。
- 一般的函数和虚函数区别。
- 虚拟表中存放的都是指针，虚函数指针。
- 编译器看见调用虚函数时，采用动态绑定。通过虚指针，查看虚表，再看调用的是哪一个函数。（普通函数调用采用动态绑定）
(* p->vptr[n])(p);编译器会找到n的位置编号。 - 静态绑定 call cll……
- 动态绑定，条件1、通过指针调用；2、指针是向上转型 up case；3、调用的是虚拟函数。（多态）
关于this
- 模板方法，this指针的使用场景。会把当前对象当做this指针传到方法里面。一个父类的方法A里面调用了一个虚函数，这个虚函数在子类中重载，这样当子类调用父类的方法A时，会通过父类的A函数，调用子类重载过的虚函数。
- 所有的成员函数都隐藏了一个this参数。
关于 Dynamic Binding
- 非指针调用不会产生动态绑定。
- 通过指针找到虚指针，找到虚表，找到相应的函数地址。
关于const
- 当成员函数的const和non-const版本同事存在是，const object只会（只能）调用const版本，non-const object只会（只能）调用non-const版本。
- const object 调用const 成员函数可行，但是non-const成员函数不可行。
- non-const object 可以调用 const 成员函数，non-const 成员函数。
- non-const 成员函数可以调用const 成员函数，反之则不行。
关于New 和 Delete
- new 先分配 memory，再调用ctor。
- delete 先调用dtor，再释放memory。
- array new，一定要搭配 array delete。
重载 new 和 delete 全局函数（编译器调用）
重载全局 ::new ::new[] ::delete ::delete[]
- inline void* operator new(size_t_size){……分配内存}
- inline void operatpr delete(void* ptr){……释放内存}
- 上面的重载函数不能放在namespace中，是全局的函数，影响是非常大的。
重载成员函数 new 和 delete
- 成员函数 void* operator new（size_t）;
- 成员函数 void operator delete（void*， size_t）;
- 成员函数 void* operator new[]（size_t）;
- 成员函数 void operator delete[]（void*， size_t）;
- 调用函数时添加了::，调用全局的函数，绕过类所定义的new和 delete版本。
- 关于new 和new[]参数的大小。有虚函数的对象对多一个指针的大小4。
- 对象数组[]，对多一个4字节的区域，记录数据的大小是多少。
- 我们可以重载类成员的operator new()，写出多个版本，前提是每个版本的声明都必须有独特的参数列，其中第一个参数必须是size_t，其余参数以new 所指定的placement arguments为初值。出现于new(……)小括号内的便是所谓placement arguments。
- 我们也可以重载类成员operator delete()，写出多个版本，但是绝对不会被delete调用。只有当new所调用的ctor抛出异常，才会调用这些重载的函数operator delete()。它们只能这样被调用，主要用来归还还未完全创造成功的object所占用的memory。即使operatordelete(……)未能一一对应operator new(……)。也不会出现任何报错。
标准库中String使用 new(extra)扩展
- string采用new（extra）进行自己的内存分配，用于实现特定内存结构中引用计数的处理。
引用 reference
int x = 0; int& r = x; sizeof(r) == sizeof(x); &x = &r;- object和其引用的大小相同，地址也相同（全都是假象），java里面的变量都是引用。
- 编译器实现都是使用指针来实现引用，但是在使用时可以从逻辑上把引用当做原值来使用。
- 声明引用的时候一定要有初值。设置完以后不能再变化。指针可以变化。
- 引用的地址和原始类型的地址相同
- 引用通常不用再变量的声明，引用主要用于参数类型（传参数）和返回类型（返回参数）的描述。
- const是不是函数签名的一部分？是
析构和构造函数
继承关系下的构造和析构
- 继承类的构造函数首先调用父类的默认构造函数再执行自己。
- 继承类的析构函数先执行自己再执行父类的析构函数。
复合关系下的构造和析构
- 拥有者的构造函数先调用组件的默认构造函数，然后再执行自己。
- 拥有者析构函数先执行自己，然后才地哦啊用组件的析构函数。
继承加复合关系下的构造和析构
- 继承类的构造函数先执行基类的默认构造函数，然后调用组件的默认构造函数，然后再执行自己。
Derived::Derived(……):Base(), Component(){}; - 继承类的析构函数首先执行自己，然后调用组件的析构函数，然后调用基类的析构函数。
Derived::~Derived(……){……~Component(), ~BAse()}