类的默认成员函数

• 类的默认成员函数
  构造函数
  构造函数是为了初始化在类中定义的私有成员变量，且在定义创建对象时自动执行一次的公有成员函数。
  专属特征：
  1>,构造函数的函数名与类名相同，且无返回值；
  2>,构造函数定义在类内类外都是可以的,定义在类外时要用 :: 进行说明是哪个类；
  3>,构造函数支持重载；
  4>,构造函数是特殊的成员函数没有隐含的this形参；
  5>,构造函数在实例化对象是自动调用，如果没有在类中定义构造函数时，编译器会自动生成一个缺省的构造函数，缺省的构造函数只能有一个。

class Time
{
   public:
         Time()  //无参的构造函数相当于默认的构造函数
         {
            //空
         }
         Time(int hour,int minute,int second)//有参的构造函数
         {
             _hour=hour;
             _minute=minute;
             _second=second;
         }
         Time(int hour=9,int minute=54,int second=23)//全缺省构造函数
         {
            _hour=hour;
            _minute=minute;
            _second=second;
         }
         Time(int hour,int minute=12,int second=30) //半缺省构造函数
         {
            _hour=hour;
            _minute=minute;
            _second=second;
         }
   private:
        int _hour;
        int _minute;
        int _second;
}
void Test()
{
   Time T1;//定义对象T1时自动调用无参构造函数，注意调用时不用加()
   Time T2(13,24,05);//定义对象T2时自动调用有参构造函数
   Time T3;//调用全缺省构造函数
   Time T4(12);//调用半缺省构造函数
}

拷贝构造函数
拷贝构造函数是用已有的对象初始化新的对象，是特殊的构造函数。
专属特征
1>,拷贝构造函数是构造函数的重载；
2>,如果拷贝构造函数未定义，编译器会自动生成缺省的拷贝构造函数，会依次拷贝类成员，称为浅拷贝或值拷贝；
3>,拷贝构造函数的须用引用进行传参，如：Time(const Time& T) .
疑问：如果采用值传递会出现什么情况？
传值方式会引发无穷递归调用，这是为什么呢……

class Time
{
 public:
      Time()//这里一定要写上构造函数，因为拷贝构造函数也属于构造函数，当有拷贝构造函数时，编译器不会生成默认的构造函数
        {
        }
        Time(Time T)//值传递
        {
           _hour=T._hour;
           _minute=T._minute;
           _second=T._second;
        }
 private:
         int _hour;
         int _minute;
         int _second;
}
void Test()
{
   Time T1;
   Time T2(T1);//Time T2=T1;（等价）
}

当T2初始化的时候调用了T2的拷贝构造函数，由于是值传递方式,编译器会给T分配一块临时空间，调用自身的拷贝构造函数把T1数据成员的值传给T，当调用自身的拷贝构造函数的时候又因为是值传递又会调用自身的拷贝构造函数，一直是值传递就会一直调用拷贝构造函数，无穷调用.

析构函数
析构函数是在对象生命周期结束的时候自动调用的一个成员函数，与构造函数的功能相反。
专属特征
1>,析构函数无参数，无返回值，函数名与类名相同前面加~；
2>,如果没有定义析构函数，编译器会自动生成缺省的析构函数，且一个类只能有一个析构函数，在对象生命周期结束的时候自动调用；
3>,析构函数的作用不是删除对象，而是撤销对象占用的内存之前做一些清理工作，可以将这部分内存分配给其他新对象；
4>,一般情况下，先调用的构造函数，其对应的析构函数会最后被调用。

#include<iostream>
using namespace std;
class Time
{
public:
    Time(int hour = 9, int minute = 54, int second = 23) 
    {
        _hour = hour;
        _minute = minute;
        _second = second;
    }
    ~Time()
    {
        cout <<  "tranfered" << endl;
    }
    void show()
    {
        cout << _hour << " " << _minute << " " << _second << endl;
    }
private:
    int _hour;
    int _minute;
    int _second;

};

int main()
{
    Time T;
    T.Time::~Time();
    T.show();
    system("pause");
    return 0;
}

调用析构函数以后，还输出了对象T的数据成员值，说明析构函数不释放对象。