GeekBand C++ 第五周

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(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(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;
}