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