（GeekBand）C++面向对象高级编程（下）第二周笔记

第十七节 对象模型（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(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(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
#include 
using namespace std;
class Fruit
{
private:
    int no;
    double weight;
    char key;
public:
    Fruit():no(0)
    {
        cout<<"defalut Fruit::ctor.this="<