C++ 对象的初始化
构造函数和析构函数

　　构造函数和析构函数是在类体中说明的两种特殊的成员函数。构造函数的功能是在创建对象时，使用给定的值来将对象初化。析构函数的功能是用来释放一个对象的，在对象删除前，用它来做一些清理工作，它与构造函数的功能正好相反。下面举一例子来说明构造函数和析构函数的特点：

　　class TDate
　　{
　　　　public:
　　　　TDate(int y, int m, int d);
　　　　~TDate();
　　　　int IsLeapYear();
　　　　void Print();
　　private:
　　　　int year, month, day;
　　};

　　//类的实现部分
　　TDate::TDate(int y, int m, int d)
　　{
　　　　year = y;
　　　　month = m;
　　　　day = d;
　　cout<<"构造函数已被调用。\n";
　　}

　　TDate::~TDate()
　　{
　　　　cout<<"析构函数被调用。\n";
　　}

　　int TDate::IsLeapYear()
　　{
　　　　return(year%4==0 && year%100!=0) || (year%400==0);
　　}

　　void TDate::Print()
　　{
　　　　cout<
　　}

　　类体内说明的函数TDate()是构造函数，而~Tdate()是析构函数。构造函数的特点如下：

　　1、构造函数是成员函数，函数体可写在类体内，也可定在类体外。

　　2、构造函数是一个特殊的函数，该函数的名字与类名相同，该函数不指定类型说明，它有隐含的返回值，该值由系统内部使用。该函数可以一个参数，也可以有多个参数。

　　3、构造函数可以重载，即可以定义多个参数个数不同的函数。

　　4、程序中不能直接调用构造函数，在创建对象时系统自动调用构造函数。

　　析构函数的特点如下：

　　1、析构函数是成员函数，函数体可写在类体内，也可定在类体外。

　　2、析构函数也是一个特殊的函数，它的名字同类名，并在前面加“~”字符，用来与构造函数加以区别。析构函数不指定数据类型，并且也没有参数。

　　3、一个类中只可能定义一个析构函数。

　　4、析构函数可以被调用，也可以系统调用。在下面两种情况下，析构函数会被自动调用。

　　·如果一个对象被定义在一个函数体内，则当这个函数结束时，该对象的析构函数被自动调用。

　　·当一个对象是使用new运算符被动态创建的，在使用delete运算符释放它时，delete将会自动调用析构函数。

　　下面用一程序说明构造函数和析构函数的应用：

　　#include
　　#include
　　#include "tdate.h"　　　　//类的定义存放在该文件中

　　void main()
　　{
　　TDate today(1998, 4, 9), tomorrow(1998, 4, 10);
　　cout<<"Today is:";
　　today.Print();
　　cout<<"Tomorrow is:";
　　tomorrow.Print();
　　getch();
　　}

　　读者可以自行调试该程序，并分析其结果。要在VC环境下调试该程序，要对程序进行一些参数设置，否则无法正常运行(主要是去掉MFC的支持——该程序无需MFC的支持)。

　　缺省构造函数和缺省析构函数

　　在类定义时没有定义任何构造函数时，则编译器自动生成一个不带参数的缺省构造函数，其格式如下：

　　<类名>::<缺省构造函数名>()
　　{
　　}

　　按构造函数的规定，缺省构造函数名同类名。缺省构造函数的这样格式也可由程序员定义在类体中。在程序中定义一个对象而没有指明初始化时，则编译器便按缺省构造函数来初始化该对象。用缺省构造函数对对象初始化时，则将对象的所有数据成员都初始化为零或空。

　　同理，如果一个类中没有定义析构函数时，则编译系统也生成一个称为缺省析构函数数，其格式如下：

　　<类名>::~<缺省析构函数名>
　　{
　　}

　　<缺省析构函数名>即为该类的类名。缺省析构函数是一个空函数

拷贝初始化构造函数

　　拷贝初始化构造函数是一种特殊的成员函数，它的功能是用一个已知的对象来初始化一个被创建的同类的对象。拷贝初始化构造函数实际上也是构造函数，它是在初始化时被调用来将一个已知对象的数据成员的值拷贝给正在创建的另一个同类的对象。

　　拷贝衩始化构造函数的特点如下：

　　1、该函数名同类名，因为它也是一种构造函数，并且该函数也不被指定返回类型。

　　2、该函数只有一个参数，并且是对某个对象的引用。

　　3、每个类都必须有一个拷贝初始化构造函数，其格式如下：

　　<类名>::<拷贝初始化构造函数名>(const<类名>&<引用名>)

       其中，<拷贝初始化构造函数名>是与该类名相同的。const是一个类型修饰符，被它修饰的对象是一个不能被更新的常量。

　　如果类中没有说明拷贝初始化构造函数，则编译系统自动生成一个具有上术形式的缺省拷贝初始化构造函数。作为该类的公有成员。

　　下面举一例子说明拷贝初始化构造函数

　　class TPoint
　　{
　　　　public:
　　　　TPoint(int x, int y) {X=x; Y=y;}
　　　　 TPoint(TPoint & p);
　　　　~TPoint() {cout<<"析构函数被调用。\n";}
　　　　int Xcoord() {return X;}
　　　　int Ycoord() {return Y;}
　　　　private:
　　　　int X, Y;
　　};

　　TPoint::TPoint(TPoint & p)
　　{
　　　　X = p.X;
　　　　Y = p.Y;
　　　　cout<<"拷贝初始化构造 函数被调用。\n";
　　}

　　#include
　　void main()
　　{
　　TPoint P1(5, 7);
　　TPoint P2(P1);
　　cout<<"P2="<
　　}

　　该程序的输出结果为：

　　拷贝初始化构造函数被调用。
　　P2=5,7
　　析构函数被调用。
　　析构函数被调用。

　　关于拷贝初始化构造函数的其他用法，可从下例看出：

　　#include
　　#include "tpont.h"    //类的定义放于该文件中
　　TPoint f(TPoint Q);
　　void main()
　　{
　　TPoint M(20, 35),P(0, 0);
　　TPoint N(M);
　　P = f(N);
　　cout<<"P="<
　　}

　　TPoint f(TPoint Q)
　　{
　　cout<<"ok\n";
　　int x, y;
　　X = Q.Xcoord()+10;
　　Y = Q.Ycoord()+20;
　　TPoint R(x, y);
　　return R;
　　}

　　请大家自行调试该程序，并分析其结果。

　　总结：拷贝初始化构造函数的功能就是用一个已知的对象来初始化另一个对象。在下述三种情况下，需要用拷贝初始化构造函数来用一个对象初始化另一个对象。

　　1、明确表示由一个对象初始化另一个对象时，如：TPoint P2(P1);

　　2、当对象作为函数实参传递给函数形参时，如：上例 P = f(N);

　　3、当对象用为函数返回值时，如：上例 return R;