类的六个默认成员函数

类的六个默认成员函数：
1.构造函数
2.拷贝构造函数
3.析构函数
4.赋值操作符重载
5.取地址操作符重载
6.const修饰的取地址操作符重载

构造函数：是一个特殊的成员函数，名字与类名相同，创建类类型对象时，由编译器自动调用，在对象的生命周期内只且只调用一次，以保证每个数据成员都有一个合适的初始值。
公有成员函数，仅在定义对象时自动执行一次。
特点：
1.函数名与类名相同。
2.对象构造时自动调用。
3.无返回值。
4.可以重载。
5.可以在类内外定义。
6.如果无构造函数，编译器自动产生一个缺省的构造函数。
7.无参和全缺省值的构造函数都认为是缺省构造函数，并且缺省构造函数之能有一个。
如下例:

class CDate
{
public:
   CDate()
   {}
   CDate(int year,int month,int day)
   {
     _year=year;
     _month=month;
     _day=day;
    }
     private:
     int _year;
     int _month;
     int _day;
} 

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个数据成员后面跟一个放在圆括号中的初始化式。
类中包含以下成员必须要放在初始化列表中初始化：
1.引用数据成员
2.const数据成员
3.类类型成员
初始化举例：

class CDate
{
public:
   CDate(int year,int month,int day)
   :_year(year)
   ,_month(month)
   ,_day(day)
   {}
     private:
     int _year;
     int _month;
     int _day;
} 

拷贝构造函数：只有单个形参，而且该形参是对本类类型对象的引用（常用const修饰的）。

举例作用：创建对象时使用同类对象来进行初始化。 CDate(const CDate&date)
特点：
1.是构造函数的一个重载。
2.必须使用引用传参，传值会无穷递归调用。
3.未定义时，编译器会自动生成一个默认缺省拷贝构造函数，缺省的拷贝构造函数会依次拷贝类成员进行初始化。 如下：

class CDate
{
public:
   CDate()
   {}
   CDate(int year,int month,int day)
   {
     _year=year;
     _month=month;
     _day=day;
    }
    CDate(const CDate&date)
    {
     _year=date._year;
     _month=date._month;
     _day=date._day;
     }
     private:
     int _year;
     int _month;
     int _day;
}; 

析构函数 ~Date()

作用：在对象声明周期结束时，调用的函数。（清除类本身分配的资源）;
特点：
1.函数名在类名前加上~；
2.无参数无返回值；
3.一个类只能有一个析构函数，若未定义，系统默认生成析构函数；
4.自动调用；
5.析构函数并非删除对象，而是做一些清理工作(释放空间);

class Array()
{
public:
Array(size_t) capacity)
:_capacity(capacity)
{
_ptr=(int*)malloc(capacity*sizeof(int));
_size=0;
}
~Array()//析构函数  清理工作
{  
        if(_ptr)
        {
            free(_ptr);
            _ptr=NULL;
        }

    _size=0;
    _capacity=0;
 }
private:
    int *_ptr;
    size_t _size;
    size_t _capaticy;
}

操作运算符重载：
作用：增强程序的可读性 关键词 ：operator
特点：
1.operator+合法的运算符构成函数名；
2.重载运算符，不可以改变，操作数个数，结合性；
3.不能重载的运算符 “*/ ” “:: ” “?: ” “. “;
输入输出运算符的重载：
对于自定义的类，不能直接通过
举例为：

class Date
{
public:
    Date(int year = 2017, int month = 9, int day = 10)
        : _year(year)
        , _month(month)
        , _day(day)
    {}

    Date& operator=(const Date& d)
    {
        if (this != &d)
         {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        return *this;
    }

若定义了友元函数时：友元函数可以访问类的私有成员。
友元函数： friend
1.友元函数可以直接访问类的私有成员，是定义在类外的函数。
2.友元函数不属于类的成员函数，但需要在类内声明(可以在类内的任何地方声明，所以友元函数不受访问限定符的限制)，声明时要加上关键字friend。
友元类：
整个类都可以是另一个类的友元函数，都可访问另一个类中的成员。

class Time
{
friend class Date;
//Date是 Time的友元，所以Date可以访问Time的所有成员 
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
public:
    void Display(){
        cout<<"year"<<_year<<endl;
        cout<<"month"<<_month<<endl;
        cout<<"day"<<_day<<endl;
        cout<<"hour"<<_hour<<endl;
        cout<<"minute"<<_minute<<endl;
        cout<<"second"<<_second<<endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

友元关系是单向的，不具有交换性。
友元关系无法传递。
友元关系无法继承。
取地址操作符重载: Date * operator&();
类的静态成员
1.static修饰的成员，称为静态类成员。
2.类的静态成员被该类型的所有对象所共享。
3.静态成员函数不会生成this指针，所以可以使用类型::作用域访问符调用静态成员函数。