C++中构造函数、析构函数和虚函数

1.类

类的三个新特征：友元（friend）、可变成员和静态成员。

友元：允许一个类将对其非公有成员的访问权授予指定的函数或类。

2.new与delete

new时做了三件事：①分配内存空间。②调用构造函数。③返回对象指针。

delete时做了两件事：①调用析构函数。②释放内存空间。

3.构造函数

1）实参决定使用哪个构造函数。

2）构造函数自动执行。

3）先调用基类构造函数，再调用子类构造函数。

4）常见类型（无参、拷贝、重载）及调用过程。与等号运算符重载区分。

例1：

#include <iostream>using namespace std;class Complex{        private :    double    m_real;    double    m_imag;    int id;    static int counter;public:    //    无参数构造函数    Complex(void)    {        m_real = 0.0;        m_imag = 0.0;        id=(++counter);        cout<<"Complex(void):id="<<id<<endl;    }    //    一般构造函数（也称重载构造函数）    Complex(double real, double imag)    {        m_real = real;        m_imag = imag;                id=(++counter);        cout<<"Complex(double,double):id="<<id<<endl;    }    //    复制构造函数（也称为拷贝构造函数）    Complex(const Complex & c)    {        // 将对象c中的数据成员值复制过来        m_real = c.m_real;        m_imag = c.m_imag;        id=(++counter);        cout<<"Complex(const Complex&):id="<<id<<" from id="<<c.id<<endl;    }                // 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象    Complex(double r)    {        m_real = r;        m_imag = 0.0;        id=(++counter);        cout<<"Complex(double):id="<<id<<endl;    }    ~Complex()    {        cout<<"~Complex():id="<<id<<endl;    }    // 等号运算符重载    Complex &operator=( const Complex &rhs )    {        if ( this == &rhs ) {            return *this;        }        this->m_real = rhs.m_real;        this->m_imag = rhs.m_imag;        cout<<"operator=(const Complex&):id="<<id<<" from id="<<rhs.id<<endl;        return *this;    }};int Complex::counter=0;Complex test1(const Complex& c){    return c;}Complex test2(const Complex c){    return c;}Complex test3(){    static Complex c(1.0,5.0);    return c;}Complex& test4(){    static Complex c(1.0,5.0);    return c;}int main(){    Complex a,b;//各调用一次Complex(void)构造函数    // 下面函数执行过程中各会调用几次构造函数，调用的是什么构造函数？    Complex c=test1(a);//①test1()②拷贝构造函数    Complex d=test2(a);//①拷贝②test2()③拷贝Complex h(c);//拷贝Complex i = h;   //拷贝，相当于Complex i(h);c=h;//等号运算符    b = test3();//①一般②拷贝③等号    b = test4();//①一般②等号    Complex e=test2(1.2);//①类型转换②拷贝    Complex f=test1(1.2);//①类型转换②拷贝    Complex g=test1(Complex(1.2));//①类型转换②拷贝}

注：

①等号：对象已初始化；拷贝：对象未初始化。

<pre name="code" class="cpp">Complex i = h;//调用拷贝；i = h;//调用等号

②

<span style="background-color: rgb(255, 255, 0);">Complex c = test1(a);//调用1次构造函数</span>

上式结果等价于

<span style="background-color: rgb(255, 255, 0);">Complex c1 = test1(a);//调用1次Complex c = c1;//调用1次，总共2次，因为多了中间变量c1.</span>

4.析构函数

牢记析构函数的调用顺序（与构造函数的调用顺序相反）

什么时候调用析构函数？

1）对象生命周期结束，被销毁时；

2）delete指向对象的指针时，或delete指向对象的基类类型指针，而其基类虚构函数是虚函数时；

3）对象i是对象o的成员，o的析构函数被调用时，对象的析构函数也被调用。

例2：

class A{public:A(){cout<<"constructing A"<<endl;}~A(){cout<<"destructing A"<<endl;}private:int a;};class B:public A{public:B(){cout<<"constructing B"<<endl;}~B(){cout<<"destructing B"<<endl;}private:int b;};void main(){B b;}

输出结果：

说明：先调用父类构造方法，再调用子类构造方法。

上述代码说明了一件事：析构函数的调用顺序与构造函数的调用顺序相反。

例3：

main()方法改为：

void main(){A *a = new B;delete a;}

输出结果：

例4：

class A{public:A(){cout<<"constructing A"<<endl;}virtual ~A(){cout<<"destructing A"<<endl;}private:int a;};class C{public: C() {  cout<<"constructing C"<<endl; } ~C() {  cout<<"destructing C"<<endl; } private:  int c;};class B:public A{public:B(){cout<<"constructing B"<<endl;}~B(){cout<<"destructing B"<<endl;}private:int b;C c;};void main(){B b;}

输出结果：

5.虚函数-virtual function

多态、虚函数表（内存中实例、最前面、地址表、父子类在内存中函数位置）、

5.1 定义

C++中虚函数的作用主要是实现了多态的机制。多态，简言之就是用父类型的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。

5.2 虚函数表

虚函数（virtual function）是通过一张虚函数表（virtual table）来实现的，简称V-Table。该表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其能真实地反映实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中。

C++中，编译器必须要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数的偏移量）。这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

代码如下：

#include <iostream>using namespace std;class Base{public:virtual void f(){cout<<"f()"<<endl;}virtual void g(){cout<<"g()"<<endl;}virtual void h(){cout<<"h()"<<endl;}};void main(){Base b;}

内存结构如下：

一般覆盖（无虚函数覆盖）

假设有如下所示的一个继承关系：

在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：对应实例：Derive d;的虚函数表如下：

可看到下面几点：

1）虚函数按照其声明顺序存在于表中。

2）父类的虚函数在子类的虚函数前面。

一般继承（有虚函数覆盖）

虚函数如下所示：

从表中可看到以下几点

1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被覆盖的函数依旧。

多重继承（无虚函数覆盖）

从上面可看到以下几点：

1）每个父类都有自己的虚表

2）子类的成员函数被放到了第一个父类的表中

多重继承（有虚函数覆盖）

注：

一、::是运算符中等级最高的，表示作用域和所属关系，它分为三种：

1）global scope（全局作用域符），用法（::name）

2）class scope（类作用域符），用法（class::name）

3）namespace scope（命名空间作用域符），用法（namespace::name）

例5：类作用域

#include <iostream>using namespace std;class First{public:int memi;double memd;};class Second{public:int memi;double mend;}void main(){First f;Second s = f;}

提示错误：不存在用户定义的从"First"到"Second"的适当转换。每个类都定义了自己的新作用域和唯一的类型。两个不同的类具有两个不同的类作用域。即使两个类具有完全相同的成员列表，它们也是不同的类型。每个类的成员不同于任何其他类的成员。

结束语

C++这门语言是一门Magic的语言，对于程序员来说，我们似乎永远摸不清楚这门语言背着我们在干什么。需要熟悉这门语言，我们就必须了解C++里面的那些东西，需要去了解C++中那些危险的东西。不然，这是一种搬起石头砸自己的脚的编程语言。

参考：

http://www.cnblogs.com/xkfz007/archive/2012/05/11/2496447.html

http://blog.csdn.net/weizhee/article/details/562833

http://blog.csdn.net/wuchuanpingstone/article/details/6742465