甜橘子，专注成都网站制作网站设计与营销型网站建设与优化
QQ :532337155
电话：028-86922220
一般而言，constructor和destructor的安插都如预期那样：
成都创新互联是一家专注于网站制作、成都网站制作与策划设计,金口河网站建设哪家好?成都创新互联做网站,专注于网站建设10年,网设计领域的专业建站公司;建站业务涵盖:金口河等地区。金口河做网站价格咨询:13518219792
{
Point point;
//point.Point::Point() 安插于此
...
//point.Point::~Point() 安插于此
}
但有些情况desctructor需要放在每一个离开点（此时object还存活）前，例如swith，goto：
{
Point point;
//point.Point::Point() 安插于此
swith ( int(point.x() ) )
{
case -1 :
...
//point.Point::~Point() 安插于此
return;
case 0 :
...
//point.Point::~Point() 安插于此
return;
case 1 :
...
//point.Point::~Point() 安插于此
return;
default :
...
//point.Point::~Point() 安插于此
return;
}
//point.Point::~Point() 安插于此
}
解决c++ global object constructor和destructor的方法步骤：
为每一个需要初始化的文件产生__sti()，内含必要的constructor或inline expansions
在每个需要内存释放的文件中产生__std()，内含必要的destructor或inline expansions
提供一组rumtime library munch函数：一个_main()用以调用可执行文件中的所有__sti()，和一个exit()用以调用可执行文件中的所有__std()
//matrix_c也就是matrix.c文件名,identity为static object
__sti__matrix_c__identity()
{
identity.Matrix::Matrix();
}
int main()
{
_main();
...
_exit();
}
local static class object保证：
要支持以上行为，需要导入临时性对象以保护local static class object，第一次处理此object时，临时对象被赋值为false，此时constructor被调用，临时对象被改为true。取地址保证单一的构造和析构：
//如下程序片段
const Matrix& identity()
{
static Matrix mat_identity;
//...
return mat_identity;
}
//编译器策略之一
static struct Matrix* __0__F3 = 0;
struct Matrix* identity__Fv()
{
static struct Matrix__lmat__identity;
//若临时性对象已被建立，什么也别做
//否则：调用constructor:__ct__6MatrixFv
//设定保护对象，使它指向目标对象
__0__F3 ? 0 : (__ct__6MatrixFv( &__1mat_identity), (__0__F3 = ( &1mat_identity) ) );
//...
}
//destructor在与文件有关联的静态内存释放函数中有条件地被调用
char __std__stat_0_c_j()
{
__0__F3 ? __dt__6MatrixFv( __0__F3, 2 ) : 0;
//...
}
现有如下片段：
Point knots[10];
对于以上数组，若Point并没有定义constructor和destructor，只需配置内存存储元素即可。但若定义了，一般来说会经由一个或多个runtime library函数完成：
void* vec_new(
void* array, //数组起始地址.若不是具名数组则为0
size_t elem_size, //每个class object的大小
int elem_count, //数组中元素个数
void(*constructor)( void* ), //class的default constructor的函数指针
void ( *destructor )( void*, char ) //class的default destructor的函数指针
);
void* vec_delete
{
void* array, //数组起始地址
size_t elem_size, //每个class object的大小
int elem_count, //数组中元素个数
void ( *destructor )( void*, char )
}
//函数调用如下：
vec_new( &knots, sizeof(Point), 10, &Point::Point, 0 );
我们不可以取constructor的地址，只有编译器可以
vec_new的主要功能是将default constructor施行于class object组成的数组的每个元素
若提供一个或多个明显初值给class object组成的数组，编译器会显示地初始化前面提供了显式初值的元素，再用vec_new初始化后面未提供的
new运算符看起来是单一运算，但其实由两个步骤完成：
int* pi = new int(5);
//new
int* pi;
if( pi = __new( sizeof( int ) ) ) *pi = 5; //内存分配成功才初始化
//delete与new相似
if( pi != 0 ) __delete( pi ); //pi并不会清除为0
若用constructor配置class object:
//new
Point3d* origin = new Point3d;
Point3d* origin;
if( origin = __new( sizeof(Point3d) ) ) origin = Point3d::Point3d(origin);
//若是exception handling
if( origin = __new( sizeof(Point3d)))
{
try
{
origin = Point3d::Point3d(origin);
}
catch(...)
{
__delete(origin);
throw;
}
}
//delete
delete origin;
if( origin != 0 )
{
Point3d::~Point3d(origin);
__delete(origin);
}
library对new运算符的实现。要求每次new传回独一无二的指针：
extern void* operator new(size_t size)
{
if( size == 0 ) size == 1;
void* last_alloc;
while( !(last_alloc == malloc(size)))
{
//使用者自己的函数
if( _new_handler ) ( *_new_handler )();
else return 0;
}
return last_alloc;
}
现有如下片段：
int * p_array = new int[5];
int* p_array = (int*)__new( 5 * sizeof(int));
struct A{ float f1; };
A* p_a = new A[5];
以上两种方式都不会调用vec_new，因为vec_new的主要功能是将default constructor施行于class object组成的数组的每个元素，第二个例子没有定义constructor或destructor。但第一个实例会调用new operator
以下片段会调用vec_new:
Point3d* p_array = new Point3d[10];
//转化
Point3d* p_array;
p_array = vec_new( 0, sizeof(Point3d), 10, &Point3d::Point3d, &Point3d::~Point3d );
以下两种delete如今都支持：
int array_size = 10;
Point3d* p_array = new Point3d[array_size];
delete [array_size]p_array;
delete []p_array;
现有如下片段：
class Point
{
public:
Point();
virtual ~Point();
//...
};
class Point3d: public Point
{
public:
Point3d();
virtual ~Point3d();
//...
};
此时，配置内含10个Point3d objects的数组，Point和Point3d的constructor各被调用10次。但调用delete，大有不同：
Point* ptr = new Point3d[10];
//只有~Point()调用,且只传递了Point class object的大小
delete [] ptr;
for( int ix = 0; ix < elem_count; ++ix )
{
Point3d* p = &( (Point3d*) ptr )[ix];
delete p;
}
调用方式：
Point2w* ptw = new ( arena ) Point2w; //arena指向内存的一个区块，放置新产生的Point2w object
void* operator new( size_t, void* p )
{
return p;
}
但是以上只是placement operator new操作的一半，扩充的另一半将class object constuctor自动实施于arena所指地址：
Point2w* ptw = ( Point2w* ) arena;
if( ptw != 0 ) ptw->Point2w::Point2w();
对于"Point2w* ptw = new ( arena ) Point2w;"，我们无法知道arena所指的这块区域是否需要先析构
//错的
Point2w* p2w = new (arena) Point3w;