读书笔记 《深度探索c++对象模型》 （5）

第六章：执行期语意学
6.1 对象的构造和解构
a) 全局对象
b) 局部静态对象
    记住局部静态对象的constructor和destructor只被执行一次。int function() { static int i; //只被初始化一次 i++; return i; }
c) 对象数组
如果一个class有一个自定义的default constructor，那么类似于Point array[10]; 的时候，一个函数会被调用：void* vec_new( void* array, // 数组起始地址 size_t elem_size, // 每一个class object大小 int elem_count, // 数组中元素数目 void (*constructor)(void*), void (*destructor)(void*, char) ) 同样，如果class定义了destructor，函数void* vec_delete( void* array, // 数组起始地址 size_t elem_size, // 每一个class object大小 int elem_count, // 数组中元素数目 void (*destructor)(void*, char) ) 会被调用。
例如：Point knots[10] = { Point(), Point(1, 1, 1), -1 }; 前三个元素会被明确初始化，vec_new会被调用7次。
d) 针对数组的new语意
如果class没有定义default constructor，那么new只是做分配空间的操作。有一点需要注意：#include <stdio.h> #include <stdlib.h> class Point { public: Point() { printf("Point::constructor/n"); } virtual ~Point() { printf("Point::destructor/n"); } protected: int _y; }; class Point3d : public Point { public: Point3d() { printf("Point3d::constructor/n"); } virtual ~Point3d() { printf("Point3d::destructor/n"); } }; int main () { Point *ptr = new Point3d[2]; // delete ptr; //这样只会delete第一个元素 delete []ptr; return 0; } 书上说在delete []ptr的时候，由于调用了vec_delete()函数，传给该函数的指针类型是Point型，所以在delete的时候仅仅调用的是Point的destructor。应该采用for (int ix = 0; ix < elem_count; ix++) { Point3d *p = &((Point3d*)ptr)[ix]; delete p; } 的方式。但是我在写程序（就是上面那段）的时候并没有任何问题。
e) placement operator new语意
首先我们区分下几个容易混淆的关键词：new、operator new、placement new。
new和delete是操作符，operator new和operator delete是标准库函数。要实现不同的内存分配行为，需要重载operator new，而不是new和delete。class MyClass {…}; MyClass * p=new MyClass;

这里的new实际上是执行如下3个过程：
1. 调用operator new分配内存；
2. 调用构造函数生成类对象；
3. 返回相应指针。
operator new就像operator+一样，是可以重载的，但是不能在全局对原型为void operator new(size_t size)这个原型进行重载，一般只能在类中进行重载。如果类中没有重载operator new，那么调用的就是全局的::operator new来完成堆的分配。同理，operator new[]、operator delete、operator delete[]也是可以重载的，一般你重载的其中一个，那么最后把其余的三个都重载一遍。
至于placement new，它也只是operator new的一个重载的版本，只是我们很少用到它。如果你想在已经分配的内存中创建一个对象，使用new时行不通的。也就是说placement new允许你在一个已经分配好的内存中（栈或者堆中）构造一个新的对象。原型中void*p实际上就是指向一个已经分配好的内存缓冲区的的首地址。
我们知道使用new操作符分配内存需要在堆中查找足够大的剩余空间，这个操作速度是很慢的，而且有可能出现无法分配内存的异常（空间不够）。placement new就可以解决这个问题。我们构造对象都是在一个预先准备好了的内存缓冲区中进行，不需要查找内存，内存分配的时间是常数；而且不会出现在程序运行中途出现内存不足的异常。所以，placement new非常适合那些对时间要求比较高，长时间运行不希望被打断的应用程序。
使用方法如下： 
1. 缓冲区提前分配 
可以使用堆的空间，也可以使用栈的空间，所以分配方式有如下两种： class MyClass {…}; char *buf=new char[N*sizeof(MyClass)+sizeof(int)]; //或者char buf[N*sizeof(MyClass)+sizeof(int)]; 2. 对象的构造 MyClass * pClass=new(buf) MyClass; 3. 对象的销毁 
一旦这个对象使用完毕，必须显式的调用类的析构函数进行销毁对象。但此时内存空间不会被释放，以便其他的对象的构造。 pClass->~MyClass(); 4. 内存的释放 
如果缓冲区在堆中，那么调用delete[] buf;进行内存的释放；如果在栈中，那么在其作用域内有效，跳出作用域，内存自动释放。

在C++标准中，对于placement operator new []有如下的说明： placement operator new[] needs implementation-defined amount of additional storage to save a size of array. 所以我们必须申请比原始对象大小多出sizeof(int)个字节来存放对象的个数，或者说数组的大小。

6.3 临时性对象
关于临时性对象的生命周期有三种情况：
a) 一般情况：临时性对象的被摧毁，应该是对完整表达式（full-expression）求值过程中的最后一个步骤。该完整表达式造成临时对象的产生。#include <iostream> using namespace std; class A { public: A(int i): m_i(i) { cout << "A(): " << m_i << endl; } ~A() { cout << "~A(): " << m_i << endl; } A operator+(const A& rhs) { cout << "A operator+(const A& rhs)" << endl; return A(m_i + rhs.m_i); } int m_i; }; int main() { A a1(1), a2(2); a1 + a2; cout << "------------------------------------" << endl; //运行到这里，a1 + a2产生的临时变量已经被释放 return 0; } 输出：
两个例外：
b) 表达式被用来初始化一个object时。#include <iostream> using namespace std; class A { public: A(int i = 0): m_i(i) { cout << "A(): " << m_i << endl; } ~A() { cout << "~A(): " << m_i << endl; } A operator+(const A& rhs) { cout << "A operator+(const A& rhs)" << endl; return A(m_i + rhs.m_i); } A& operator=(const A& rhs) { cout << "A& operator=(const A& rhs)" << endl; m_i += rhs.m_i; return *this; } int m_i; }; int main() { A a1(1), a2(2); A a3; a3 = a1 + a2; //a1 + a2产生的临时变量在a3的赋值操作完成后，才释放 return 0; } 输出：
c) 如果一个临时性对象被绑定于一个reference，对象将残留，直到被初始化之reference的生命结束，或直到临时对象的生命范畴（scope）结束——视哪一种情况先到达而定。#include <iostream> using namespace std; class A { friend ostream& operator<<(ostream& os, const A&); public: A() { } A(const A&) { cout << "A(const A&)" << endl; } ~A() { cout << "~A()" << endl; } }; ostream& operator<<(ostream& os, const A&) { os << "ostream& operator<<(ostream& os, const A&)" << endl; return os; } const A& f(const A& a) { return a; } int main(int argc, char* argv[]) { { const A& a = A(); cout << "-------------------" << endl; }//直到被初始化之reference的生命结束 cout << f(A()) << endl; //直到临时对象的生命范畴（scope）结束： //临时对象的const引用在f的参数上（而不是返回值）。 //这个引用在f()返回的时候就结束了，但是临时对象未必销毁。 cout << "-------------------" << endl; return 0; } 输出：