c++对象模型 执行期语义

obejct construction and destruction

​ 一般而言,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() 安插于此
}
  • 一般而言,我们会尽可能将object放于使用它的那个程序片段附近,如此即可节省非必要的对象产生和销毁

全局对象

  • c++保证,一定会在main()中第一次用到global object前,将global object构造出来,而在main()结束前把global object摧毁掉
  • c++中,global objects都被放置于data segment,若显示为他指定一个值,此object将以此为初值,否则赋值为0(nonclass亦支持)。但c与此不同,c并不自动设定初值,而是global object只能被一个常量表达式设定初值

​ 解决c++ global object constructor和destructor的方法步骤:

  1. 为每一个需要初始化的文件产生__sti(),内含必要的constructor或inline expansions

  2. 在每个需要内存释放的文件中产生__std(),内含必要的destructor或inline expansions

  3. 提供一组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();
    }
    
  • 支持non class objects的静态初始化,也意味着支持virtual base classes。因为derived class的pointer或reference存取virtual base class subobject是一种非常量表达式

局部静态对象

​ local static class object保证:

  1. 对象的constructor只被调用一次,即使在函数中可能会被多次调用
  2. 对象的destructor只被调用一次,即使在函数中可能会被多次调用

​ 要支持以上行为,需要导入临时性对象以保护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和delete

​ 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);
}
  • vec_new有责任在excption发生的时候把内存释放掉

​ 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;
  • delete数组的元素如何记录呢?方法是为vec_new()所传会的每个内存区块配置一个额外的word,将元素个数藏在word中,这种被藏的数值被称为cookie

​ 现有如下片段:

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;

  • 对于以上行为,最好的方法是避免一个base class指针指向一个derived class objects组成的数组。但若有这方面需求,以下方法可行:
    for( int ix = 0; ix < elem_count; ++ix )
    {
        Point3d* p = &( (Point3d*) ptr )[ix];
        delete p;
    }
    

placement operator new

​ 调用方式:

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();
  • placement operator delete会对object实施destructor,但不释放内存

​ 对于"Point2w* ptw = new ( arena ) Point2w;",我们无法知道arena所指的这块区域是否需要先析构

  • placement operator new并不支持多态。因此,arena所表现的真正指针类型,要么指向相同类型的class,要么是一块新的内存,足够容纳该类型的object
    //错的
    Point2w* p2w = new (arena) Point3w;
    

临时对象

  • 凡持有表达式结果的临时对象,应保留到class object的初始化操作完成
  • 若临时对象被绑定在一个reference,对象将残留直至被初始化的reference声明结束,或是scope结束

文章名称:c++对象模型 执行期语义
转载源于:http://bzwzjz.com/article/dsoiege.html

其他资讯

Copyright © 2007-2020 广东宝晨空调科技有限公司 All Rights Reserved 粤ICP备2022107769号
友情链接: 成都网站设计 成都网站设计 营销型网站建设 成都网站制作公司 营销型网站建设 网站建设方案 LED网站设计方案 网站建设推广 手机网站制作 四川成都网站制作 成都响应式网站建设 商城网站建设 企业网站设计 手机网站制作 广安网站设计 成都网站建设推广 成都网站制作 成都网站设计 成都网站设计公司 成都网站制作 成都网站建设 成都网站建设