C++构造函数与析构函数

转自http://blog.csdn.net/tqtuuuu/article/details/6652144

构造函数

    对于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); ">&nbsp;</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并不是那么傻，她会去虚函数表里面查看当前析构函数是否被定义为虚函数，如果是虚函数，它就会想了，那对象会不会实例化的是子类的对象呢，于是再判断是否实例化为子类对象，如果是就先调用子类的析构函数。