第十七节 对象模型（Object Model）：关于vptr和vtbl
也是老生畅谈的一些知识，简单的做下总结吧。
- 当class中存在virtual函数成员时，指向其的指针会被记录在virtual table中，且class会自动生成一个virtual pointer指向virtual table，大小为4字节。
- 不论有多少虚函数，都不会直接体现在该类Object的大小上。
- 在继承关系中，子类拥有父类的全部Data,以及父类function的调用权（不考虑private）
- 关于虚函数的调用：编译器根据传入的this判断调用哪个Object中的vptr，之后在vtbl中找到对象函数执行。
- 类中各成员的包含等关系如下图所示：
第十八节 对象模型：关于this
this是C++实现多态的重要手段。
关于this指针，我们通过设计模式Template Method案例来举例。
(MFC使用该模式)
//Application framework
CDocument::OnFileOpen()
{
...
Serialize()
...
}
//该函数设计了一系列动作（用...表示）,
//其中一个动作（Serialize()）现在无法决定,
//可能要退后几年去实现,
//则将他设计为虚函数。
class CMyDoc:public CDocument
{
virtual Serialize(){...}
};
main()
{
CMyDoc myDoc;
...
myDoc.OnFileOpen();
//编译器转化为
//CDocument::OnFileOpen(&myDoc)
//&myDoc作为this指针传入函数
}
解析：在主函数中执行myDoc.OnFileOpen()，并将&myDoc作为this指针传入基类的OnFileOpen()函数，当遇到虚函数时，根据this指针跳转到相对应的子类中执行相对应的函数。
第十九节 对象模型：关于Dynamic Binding
这节课分析了虚函数的对象调用与指针调用在汇编层面上的区别。
没听懂就不发表意见了。。。
第二十节 谈谈const
很实用的一堂课。
过去看大神敲代码的时候，总是好奇为什么会有const这个东西，对它的理解也仅仅是停留在“just->常量”的层面上，听了侯老师的课以后，对const的使用有了更深的理解，总结了一下几点规范。
- const它限定一个变量不允许被改变，产生静态作用。
- const可以修饰成员函数与变量，功能各不相同。
- const可以保证函数不会修改Data的值。
- 当成员函数同时拥有const与non-const版本时，const object只能调用const版本，non-const只能调用non-const版本。
第二十一节 关于new,delete
通过前面的课程，我们已经知道
Complex* pc=new Complex(1,2);
//会被编译器转化为
void* mem=operator new(sizeof(Complex));//分配内存（大小决定于class数据类型）,内部会调用malloc(n)
pc=static_cast<Complex*>(mem);//转型
pc->Complex::Complex(1,2);//构造函数
String* ps=new String(Hello);
delete ps;
//编译器转化为
String::~String(ps);//调用析构函数，杀掉class中动态分配的内存
operator delete(ps);//释放内存，内部调用free(ps)，free(ps)用来杀掉class本身(即数据成员);
new与delete本质是一种表达式，这种表达式不可以被重载，也就是说，上面被编译器分解的三步是一定会执行的，不可以被修改。我们常说的new与delete的重载本质上是对其中operator new与operator delete的重载。
第二十二节 重载Operator new,Operator delete
重载：全局operator new,全局operator delete,全局operator new[],全局operator delete[]
首先是对全局new与delete的重载。
void* myAlloc(size_t size)
{return malloc(size);}
void myFree(void* ptr)
{return free(ptr);}
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与delete提供的四个接口，值得注意的是，因为是对全局的new与delete进行重载，它的影响会非常的广。
重载member operator new/delete
用下面几段代码简单解释member operator new/delete的执行原理，完成的代码会在下节中给出。
//main中执行
Foo* p=new Foo;
delete p;
//Foo* p=new Foo分解
try
{
void* men=operator new(sizeof(Foo));//在class Foo中重载
p=static_cast<Foo*>(mem);
p->Foo::Foo();
}
//delete p分解
p->~Foo();
operator delete(p);//在class Foo中重载
//class Foo
class Foo
{
public:
void* operator new(size_t);
void* operator delete(void*,size_t);
};
arrary new与arrarya delete的原理与其类似，本节只做简单的介绍。
第二十三节 示例
下面是比较完整的一段重载member operator new/delete/new[]/delete[]的代码，有继承关系属于作业要求（原来我把自己用于其他事情的代码贴过来），大可直接无视掉。
#include<iostream>
#include<cstdlib>
using namespace std;
class Fruit
{
private:
int no;
double weight;
char key;
public:
Fruit():no(0)
{
cout<<"defalut Fruit::ctor.this="<<this<<" no="<<no<<endl;
}
Fruit(int i):no(i)
{
cout<<"Fruit::ctor.this="<<this<<" no="<<no<<endl;
}
~Fruit()
{
cout<<"defalut Fruit::dtor.this="<<this<<" no="<<no<<endl;
}
void print() { }
virtual void process(){ }
};
class Apple: public Fruit
{
private:
int size;
char type;
public:
Apple():size(0)
{
cout<<"defalut Apple::ctor.this="<<this<<" size="<<size<<endl;
}
Apple(int i):size(i),Fruit(i)
{
cout<<"Apple::ctor.this="<<this<<" size="<<size<<endl;
}
~Apple()
{
cout<<"Apple::dtor.this="<<this<<" size="<<size<<endl;
}
void save() { }
virtual void process(){ }
static void* operator new(size_t size);
static void operator delete(void* pdead,size_t size);
static void* operator new[](size_t size);
static void operator delete[](void* pdead,size_t size);
};
void* Apple::operator new(size_t size)
{
Apple* p=(Apple*)malloc(size);
cout<<"Apple::operator new()."<<endl;
return p;
}
void Apple::operator delete(void* pdead,size_t size)
{
cout<<"Apple::operator delete()."<<endl;
free(pdead);
}
void* Apple::operator new[](size_t size)
{
Apple* p=(Apple*)malloc(size);
cout<<"Apple::operator new[]()."<<endl;
return p;
}
void Apple::operator delete[](void* pdead,size_t size)
{
cout<<"Apple::operator delete[]()."<<endl;
free(pdead);
}
int main()
{
Apple *p1=new Apple(9);
cout<<endl;
delete p1;
cout<<endl;
Apple *p2=new Apple[5];
cout<<endl;
delete []p2;
return 0;
}
