C++构造函数与析构函数知多少

众所周知，几乎所有的面向对象的编程语言都保护构造函数与析构函数，好学者就要举手了，啥情况啊，Java里面不就没有析构函数嘛。好吧，你问倒我了，不过可以认为Java的垃圾自动回收机制实现了对象析构的功能。管他呢，还是看C++的构造函数和析构函数吧。

 

构造函数

    对于C++的构造函数，暂且将其分为以下几类：

1. 默认构造函数

2. 隐士转换构造函数

3. 拷贝构造函数

4. 其它构造函数

    1. 默认构造函数表示没有任何参数的构造函数，当自定义任何构造函数以后，将不再自动创建默认构造函数，当然，默认构造函数啥也不干，程序员关心系数顿时大跌。关于默认构造函数还需要关心的一个问题是，当本类继承于另一个类(即父类)，父类没有默认构造函数时，本类将自动没有构造函数，并且还必须定义至少能够支持父类初始化的构造函数。

    2. 隐士转换构造函数时什么呢？它是这样一类构造函数，这类构造函数仅含有一个参数。由于C++规定，为只含有一个参数的构造函数自动定义一种隐士转换，将构造函数的参数对应数据类型的对象转换为类对象。如下面例子所示：

 

class String {     String(const char *s);};String s = "hello friends";

    其中字符串“hello friends”通过隐士转换构造函数转换为了String类对象s。这里不得不提一个关键字explicit，比较悲剧的是学了好几年C++后才知道这么一个关键字，这也充分体现了一本好书的重要性。下面来看看explicit的用法，再解释。

class String {    explicit String(const char *s);};String s = "hello friends"; //编译不通过String s("hello friends");  //编译通过

    explicit仅用于构造函数，且仅用于隐士转换构造函数，其目的是禁止隐士构造函数功能。如上代码所示，当为构造函数添加explicit关键字后，String s = "hello friends"; 编译不通过。当然，此时构造函数本身还是能够正常工作的。

    3. 拷贝构造函数,就是用来复制对象的一种特殊的构造函数。通过它，可以使用一个已经创建好的对象（由拷贝构造函数的参数指定）去初始化一个正准备创建的同类对象。

class 类名{public:    类名(类名 &对象名);};

    如上述代码所述，拷贝构造函数只能有一个参数，并且必须是同类对象的引用。每个类都应该有一个拷贝构造函数，如果用户没有指定，将使用默认的拷贝构造函数。默认拷贝构造函数执行对象的全部内容复制,但有时需要有选择、有变化地复制。这种情况就需要显示定义拷贝构造函数，并实现为感兴趣部分的复制或者为新对象添加某些属性值。

    拷贝构造函数最常见的使用方式是在类中含有指针类型属性时，因为默认的拷贝函数是按指拷贝的，即所谓的浅拷贝。这时需要显示定义拷贝构造函数，并显示地将指针从新分配内存并copy以前指向的值到新分配的内存中。

    4. 其它构造函数，没什么特别的，就是前面1,2,3未包含的构造函数均属于该类。

   

 构造函数初始化参数列表

    以下情况下需要使用初始化成员列表：（待补充）

一、需要初始化的数据成员是对象的情况；

二、需要初始化const修饰的类成员；

    第一种情况，如果类A中属性存在一个类B，且类B没有不带参数的构造函数，此时初始化A时也需要初始化B，所以需要初始化参数列表。当然，此种情况一般成员属性也可以通过此种方式初始化。

    第二种情况，const成员属性不能复制，一旦初始化后就不能改变。

    下面的例子说明构造函数初始化参数列表的使用：

#include <iostream>using namespace std;class B{public:    B(int b) {        cout<<b<<endl;    }};class A{public:    B b;    A(int a, int ci);private:    const int ci;    //const int ci = 10;    //编译错误，不能初始化      static const int cv = 10; //添加static关键字后能够编译通过    int c;};A::A(int a, int ci):b(a),ci(ci),c(4) {    cout << ci << "--" << c << endl;}int main(){    A a(5, 10);    return 0;}

析构函数

   析构函数就与构造函数对应，在对象消亡时做一些善后处理。看下面的例子：

#include <iostream>using namespace std;class A{public:    A() {        cout << "A..." << endl;    }    ~A() {        cout << "~A" <<endl;    }};class B : public A{public:    B() {        cout<<"B..."<<endl;    }    ~B() {        cout<<"~B"<<endl;    }};int main() {    A *a = new B();    delete a;    return 0;}<span style="FONT-FAMILY: Arial, Verdana, sans-serif; WHITE-SPACE: normal; BACKGROUND-COLOR: rgb(255,255,255)"> </span>

    编译输出：

# ./a.out A...B...~A

    由此可见，在对象a消亡时，会自动调用对象A的析构函数。但是C++也太傻了吧，明明我实例化的B对象，可为啥析构时是调用A对象的析构函数呢？看delete a，由此可估计delete关键字只认a的对象，而不会变通。怎么能够这样...

virtual关键字

     上面的例子显示，构造了对象B，却没有析构，这会造成啥问题呢？反正我是不清楚了。于是C++提供的virtual关键字可以解决这个问题，看下面的代码：

#include <iostream>using namespace std;class A{public:    A() {        cout << "A..." << endl;    }    virtual ~A() {            //唯一区别：添加了关键字virtual        cout << "~A" <<endl;    }};class B : public A{public:    B() {        cout<<"B..."<<endl;    }    ~B() {        cout<<"~B"<<endl;    }};int main() {    A *a = new B();    delete a;    return 0;}

     输出：

# ./a.out A...B...~B~A

    可见，添加virtual关键字后，确实能够解决该问题，B对象也调用了析构函数。可是这是为什么呢？

    下面开始yy了，也许delete并不是那么傻，她会去虚函数表里面查看当前析构函数是否被定义为虚函数，如果是虚函数，它就会想了，那对象会不会实例化的是子类的对象呢，于是再判断是否实例化为子类对象，如果是就先调用子类的析构函数。

    此文并不想讲virtual关键字的用法，只是介绍一下virtual关键字与析构函数的关系。如果想了解virtual关键字的用法，请自行CSDN了。