构造和析构的那些事

对《C++对象模型》、《More Effective C++》两书中关于构造以及析构函数的讲解总结：

一.关于default constructors.

“default constructors......在需要的时候被编译出来” 此处是指在编译器需要的时候被编译出来，被合成出来的constructor只执行编译器所需的行动。即使有需要为class合成一个default constructor, 也不会将两个data members val 和 pnext 初始化为0.

class Foo{
   public: int val;
    Foo * pnext;
};
void foo_bar(){
       Foobar;
       if(bar.val|| bar.pnext)
       //..do something
       //..
}

“对于class X, 如果没有任何 user-declared constructor, 那么会有一个 default constructor 被隐式(implicitly)声明出来......一个被隐式声明出来的constructor将是一个trival constructor(没啥用的)”

1. 如果一个class 没有任何constructor，但它内含一个member object，而后者有default constructor，那么个这个class的implicit default constructor 就是"nontrival",编译器需要为该class 合成一个default constructor. 不过这个合成操作只有在constructor 真正需要被调用时才会发生。 C++ 语言要求以"member objects 在class 中的声明顺序" 来调用各个constructors, 以inline的方式安插在程序代码中。

2. 带有default constructor 的 base class

类似道理，如果一个没有任何constructor的class 派生自一个“带有default constructor”的 base class, 那么这个 derived class 的default constructor 会被视为nonvtrival

3. 带有一个virtual Function 的class

class声明或继承一个virtual function

class 派生自一个继承串链，其中有一个或多个virtual base classes vtbl 以及 vptr

4. 带有virtual Base class 的 class

必须使virtual base class 在其每一个 derived class object 中的位置，能够于执行期准备妥当。

C++新手一般有两个误解：

1. 任何class如果没有定义default constructor，就会被合成出一个来。

2. 比那机器合成出来的default constructor 会显示设定"class 内每一个 data member 的默认值"

二.copy constructor 的构造操作

有三种情况，会以一个object的内容作为另一个class object的初值

1.显示的赋值初始化;

2.object当做参数交给某个函数 ;

3.当函数返回一个class object default memberwise initialization;

把每一个内建的或派生的data member(例如一个指针或一个数组)的值，从某个object 拷贝一份到另一个object上。不过它并不会拷贝其中member class object，而是以递归的方式施行memberwise initialization。

一个class 可用两种方式复制得到，一种是被初始化(copy constructor)，另一种是被指定(copy assignment operator)。

决定一个copy constructor是否为trival 的标准在于class 是否展现出所谓的 bitwise copy semantics。

三. member initialization list

在下列情况下，为了让你的程序能够被顺利编译，你必须使用member initialization list：

1. 初始化一个reference member;

2. 初始化一个 const member;

3. 调用一个base class 的 constructor, 而它拥有一组参数;

4. 调用一个member class的constructor，而它拥有一组参数时。

list中的项目顺序是由class中的members 声明顺序决定的，不是由initialization list中的排列顺序决定的，

class X
{
private:
       int i;
       int j;
public:
X(int val):j(val), i(j) {}
};

i(j)其实比j(val)更早执行，因为j一开始没有值，所以i(j)执行结果就是i无法预知。

正确的写法 initialization list 的项目被放在explicit user code 之前。

X(int val): j(val) {i = j;}

简单的说，编译器会对initializationlist 一一处理并可能重新排序，members 的声明顺序。它会被安插一些代码到constructor体内，并置于任何explicit user code 之前。

四. 析构语意学

如果class没有定义destructor，那么只有在class 内含memberobject(抑或class 自己的base class)拥有destructor 的情况下，编译器才会自动合成出一个来。甚至虽然它拥有一个virtualfunction，都不会。

1. destructor 的函数本体首先被执行;

2.如果class 拥有member class object，而后者拥有destructor，那么它们会以其声明顺序的相反顺序被调用;

3.如果object 内含一个vptr，现在被重新设定，指向适当之base class 的virtual table。

继承体系下的对象构造

constructor 可能内含大量的隐蔽码，因为编译器会扩充每一个constructor，扩充程度视class T 的继承体系而定。一般而言，编译器所做的扩充操作如下：

