(Boolan) C++面向对象高级编程（五）

对象模型

虚表和虚指针

关于虚表和虚指针以及内存对其等问题，我之前的文章做了非常详细的测试和整理，如果需要查看，可以查看后面的链接： http://www.jianshu.com/p/46acf45ee795
再次我对主要的知识点做一些梳理
虚指针
- 类中如果存在虚函数，就会在内存中存在虚指针
- 在对象的内存空间中，只需要持有虚函数们的一个指针（实际虚函数们是以个虚函数的数组）
- 由于虚函数指针，实际持有的实际是一个数组的指针，那么无论class设计有多少个虚函数，对于对象的大小来说都只增加一个指针的大小
- 继承过程实际是继承了父类的函数的调用权，所以，父类有虚函数，子类也一定会有虚函数
- 示例
  - UML
    
    类UML图
  - 虚指针和虚表图

虚指针和虚表

由图可以看出，在虚表中放的全都是虚函数的指针。其中void vfunc2()是在class A中定义的，而他的子类都继承自class A，并且没有被覆写，所以，A、B、C中的虚表都同时具有指针指向A::vfunc2()，而其余的虚函数，都是在各自class中定义的，所以各自会指向自己定义的虚函数（B::vfunc1()、C::vfunc1()）

子类调用虚函数：
C* pc = new C;//创建C的对象
pc->vfunc2(); //通过c的指针，调用未被覆写的虚函数
上方的调用过程，实际是相当于 (*(pc-> vptr)[n])(pc); 或 (*pc->vptr[n])(pc);
// 也就是说，调用过程会动态从数组（实际就是虚表）中，取出函数的指针，并把pc作为实参传入该函数，以实现调用
动态绑定调用虚函数：
A* pa = new C; //C的对象向上转型
pa->vfunc2(); //实际会调用C中所实现的vfunc2()

//实际过程，((pa->vptr)[n])(pa);或(pa->vptr)(pa)，而pa实际指向的为子类地址，所以看似是父类在调用，实则为子类在调用。所以调用时具体还是需要看指针所指向的对象

通过以上的原理，C++可以实现非常强大的可扩展性，无需判断具体是哪个类来调用相应的函数

实现多态（polymophism）条件：调用者是指针，向上转型（父类指针 = 子类指针），调用虚函数

模版方法（Template Method）

模版方法的UML

父类中的OnFileOpen()函数中调用了自己的虚函数Serialise()。

子类对象再调用OnFileOpen()函数执行到Serialize()函数式，会调用子类所实现的Serialize()函数。

原理：在父类的OnFileOpen()函数中调用自己的虚函数Serialise()时，实际是this->Serialize();的过程，由于Serialize();为虚函数, 并且子类对象符合了向上转型父类* x = new 子类，所以，实际相当于(*(this->vptr)[n])(this);的动态绑定过程。此时子类对象.OnFileOpen()子类调用OnFileOpen()时，相当于父类::OnFileOpen(子类对象的指针);，所以此时的OnFileOpen()中的this指针，实际是子类的指针，所以可以调用到子类所实现父类虚函数的实现函数了。

动态绑定
- 调用函数的是一个指针，使用对象调用仅仅是静态绑定
- 子类对象向上转型
- 调用的函数为虚函数

const关键字

| const object (data member不得变动)| non-const object (data member可变动)
----|------|----
const member functions （保证不改变data members） | √ | √
non-const member functions （不保证data members不改变）| × | √

问题，常量对象是不能调用非常量函数的，那么在实际应用者有什么例子吗？

charT operator[] (size_type pos) const {.....//不需要考虑copy on write}
reference operator[] (size_type pos) {....// 必须考虑copy on write}
//对于class template std::basic_string具有以上的两个成员函数。
//原因：对于字符串来说，无论常量还是非常量，都应该可以通过[index]来获取其中的某一个字母，此时无法确认是否是那种调用，必须有两个函数来由编译器自动区分，以便常量对象调用常量成员函数，非常量对象调用非常量成员函数

const关键字的初始化
const修饰的变量必需初始化

int i = 41;
const int c1 = i;  //正确，i的值拷贝给了c1
int j = c1;  //正确。ci的值拷贝给了i

拷贝一个对象的值，并不会改变它，一旦拷贝完成，心的对象就和原来的对象没什么关系了

const对象默认情况下只在文件内有效。
当多个文件中出现了同名的const变量时，其实等同于不同文件中分别定义了独立的变量。（解决方案是在定义和声明的地方都是用extern关键字修饰，两处则为同一个对象）

new和delete

new和delete的分解动作

new：先分配memory，再调用Constructor

TypeName *pt = new TypeName(params...);的编译器处理过程:
1. void *mem = operator new (sizeof(TypeName)); //分配所需的内存，operator new的内部调用了malloc(n)来分配空间
2. pt = static_cast<TypeName *>(mem); //类型强转
3. pt->TypeName::TypeName(params...); //调用class所对应的构造函数

delete：先分配deconstructor，再释放内存

delete pt; 的编译器处理过程
1 TypeName::~TypeName(pt); //调用析构函数
2 operator delete(pt); //释放内存，operator delete内部调用了free(pt)

重载operator new 和operator delete

全局的重载
- 调用者为编译器
- 范围为全局

void* myAlloc(size_t size){return malloc(size);}
void myFree(void* ptr){return free(ptr); }
.....
//痊愈重载，不能放在任何的namespace中
inline void* operator new (size_t size){
    cout << "global new() \n"; 
    return myAlloc(size);
}
inline void* operator new[](size_t size){
    cout << "operator new[]\n";
    return myAlloc(size);
}
inline void operator delete(void* ptr){
    cout << "global delete()\n";
    myFree(ptr);
}
inline void operator delete[](void* ptr){
    cout << "global delete[]\n";
    myFree(ptr);
}

重载member operator new/ delete

class Foo{
public:
    void* operator new(size_t);
    void operator delete(void* , size_t);//第二参数是可选参数，可以不写
//.......
}

重载后的调用过程

Foo* p = new Foo;

 //Foo* p = new Foo;执行过程
try{
    void* mem = operator new (sizeof(Foo));
    p = static_cast<Foo*> (mem);
    p->Foo:Foo();
  }

delete p;

//delete p;的执行过程
p->~Foo();
operator delete(p);

重载member operator new[]/delete[]

class Foo{
public:
    void* operator new[](size_t);
    void operator delete[](void* , size_t);//第二参数是可选参数，可以不写
//.......
}