析构函数

析构函数(destructor)也是一个特殊的成员函数，它的作用与构造函数相反，它的名字是类名的前面加一个“～”符号。

在C++中“～”是位取反运算符，从这点也可以想到：

析构函数是与构造函数作用相反的函数。

当对象的生命期结束时，会自动执行析构函数。

具体地说如果出现以下几种情况，程序就会执行析构函数：

①如果在一个函数中定义了一个对象(它是自动局部对象)，当这个函数被调用结束时，对象应该释放，在对象释放前自动执行析构函数。

②static局部对象在函数调用结束时对象并不释放，因此也不调用析构函数，只在main函数结束或调用exit函数结束程序时，才调用static局部对象的析构函数。

③如果定义了一个全局对象，则在程序的流程离开其作用域时(如main函数结束或调用exit函数) 时，调用该全局对象的析构函数。

④如果用new运算符动态地建立了一个对象，当用delete运算符释放该对象时，先调用该对象的析构函数。

析构函数的作用并不是删除对象，而是在撤销对象占用的内存之前完成一些清理工作，使这部分内存可以被程序分配给新对象使用。

程序设计者事先设计好析构函数，以完成所需的功能，只要对象的生命期结束，程序就自动执行析构函数来完成这些工作。

析构函数不返回任何值，没有函数类型，也没有函数参数。

因此它不能被重载。

一个类可以有多个构造函数，但只能有一个析构函数。

实际上，析构函数的作用并不仅限于释放资源方面，它还可以被用来执行“用户希望在最后一次使用对象之后所执行的任何操作”，例如输出有关的信息。

这里说的用户是指类的设计者，因为，析构函数是在声明类的时候定义的。

也就是说，析构函数可以完成类的设计者所指定的任何操作。

一般情况下，类的设计者应当在声明类的同时定义析构函数，以指定如何完成“清理”的工作。

如果用户没有定义析构函数，C++编译系统会自动生成一个析构函数，但它只是徒有析构函数的名称和形式，实际上什么操作都不进行。

想让析构函数完成任何工作，都必须在定义的析构函数中指定。

例9.5 包含构造函数和析构函数的C++程序。

#include

#include

using namespace std;

class Student //声明Student类

{public :

student(int n,string nam,char s ) //定义构造函数

{num=n;

name=nam;

***=s;

cout<<″Constructor called.″<<endl; //输出有关信息

}

~Student( ) //定义析构函数

{cout<<″Destructor called.″<<endl;} //输出有关信息

void display( ) //定义成员函数

{cout<<″num: ″<<num<<endl;

cout<<″name: ″<<name<<endl;

cout<<″***: ″<<***<<endl<<endl; }

private :

int num;

char name[10];

char ***;

};

int main( )

{Student stud1(10010,″Wang_li″,′f′); //建立对象stud1

stud1.display( ); //输出学生1的数据

Student stud2(10011,″Zhang_fun″,′m′); //定义对象stud2

stud2.display( ); //输出学生2的数据

return 0;

}

程序运行结果如下：

Constructor called.

num: 10010

name:Wang_li

***: f

Constructor called.

num: 10011

name:Zhang_fun

***:m

Destructor called.

Destructor called.

(执行stud1的构造函数) (执行stud1的display函数)

(执行stud2的构造函数) (执行stud2的display函数)

(执行stud2的析构函数) (执行stud1的析构函数)

9.3 调用构造函数和析构函数的顺序

在使用构造函数和析构函数时，需要特别注意对它们的调用时间和调用顺序。

在一般情况下，调用析构函数的次序正好与调用构造函数的次序相反：最先被调用的构造函数，其对应的(同一对象中的)析构函数最后被调用，而最后被调用的构造函数，其对应的析构函数最先被调用。

如图9.1示意。

图9.1

但是，并不是在任何情况下都是按这一原则处理的。

在第4章第4.11和4.12节中曾介绍过作用域和存储类别的概念，这些概念对于对象也是适用的。

对象可以在不同的作用域中定义，可以有不同的存储类别。

这些会影响调用构造函数和析构函数的时机。

下面归纳一下什么时候调用构造函数和析构函数：

(1) 在全局范围中定义的对象(即在所有函数之外定义的对象)，它的构造函数在文件中的所有函数(包括main函数)执行之前调用。

但如果一个程序中有多个文件，而不同的文件中都定义了全局对象，则这些对象的构造函数的执行顺序是不确定的。

如果函数被多次调用，则只在第一次建立对象时调用构造函数

