十六 对象模型：关于vptr和vtbl
如图模型所示，B类继承A类，C类继承B类，子类有父类的成分，继承的包括数据、非虚函数和虚函数。当类里面有虚函数，无论多少数量，会多一个指针，如图vptr（虚指针），指向vtbl（虚函数表）。虚函数的调用是通过虚函数表实现，无论子类是否要重写函数。
有一个指针p指向c（new c），通过p调用vfunc1（），先调用虚函数表，在虚函数表上找到对应编号的函数，实现调用，这种方式叫做动态绑定。解析成c语言的形式如下：
（*（p->vptr）[n]）（p）； //n是在虚函数表中函数的编号，根据你写的代码的顺序排
//或者
（* p->vptr[n]）（p）；
（1）如图左下角实现不同形状的draw（），1.将指向A（shape类）的指针放到容器里面；2.将draw（）写成虚函数；3.具体形状类（例如rect类）继承抽象类shape。
注：为了让容器容纳各种各样的形状，容器里面放的是指针，因为容器里面数据类型必须一致，指针必须指向父类，这样声明的时候指向父类，用的时候就可以指向子类。
（2）对比c语言的实现方法，c语言是先判断哪一种形状，然后调用其draw（）函数，这样写要添加某个形状，重新写判断类型代码，不方便。
总结：C++编译器看到函数，有两个考量。
一是静态绑定，编译成Call、XXX（地址）；
二是动态绑定（虚机制:动态绑定的形式），要符合三个条件：1.通过指针调用 2.这个指针向上转型3.调用虚函数。调用哪个虚函数，要看p指向什么，这就是理解动态绑定。
结合第四周作业探究内存模型：
所以根据测试代码sizeof大小组成如图所示
Fruit：8+(4+4)+8+(1+7)=32
Apple：8+(4+4)+8+(1+3+4)+(1+7)=40
测试代码：
#include <iostream>
using namespace std;
class Fruit
{
public:
int no;
double weight;
char key;
void print() { }
virtual void process() { }
};
//-------------------------------------------------
class Apple : public Fruit
{
public:
int size;
char type;
void save() { }
virtual void process() { }
};
//-------------------------------------------------
int main(int argc, char const *argv[])
{
Fruit fruit;
Apple apple;
cout << "--------------Fruit----------------" << endl;
cout << "sizeof(Fruit) = " << sizeof(Fruit) << endl;
printf("Fruit.vptr = %x\n", &fruit);
printf("Fruit.vptr_process = %x\n", *(int*)&fruit);
printf("Fruit = %x\n", &fruit);
printf("Fruit.no = %x\n", &fruit.no);
printf("Fruit.weight = %x\n", &fruit.weight);
printf("Fruit.key = %x\n", &fruit.key);
cout << "--------------Apple----------------" << endl;
cout << "sizeof(Apple) = " << sizeof(Apple) << endl;
printf("Apple.vptr = %x\n", &apple);
printf("Apple.vptr_process = %x\n", *(int*)&apple);
printf("Apple = %x\n", &apple);
printf("Apple.no = %x\n", &apple.no);
printf("Apple.weight = %x\n", &apple.weight);
printf("Apple.key = %x\n", &apple.key);
printf("Apple.size = %x\n", &apple.size);
printf("Apple.type = %x\n", &apple.type);
system("pause");
return 0;
}
十七 对象模型：关于this
通过一个对象来调用一个函数，那个对象的地址就是this指针
第三周笔记有对这种模式具体的叙述及优点，这里不再赘述。
链接：http://www.jianshu.com/p/ca6613dd4c8d
十八 对象模型：关于Dynamic Binding
a是A的对象，虽然初值是b经过强制类型转换的，但因为是通过对象调用，不是指针，所以这是静态绑定。编译的汇编码为箭头所指。
pa为动态绑定，满足三个条件（new出来B，类型是A，是向上转型），call不是一个固定的地址。
（*（P->vptr）[n]）（p）的解释：通过指针p找到虚指针vptr，再找到虚表，取出其中第n个，把它当成函数指针去调用，由于是通过p来调用，所以p就是一个this指针，（p）就是this指针。
十九 重谈const
const第一周笔记有提过，链接：http://www.jianshu.com/p/2fafca2021d5
（1）这里需要新提出的是:basic_string有两个成员函数，一个operator[]函数后面有const，一个没有const，这两者可以存在，且有const的不用写COW，没有const的必须写COW。
（2）常成员函数的const和non-const版本同时存在，const object只能调用const版本，non-const object只能调用non-const版本。
二十 关于New Delete
第二周有记载，这里不再赘述。
链接：http://www.jianshu.com/p/12dcce512fd4
重载Operator new，Operator delete
重载operator new和operator delete用来设计自己的内存池，也就是内存管理。
全局写法：
void* myAlloy(size_t size)
{return malloc(size);}
void myFree(void* ptr)
{return free(ptr);}
//他们不可以被声明与一个namespace内
inline void* operator new（size_t size）
{cout<<“jjhou global new() \n"; return myAlloc(size);}
inline void* operator new[]（size_t size）
{cout<<“jjhou global new[]() \n"; return myAlloc(size);}
inline void* operator delete（void* ptr）
{cout<<“jjhou global delete() \n"; myFree(ptr);}
inline void* operator delete[]（void* ptr）
{cout<<“jjhou global delete[]() \n"; myFree(ptr);}
new的时候三个动作（其中一个调用new函数，此new和前头new不同），如果写了自己的重载new函数，则调用该函数，否则调用全局的new函数。
重载全局的函数，影响无远弗界。
成员函数写法：
Foo* p=new Foo;
//try{
// void* mem=operator new(sizeof(Foo));
// p=static_cast<Foo*>(mem);
// p->Foo::Foo();
//}
delete p
//p->~Foo();
//operator delete(p);
class Foo{
public:
void* operator new(size_t);
void operator delete(void*,size_t); //size_t 可有可无
//...
};
示例
在G4.9中，数组大小是数组整包大小加上一个计数器。
Foo* p=::new Foo(7);
::delete p;
Foo* pArray=::new Foo[5];
::delete[] pArray;
这样调用（也就是写上global scope operator：：），会绕过前述overloaded functions，强迫使用global version。
重载new（），delete（）
我们可以重载class member operator new（），写出多个版本，前提是每一版本的声明都必须有独特的参数列，其中第一个参数必须是size_t，其余参数以new所指定的placement arguments为初值。出现于new（......）小括号内的便是所谓placement arguments。
Foo* pf=new(300,'c')Foo;
我们也可以重载class member operator delete（），写出多个版本。但它们绝不会被delete调用。只有当new所调用的ctor抛出exception，才会调用这些重载版的operator delete（）。他只可能这样被调用。主要用来归还未能完全创建成功的object所占用的memory。
Basic_String 使用new（extra）扩充申请量
