C/C++编程：无继承情况下的对象构造

本是古典何须时尚 2023-01-19 04:35 20阅读 0赞

# 结构体 #

对于下面程序片段  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]  
L1、L2、L6表现出三种不同的对象产生方式：

*  全局(global)内存配置
 *  本地(local)内存呢配置
 *  堆(heap)内存配置

L7将一个类对象指定给另一个，L10设定返回值，L9则明确以delete运算符删除堆对象

一个对象的生命，是该对象的一个执行期属性：

*  全局对象的生命和整个程序的生命相同
 *  本地对象的生命从L5的定义开始，到L10结束
 *  堆对象的生命从它被new配置出来开始，到delete销毁为止

下面是Point的第一次声明，可以写成C程序。C++标准说设置一种POD声明形式：

typedef struct{
        
    	float x, y, z:
    }Point;

如果我们用C++来编译这段码，会发生什么事？

*  理论上，编译期会为Point声明一个**trivial默认构造函数**、一个**trivial析构函数**、一个**trivial拷贝构造函数**、一个**trivial拷贝赋值运算符**
 *  实际上，编译期会分析这个声明，并为它贴上POD标志

当编译期遇到如下定义：

/*(1)*/ Point global;

*  理论上，Point1的**trivial默认构造函数**和**trivial析构函数**都会被产生并调用：
    
     *  构造函数在程序**起始处**(startup)被调用
     *  析构函数在程序exit()是被调用（exit()是由系统产生，放在main()结束之前）
 *  实际上，那些triival函数不是没被定义，就是没被调用，程序的行为就如它在C种的表现一样。只有一个小小的例外：
    
     *  在C种，global被视为一个**临时性的定义**，因为它没有明确的初始化操作。一个"临时性的定义"可以在程序中发生多次，那些实例会被链接器折叠起来，只留下一个实体，被放在程序data segment种一个**特别保留给未初始化的global对象使用**的空间。这个空间被称为BSS
     *  C++并不支持**临时性的定义**(这是因为类构造行为的隐含引用之故)，因此，global在C++中被视为完全定义(它会阻止第二个或者更多个定义)。C和C++的一个差异在于，BSS数据段在C++中相对的不重要。**C++的所有全局对象都被当作初始化过的数据**来对象

当编译期遇到如下定义：

/*(2)*/ Point local;

*  既没有被构造也没有被解构
 *  这个对象不会自动将其成员变量初始化

当编译期遇到如下定义：

/*(6)*/ Point *heap = new Point;

*  这里会被转换为new运算符的调用：

Point *heap = __new(sizeof(Point));

*  注意：这里没有默认构造函数施行于new运算符所传回的Point对象上

当编译期遇到如下赋值操作：

/*(7)*/ *heap = local;

*  理论上，这里的指定操作会触发trivial copy assignment operatir进行拷贝搬运操作
 *  实际上，这个对象是一个POD，所以赋值操作只是像C那样的纯粹位搬移操作

当编译期遇到如下操作：

/*(9)*/delete  heap;

*  会被转换为对delete运算符的调用：

__delete(heap);

*  理论上，这样的操作会触发Point的trivial destructor
 *  实际上，destructor要不是没有产生就是没有被调用

当编译期遇到如下操作：

(10) return local;

*  函数以传值的方式将local传回
 *  理论上会触发trivial copy constructor
 *  实际上return操作只是一个简单的位拷贝操作，因为对象是一个POD

# 抽象数据类型 #

以下是Point的第二次声明，在public接口下多了private数据，提供完整的封装性，但没有提供任何虚函数：

*  没有为Point定义一个拷贝构造函数或者拷贝运算符，因为默认的位语意(default bitwise semantice)已经足够
 *  没有位Point提供一个析构函数，因为程序默认的内存管理也足够了

class Point{
        
    public:
    	Point(float x = 0.0, float y = 0.0, float z = 0.0) : _x(x), _y(y), _z(z){
        
    	}
    private:
    	float _x, _y, _z;
    };

这个经过封装的Point类，其大小并没有改变，还是三个连续的float。是的，**不论private、public存取层，或者是成员函数的声明，都不会占用额外的对象空间**

对于一个global实体：

Point global; // 实施Point::Point(0.0, 0.0, 0.0);

*  现在有了默认构造函数作用于其上。
 *  由于global被定义在全局范围内，其初始化操作将延迟到程序激活(startup)时才开始

如果要对类中所有成员都设定常量初始值，那么给予一个`explicait initializetion list`会比较高效。甚至在local scope中也是如此。举个例子：

void mumble(){
        
    	Point local1 = {
        1.0, 1.0, 1.0};  // explicit initialization
    
    	Point local2;
    
    	// 相当于一个inline expansion
    	// explicit initialization会快一点
    	local2._x = 1.0;
    	local2._y = 1.0;
    	local2._z = 1.0;
    }

local1的初始化操作会比local2快。这是因为当函数的activation record被放进程序堆栈时，上面的初始化列表中的常量就可以被放进local1的内存中了

`explicait initializetion list`的三个缺点：

*  只有当类成员都是public时，才能其作用
 *  只能指定常量，因为它们在编译时期就可以被评估求值
 *  由于编译器不会主动施行，所以初始化行为的失败可能性会比较高。

explicait initializetion list它的效率不能补偿它的缺点。

对于local Point object的定义：

{
        
    	Point local;
    }

*  **在编译期层面，会有一个优化机制来识别inline constructors，后者简单的提供一个`member-by-member`的常量指定操作。然后编译器会抽取出那些值，并且对待它们好像时explicait initializetion list一样，不会把constructors扩展成一些类的assignment之类**
 *  因此，被附加上default Point cinstructor的inline expansion：

{
        
    	// 默认构造函数的内联展开
    	Point local;
    	local._x = 0.0; local._y = 0.0; local._z = 0.0;
    }

对于堆对象：

Point *heap = new Point

*  被附加上”对default Point cinstructor的有条件调用操作“：

Point *heap = __new(sizeof(Point));
    if(heap != 0){
        
    	heap->Point::Point();
    }

*  然后又被编译器执行inline expansion操作

对于heap指针指向local object：

*heap = local;

*  保持简单的位拷贝操作

对于传值返回：

return local;

*  保持简单的位拷贝操作

对于删除heap对象：

delete heap;

*  该操作并不会导致构造函数被调用，因为我们没有明确的提供一个构造函数实体

理论上，Point类有一个默认拷贝构造函数、拷贝运算符、和析构函数，然后它们但是无关痛痒的(trivial)，而且编译器实际上根据没有产生它们

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20221021/60d5671601014115ba32b79696ec29d7.png