构造函数与析构函数（基础知识回顾）

1.构造函数

      在对象被创建时利用特定的初始值构造对象，把对象置于某一个初始状态。它在对象被创建的时候由系统自动调用，我们只需要使用默认的构造函数或者自己定义构造函数，而不用管系统怎么调用它。函数名与类名一致，且无返回值。

 class Clock
        {
        public:
                  Clock(int H, int M, int S);              //构造函数
                  void ShowTime();
        private:
                  int Hour, Minute, Second;
        };

        构造函数的实现：
        Clock::Clock(int H, int M, int S)
        {
                 Hour=H;
                 Minute=M;
                 Second=S;
        }

        建立对象时构造函数的作用：
        int main()
        {
                Clock c(0,0,0); //隐含调用构造函数，将初始值作为实参。
                c.ShowTime();
                return 0;
        }

       构造函数也是一个成员函数，所以它可以直接访问类的所有数据成员，可以是内联函数，可以带有形参表，可以带默认的形参值，也可以重载，就是有若干个名字相同但形参个数或者类型不同的构造函数。自己声明了构造函数，系统就不会调用默认的了，而且可以自己在构造函数中进行一些初始化操作。

2.拷贝构造函数

      拷贝构造函数的作用是将一个对象的内容拷贝给相同类的另一个对象。拷贝构造函数的形参是本类的对象的引用。

用法如下：

class Point
       {
       public:
                   Point(int xx=0,int yy=0)    {X=xx; Y=yy;}    //构造函数
                   Point(Point &p);                             //拷贝构造函数
       private:
                   int  X, Y;
       };

      Point::Point(Point &p)
      {
                  X=p.X;
                  Y=p.Y;
                  cout<<"拷贝构造函数被调用"<<endl;
      }

 拷贝构造函数在以下三种情况下会被调用：

 a.当用类的一个对象去初始化该类的另一个对象时系统自动调用拷贝构造函数实现拷贝赋值。

 Point A(1,2);
 Point B(A); //拷贝构造函数被调用

 b.函数的形参为类对象，调用函数时，实参赋值给形参，系统自动调用拷贝构造函数。例如：

  void fun1(Point p)
       {  
                cout<<p.GetX()<<endl;
       }
       int main()
       {  
               Point A(1,2);
               fun1(A); //调用拷贝构造函数
               return 0;
       }     

c.函数的返回值是类对象时，系统自动调用拷贝构造函数。例如：

 Point fun2()
       {   
              Point A(1,2);
              return A; //调用拷贝构造函数
       }
       int main()
       {
             Point B;
             B=fun2();
             return 0;
       }

3.析构函数

      在对象被删除之前做一些清理工作。析构函数是在对象要被删除时由系统自动调用的，它执行完后对象就消失了，分配的内存空间也释放了。

      析构函数是类的一个公有函数成员，它的名称是在类名前加“~”形成，没有返回值，也不能有任何形参。如果没有定义析构函数系统也会自动生成一个默认析构函数，默认析构函数不会做任何工作。所以一般如果想在对象被删除之前做什么工作，就可以把它写到析构函数里。

 class Point
       {    
       public:
                   Point(int xx, int yy);
                   ~Point();
                   //...其他函数原型
       private:
                  int X, int Y;
                  char *p;
       };

       下面是构造函数和析构函数的实现：

       Point::Point(int xx,int yy)
       {     
                 X=xx;   
                 Y=yy;
                 p=new char[20];     // 构造函数中动态分配char型内存
       }
       Point::~Point()
       {
                delete []char;      // 在类析构时释放之前动态分配的内存
       }