当main函数执行完毕或调用exit函数时(此时程序终止)，调用析构函数。

(2) 如果定义的是局部自动对象(例如在函数中定义对象)，则在建立对象时调用其构造函数。

如果函数被多次调用，则在每次建立对象时都要调用构造函数。

在函数调用结束、对象释放时先调用析构函数。

(3) 如果在函数中定义静态(static )局部对象，则只在程序第一次调用此函数建立对象时调用构造函数一次，在调用结束时对象并不释放，因此也不调用析构函数，只在main函数结束或调用exit函数结束程序时，才调用析构函数。

构造函数和析构函数在面向对象的程序设计中是相当重要的。

以上介绍了最基本的、使用最多的普通构造函数，在本章第9.8节中将会介绍复制构造函数，在第10章第10.7节中还要介绍转换构造函数。

9.4 对象数组数组不仅可以由简单变量组成(例如整型数组的每一个元素都是整型变量)，也可以由对象组成(对象数组的每一个元素都是同类的对象)。

在日常生活中，有许多实体的属性是共同的，只是属性的具体内容不同。

例如一个班有50个学生，每个学生的属性包括姓名、性别、年龄、成绩等。

如果为每一个学生建立一个对象，需要分别取50个对象名。

用程序处理很不方便。

这时可以定义一个“学生类”对象数组，每一个数组元素是一个“学生类”对象。

例如

Student stud[50];

//假设已声明了Student类，定义stud数组，有50个元素

在建立数组时，同样要调用构造函数。

如果有50个元素，需要调用50次构造函数。

在需要时可以在定义数组时提供实参以实现初始化。

如果构造函数只有一个参数，在定义数组时可以直接在等号后面的花括号内提供实参。

如

Student stud[3]={60,70,78};

//合法，3个实参分别传递给3个数组元素的构造函数

如果构造函数有多个参数，则不能用在定义数组时直接提供所有实参的方法，因为一个数组有多个元素，对每个元素要提供多个实参，如果再考虑到构造函数有默认参数的情况，很容易造成实参与形参的对应关系不清晰，出现歧义性。

例如，类Student的构造函数有多个参数，且为默认参数：

Student:: Student(int=1001,int=18,int=60);

//定义构造函数，有多个参数，且为默认参数

如果定义对象数组的语句为

Student stud[3]={1005,60,70};

在程序中最好不要采用这种容易引起歧义性的方法。

编译系统只为每个对象元素的构造函数传递一个实参，所以在定义数组时提供的实参个数不能超过数组元素个数，如

Student stud[3]={60,70,78,45};

//不合法，实参个数超过对象数组元素个数

那么，如果构造函数有多个参数，在定义对象数组时应当怎样实现初始化呢？回答是：在花括号中分别写出构造函数并指定实参。

如果构造函数有3个参数，分别代表学号、年龄、成绩。

则可以这样定义对象数组：

Student Stud[3]={ //定义对象数组

Student(1001,18,87), //调用第1个元素的构造函数，为它提供3个实参

Student(1002,19,76), //调用第2个元素的构造函数，为它提供3个实参

Student(1003,18,72) //调用第3个元素的构造函数，为它提供3个实参

};

在建立对象数组时，分别调用构造函数，对每个元素初始化。

每一个元素的实参分别用括号包起来，对应构造函数的一组形参，不会混淆。

例9.6 对象数组的使用方法。

#include

using namespace std;

class Box

{

public :

Box(int h=10,int w=12,int len=15): height(h),width(w),length(len){ } //声明有默认参数的构造函数，用参数初始化表对数据成员初始化

int volume( );

private :

int height;

int width;

int length;

}; int Box::volume( ) {return (height*width*length); }

int main( )

{ Box a[3]={ //定义对象数组

Box(10,12,15), //调用构造函数Box，提供第1个元素的实参

Box(15,18,20), //调用构造函数Box，提供第2个元素的实参

Box(16,20,26) //调用构造函数Box，提供第3个元素的实参

};

cout<<″volume of a[0] is ″<<a[0].volume( )<<endl;

cout<<″volume of a[1] is ″<<a[1].volume( )<<endl;

cout<<″volume of a[2] is ″<<a[2].volume( )<<endl;

}

运行结果如下：

volume of a[0] is 1800

volume of a[1] is 5400

volume of a[2] is 8320

9.5 对象指针

9.5.1 指向对象的指针

在建立对象时，编译系统会为每一个对象分配一定的存储空间，以存放其成员。

对象空间的起始地址就是对象的指针。

可以定义一个指针变量，用来存放对象的指针。