1. member initialization list 中的data members 初始化操作会被放进 constructor 的函数本体，并以members 的声明顺序为顺序;

2，如果一个member并没有出现在memberinitialization list 中，但它有一个default constructor，那么该default constructor 必须被调用;

3. 在那之前，如果class object 有virtual table pointers，它们必须被设定为初值，指向适当的 virtual tables;

4.在那之前，所有上一层的base class constructors 必须被调用，以base class 的声明顺序为顺序(与memberinitialization list 中的顺序没有关联);

5.所有的virtual base class constructors 必须被调用，从左到右，从最深到最浅。

虚拟继承

传统的“constructor扩充现象”并没有发生，这是因为virtual base class 的共享性的缘故。

五. 构造函数以及析构函数中内存泄露的问题

void processAdoptions(istream&dataSource)
{
       while(dataSource)
       {
             ALA *pa =readALA(dataSource);
             pa->processAdoption();
              deletepa;
       }
}

每当readALA 被调用，便产生一个新的heap object。如果没有调用delete，这个循环很快便会出现资源泄露的问题。

如果pa->processAdoption抛出一个exception,processAdoption 便会发生一次资源泄露。

简单的解决方法:

 voidprocessAdoptions(istream& dataSource)
{
       while(dataSource) {
              ALA *pa =readALA(dataSource);
              try{
                     pa->processAdoption();
                  }
       }
              catch(....) {
                     deletepa;
           throw;
              }
              delete pa;       //如果没有exception 被抛出，也要避免资源泄露
       }
}

代码凌乱，思考如何把delete动作从process Adoptions函数移动到函数内某个局部对象的destructor内。

解决的办法就是，以一个"类似指针的对象"取代指针pa。如此当这个类似指针的对象被自动销毁的时候，我们可以令其destructor调用delete。行为类似 smart pointers。

(我们必须明智和审慎的使用智能指针，因为至少需要加上 copy constructor, assignment operator 以及指针仿真函数 operator* 和 operator->)....

以auto_ptr 对象取代原始指针，就不需要担心heap objects没有被删除，即使在exception 被抛出的情况下。

void processAdoptions(istream&dataSource)
{
       while(dataSource)
       {
              auto_ptr<ALA>pa(readALA(dataSource));  //pa被声明为auto_ptr<ALA>对象，自动析构
              pa->processAdoption();            //循环后不再有delete 语句
       }
}

一个对象存放"必须自动释放的资源"，并依赖该对象的destructor 释放

void displayInfo(const Information&info)
{
       WINDOW_HANDLE  w(createWindow());
       displayinfo in wondow corresponding to w;
       destroyWindow(w);
}
class WindowHandle{
public:
 WindowHandle(WINDOW_HANDLE handle):w(handle) {}
       ~WindowHandle(){destroyWindow(w);}
       operatorWINDOW_HANDLE() {return w;}
private:
   WINDOW_HANDLE W;
       WindowHandle(constWindowHandle&);
       WindowHandle&operator=(const WindowHandle);
}
void displayInfo(const Information&info){
       WondowHandlew(createWindow());
       displayinfo in window vorresponding to w;   //坚持把资源封装在对象内，通常可以避免资源泄露
}
在constructor 内阻止资源泄露(resource leak):
BookEntry::BookEntry(const string&name,
                               const string& address,
                                   conststring& imageFileName,
                                   conststring& audioClipFilename)
:theName(name),theAddress(address),theImage(0), theAudioClip(0)
{
       if(imageFile!= " ") {
           theImage = new Image(imageFileName);    
    }
       if(audioClipFileName!= ""){
       theAudioClip = new AutdioClip(audioClipFileName);
    }
}
BookEntry:: ~BookEntry(){
       delete the Image;     //C++保证删除null指针是安全的
       deletetheAudioClip;
}

可是当 newAudioClip(audiocliopFileName) 出现异常，控制权移出BookEntry constructor, 此时BookEntry 的 destructor 不会调用来删除theImage已经指向的对象。 C++只会析构已构造完成的对象。

秒客网

构造和析构的那些事

相关文章