17.对象模型，关于vptr和vtbl
- vptr：虚指针
- vtbl：虚表
当一个类有虚函数的时候（无论多少），对象的模型中就会多一个指针。 这个指针指向一个vtbl，这个vtbl存着类虚函数的指针。
- A有两个虚函数，所以A的vtbl中有两个指针，一个指向A::vfunc1()，另一个指向A::vfunc2()。
- B也有两个虚函数，都继承于A，但是B重写了一个，所以B的vtbl中的指针，一个指向自己重写的B::vfunc1(),另一个指向A::vfunc1()。
- C也有两个虚函数，情况同于B，所以C的vtbl中的指针，一个指向自己重写的C::vfunc1()，另一个指向A::vfunc1()。
当编译器发现你使用虚函数时，则会使用图中的方式，调用到合适的虚函数。(*(p->vptr)[n])(p);或(*p->vptr[n])(p);，称之为虚机制，动态绑定。
18.对象模型，关于this
简单的说，通过一个对象调用一个函数，那么对象的地址就是this pointer。
Dynamic Binding：
this->Serialize();
===>
(*(this->vptr)[n])(this);
动态绑定的关键，就是确定vptr到底是哪个类的vptr，而要确定vptr，依靠的则是this pointer。每个对象，都有一个this pointer，所以可以通过对象的this pointer，找到对的vtbl，完成动态绑定，也就是多态。
19.对象模型，关于Dynamic Binding
Dynamic Binding的三大条件：
- 通过指针而非对象来调用函数。
- 调用的函数是虚函数。
- 向上转型。
dynamic binding只有通过指针调用虚函数时才会发生，要是直接通过对象来调用虚函数，那么就是static binding。
20.谈谈const
cosnt member functions（常量成员函数）
double real() const { ... };
double real() const { ... };
上段代码中的成员函数是cosnt member functions，意图是告诉编译器，我不会改变类的成员变量，并且要求编译器来把关，当出现改变时，编译器会报错。
因为const是函数签名的一部分，所以成员函数的const和non-const版本可以同时存在，有可能出现如下的调用情况：
| const object（data members 不可改变） | non-const object（data members 可以改变） | |
|---|---|---|
| const member functions（保证不改变data members） | YES | YES |
| non-const member functions（不保证data members不变） | NO | YES |
COW:Copy On Write。
在calss template std::basic_string<...>中，使用了共享的机制，意思是量string出现拷贝时，实际是两个string指向同一个字符串，当其中一个需要改变时，则需要copy一个副本来让它改变，原来共享的字符串保持不变，改变后两个string就会指向不同的字符串。在该类中的operator[]，有两个版本重载，const和non-const，则const版本不需要考虑COW，non-const版本则需要考虑COW，因为其字符串可以被改变。
这里需要额外注意，const member functions也可以被non-const object调用，但是这仅仅是只存在const member functions而不存在对应的non-const member functions时才会出现。当成员函数的const和non-const版本同时存在时，const object只会（只能）调用const版本，non-const object只会（只能）调用non-const版本。
所以说，当只存在const member functions时，const object和non-const object都可以调用；当只存在non-const member functions时，只能由non-const object调用，const object调用时，会引发如下的错误：
class String{
public:
void print(){}
};
int main(){
const String s;
s.print();
return 0;
}
1>d:\work\test_proj\geekband\test\source.cpp(10): error C2662: “String::print”: 不能将“this”指针从“const String”转换为“String &”
1> 转换丢失限定符
21.关于New,Delete
new和delete都称作expression（表达式）
- new分解后称作operator new，先分配memory，再调用ctor。
- delete分解后称作operator delete，先调用dtor，再释放memory。
operator new 和 operator delete可以被重载。
new搭配delete，array new搭配array delete。
new和delete都可以被重载，涉及到设计内存池。我们至少要知道new和delete重载的形式。
22.重载operator new，operator delete，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){
cout << "my operator new() \n";
return myAlloc(size);
}
inline void* operator new[](size_t){
cout << "my operator new[]() \n";
return myAlloc(size);
}
inline void operator delete(void* ptr){
cout << "my operator delete() \n";
return myFree(ptr);
}
inline void operator delete[](void* ptr){
cout << "my operator delete[]() \n";
return myFree(ptr);
}
成员函数
new和delete：
class Foo{
public:
void* operator new(size_t);
void operator delete(void*, size_t);//第二个参数可有可无
...
};
Foo* p = new Foo;
...
delete p;
分解new:
try{
void* mem = operator new(sizeof(Foo));
p = static_cast<Foo*>(mem);
p->Foo::Foo();
}
分解delete:
p->~Foo();
operator delete(p);
new[]和delete[]：
class Foo{
public:
void* operator new(size_t);
void operator delete(void*, size_t);//第二个参数可有可无
...
};
Foo* p = new Foo[N];
...
delete[] p;
分解new[]:
try{
void* mem = operator new(sizeof(Foo) * N + 4);//用4个字节来存储数组的长度。
p = static_cast<Foo*>(mem);
p->Foo::Foo();//N次
}
分解delete[]:
p->~Foo();//N次
operator delete(p);
23.示例
Example:
class Foo{
public:
int _id;
long _data;
string _str;
public:
Foo(): _id(0){
cout << "default ctor.this = " << this << " id = " << _id << endl;
}
Foo(int i): _id(i){
cout << "ctor.this = " << this << " id = " << _id << endl;
}
~Foo(){
cout << "dtor.this = " << this << " id = " << _id << endl;
}
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*, size_t size);
...
};
void* Foo::operator new(size_t size){
Foo *p = (Foo*)malloc(size);
cout << "size = " << size << " return: " << p << endl;
cout << "*(int*)p = " << *(int*)p << endl;
return p;
}
void Foo::operator delete(void* pdead, size_t size){
cout << "pdead = " << pdead << " size = " << size << endl;
cout << "*(int*)pdead = " << *(int*)pdead << endl;
free(pdead);
}
void* Foo::operator new[](size_t size){
Foo *p = (Foo*)malloc(size);
cout << "size = " << size << " return: " << p << endl;
cout << "*(int*)p = " << *(int*)p << endl;
return p;
}
void Foo::operator delete[](void* pdead, size_t size){
cout << "pdead = " << pdead << " size = " << size << endl;
cout << "*(int*)pdead = " << *(int*)pdead << endl;
free(pdead);
}
//若没有成员函数，就调用globals
Foo* pf = new Foo;
delete pf;
//强制调用globals
Foo* pf = ::new Foo;
::delete pf;
测试1：
cout << "sizeof(Foo) = " << sizeof(Foo) << endl;
Foo*p = new Foo(7);
delete p;
Foo* pArray = new Foo[5];
delete[] pArray;
测试1结果：
sizeof(Foo) = 40
size = 40 return: 000B4FF0
*(int*)p = -842150451
ctor.this = 000B4FF0 id = 7
dtor.this = 000B4FF0 id = 7
pdead = 000B4FF0 size = 40
*(int*)pdead = 7
size = 204 return: 000B4FF0
*(int*)p = -842150451
default ctor.this = 000B4FF4 id = 0
default ctor.this = 000B501C id = 0
default ctor.this = 000B5044 id = 0
default ctor.this = 000B506C id = 0
default ctor.this = 000B5094 id = 0
dtor.this = 000B5094 id = 0
dtor.this = 000B506C id = 0
dtor.this = 000B5044 id = 0
dtor.this = 000B501C id = 0
dtor.this = 000B4FF4 id = 0
pdead = 000B4FF0 size = 40
*(int*)pdead = 5
测试2：
cout << "sizeof(Foo) = " << sizeof(Foo) << endl;
Foo*p = ::new Foo(7);
::delete p;
Foo* pArray = ::new Foo[5];
::delete[] pArray;
测试2结果：
sizeof(Foo) = 40
ctor.this = 00A84FF0 id = 7
dtor.this = 00A84FF0 id = 7
default ctor.this = 00A84FF4 id = 0
default ctor.this = 00A8501C id = 0
default ctor.this = 00A85044 id = 0
default ctor.this = 00A8506C id = 0
default ctor.this = 00A85094 id = 0
dtor.this = 00A85094 id = 0
dtor.this = 00A8506C id = 0
dtor.this = 00A85044 id = 0
dtor.this = 00A8501C id = 0
dtor.this = 00A84FF4 id = 0
24.重载new(),delete()示例
我们可以重载class member operator mew(),称为placement new。每一个重载版本必须有独特的参数列，其中以第一参数必须是size_t。小括号里面的便是placement arguments。
我们也可以重载class member operator delete()，写出很多版本，但他们绝不会被delete调用，只有当new所调用的ctor跑出exception，才会调用这些重载版本的operator delete()。 只能这么被调用，主要用来归还未能完全创建成功的object所占用的memory。
25.basic_string使用new(extra)扩充申请量
当我们需要无声无息的多分配一些内存的时候，可以通过重载placement new来实现。
一点扩展
class Fruit{
int no;
double weight;
char key;
public:
virtual ~Fruit(){
cout << "Fruit dtor. this = " << this << " no = " << no << endl;
}
Fruit() : no(0){
cout << "Fruit default ctor. this = " << this << " no = " << no << endl;
}
Fruit(int i) : no(i){
cout << "Fruit ctor. this = " << this << " no = " << no << endl;
}
void print() const { }
virtual void process() { }
};
class Apple: public Fruit{
int size;
char type;
public:
virtual ~Apple(){
cout << "Apple dtor. this = " << this << endl;
}
Apple(){
cout << "Apple default ctor. this = " << this << endl;
}
Apple(int i) : Fruit(i){
cout << "Apple ctor. this = " << this << endl;
}
void save() { }
virtual void process(){ }
};
在如下的测试代码中：
int main(){
Fruit* pf = new Apple[3];
...
delete[] pf; //此种行为未确定，在GCC4.9.2编译运行后会出错。在vs2010下可正确运行，但是在C++标准中，该行为应该是未定义的，这里要特别小心。
return 0;
}