如果有一个类：

class Time

{public :

int hour;

int minute;

int sec;

void get_time( );

};

void Time::get_time( )

{cout<<hour<<″:″<<minute<<″:″<<sec<<endl;}

在此基础上有以下语句：

Time *pt; //定义pt为指向Time类对象的指针变量

Time t1; //定义t1为Time类对象

pt=&t1; //将t1的起始地址赋给pt

这样，pt就是指向Time类对象的指针变量，它指向对象t1。

定义指向类对象的指针变量的一般形式为

类名 *对象指针名；

可以通过对象指针访问对象和对象的成员。

如

(*pt).hour

pt->hour

(*pt).get_time ( )

pt->get_time ( )

 

pt所指向的对象，即t1。

pt所指向的对象中的hour成员，即t1.hour

pt所指向的对象中的hour成员，即t1.hour 调用pt所指向的对象中的get_time函数，即t1.get_time 调用pt所指向的对象中的get_time函数，即t1.get_time

9.5.2 指向对象成员的指针

对象有地址，存放对象初始地址的指针变量就是指向对象的指针变量。

对象中的成员也有地址，存放对象成员地址的指针变量就是指向对象成员的指针变量。

1. 指向对象数据成员的指针定义指向对象数据成员的指针变量的方法和定义指向普通变量的指针变量方法相同。

例如

int *p1; //定义指向整型数据的指针变量

定义指向对象数据成员的指针变量的一般形式为数据类型名 *指针变量名；如果Time类的数据成员hour为公用的整型数据，则可以在类外通过指向对象数据成员的指针变量访问对象数据成员hour。

p1=&t1.hour;

//将对象t1的数据成员hour的地址赋给p1，p1指向t1.hour

cout<<*p1<<endl;

//输出t1.hour的值

2. 指向对象成员函数的指针需要提醒读者注意： 定义指向对象成员函数的指针变量的方法和定义指向普通函数的指针变量方法有所不同。

成员函数与普通函数有一个最根本的区别： 它是类中的一个成员。

编译系统要求在上面的赋值语句中，指针变量的类型必须与赋值号右侧函数的类型相匹配，要求在以下3方面都要匹配：

函数参数的类型和参数个数；

②函数返回值的类型；

③所属的类。

定义指向成员函数的指针变量应该采用下面的形式：

void (Time::*p2)( );

//定义p2为指向Time类中公用成员函数的指针变量

定义指向公用成员函数的指针变量的一般形式为

 

数据类型名 (类名::*指针变量名)(参数表列)；

可以让它指向一个公用成员函数，只需把公用成员函数的入口地址赋给一个指向公用成员函数的指针变量即可。

如

p2=&Time::get_time;

使指针变量指向一个公用成员函数的一般形式为

指针变量名=&类名::成员函数名;

例9.7 有关对象指针的使用方法。

#include

using namespace std;

class Time

{public:

Time(int,int,int);

int hour;

int minute;

int sec;

void get_time( );

};

Time::Time(int h,int m,int s)

{hour=h;

minute=m;

sec=s;

}

void Time::get_time( ) //声明公有成员函数

//定义公有成员函数

{cout<<hour<<″:″<<minute<<″:″ <<sec<<endl;}

int main( )

{Time t1(10,13,56); //定义Time类对象t1

int *p1=&t1.hour; //定义指向整型数据的指针变量p1，并使p1指向t1.hour

cout<<* p1<<endl; //输出p1所指的数据成员t1.hour

t1.get_time( ); //调用对象t1的成员函数get_time

Time *p2=&t1; //定义指向Time类对象的指针变量p2，并使p2指向t1

p2->get_time( ); //调用p2所指向对象(即t1)的get_time函数

void (Time::*p3)( ); //定义指向Time类公用成员函数的指针变量p3

p3=&Time::get_time; //使p3指向Time类公用成员函数get_time

(t1.*p3)( ); //调用对象t1中p3所指的成员函数(即t1.get_time( ))

}

程序运行结果为

10 (main函数第4行的输出)

10:13:56 (main函数第5行的输出)

10:13:56 (main函数第7行的输出)

10:13:56 (main函数第10行的输出)

可以看到为了输出t1中hour,minute和sec的值，可以采用3种不同的方法。

说明：

(1) 从main函数第9行可以看出：成员函数的入口地址的正确写法是： &类名::成员函数名。

(2) main函数第8、9两行可以合写为一行：

void (Time::*p3)( )=&Time::get_time; //定义指针变量时指定其指向