知识点17

类的的6个默认成员函数：包括构造函数、析构函数、拷贝构造函数、赋值重载和取地址重载。构造函数主要完成初始化工作，析构函数完成清理工作。拷贝构造是使用同类对象初始化创建对象，赋值重载是把一个对象赋值给另一个对象，这两个操作区别就是前者只有一个对象，后者有两个。取地址重载主要是对普通对象和 const 对象取地址，这里是两个函数普通对象和 const 对象不同。默认成员函数用户没有显示实现，编译器会自动生成称为默认成员函数。

知识点18

构造函数：构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，在对象的整个生命周期内只调用一次。

特征有：

（1）函数名与类名相同。

（2）无函数返回值。(也不需要写 void)

（3）对象实例化时编译器自动调用对应的构造函数。

（4）构造函数可以重载，可能有多种初始化方式。

class Date
{
    public:
        //1.无参构造函数
        Date()
        {}

        //2.带参构造函数
        Date(int year, int month, int day)
        {
            _year = year;
            _month = month;        
            _day = day;
        }
    private:
        int _year;
        int _month;
        int _day;
};

void TestDate()
{
    Date d1;    //调用无参构造函数，无需在后面加括号，否则就成了函数声明
    Date d2(2015, 1, 1);    //调用带参的构造函数
    
    Date d3();//声明了d3函数，该函数无参，返回一个Date类对象
}

如果类中没有显示定义构造函数，则 C++编译器会自动生成一个无参的构造函数，一旦用户显式定义将不再自动生成。

参数有两类，一类内置类型（基本类型），语言本身定义的基础类型 int/char/double/指针等等；另一类自定义类型用 struct/class 等定义的。我们不写，编译器自动生成的构造函数内置类型不做处理，但是有些编译器做了优化可以处理（不是全部都有），其次就是 C++11打了补丁可以给缺省值初始化；自定义类型成员，会调用他的默认构造函数。

总之，一般情况下，构造函数都需要我们自己写，只有当内置类型成员都有缺省值且初始化符合我们的要求或全是自定义类型的成员且都定义了默认构造时，可不用自己写。

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数，全缺省构造函数，我们没写编译器默认生成的构造函数，都可认为是默认构造。

知识点19

析构函数：析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。跟构造函数一样，编译器自己生成的析构函数内置类型也是不处理，只处理自定义类型。

特征有：

（1）析构函数名是在类名前加上字符 ~ 。

（2）无参数无返回值类型。

（3）一个类只能有一个析构函数。若未显示定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。

（4）对象生命周期结束时，C++ 编译系统自动调用析构函数。

typedef int DataType;
class Stack
{
    public:
        Stack(size_t capacity = 3)
        {
            _array = (DataType*)malloc(sizeof(DataType) * capacity);
            if(NULL  = _array)
            {
                perror("malloc申请空间失败");
                return;
            }

            _capacity = capacity;
            _size = 0;
        }
        
        void Push(DataType data)
        {
            //checkCapacity()此处应对容量进行检查，不够时扩容        
            _array[_size] = data;
            _size++;
        }

        ~Stack()
        {
            if(_array)
            {
                free(_array);
                _array = NULL;
                _capacity = 0;
                _size = 0;
            }
        } 
        
        private:
            DataType* _array;
            int _capacity;
            int _size;
};

void TestStack()
{
    Stack s;
    s.Push(1);
    s.Push(2);
}

一般情况，有动态申请资源，就需要显式写析构函数释放资源（比如栈）。

没有动态申请资源，不需要析构函数（如日期类）。

需要释放资源的成员都是自定义类型，不需要写析构（如队列）。

知识点20

拷贝构造函数：只有单个形参，该形参是对本类类对象的引用（一般常用 const修饰），在用已存在的类类型对象创建新对象时由编译器自动调用。

特征是：

（1）拷贝构造函数是构造函数的一个重载形式。

（2）拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。C++规定传参时自定义类型必须调用拷贝构造，内置类型直接拷贝。

（3）若未显式定义，编译器会自动生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者指拷贝。注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式拷贝的（浅拷贝/值拷贝），而自定义类型是调用其拷贝构造函数完成拷贝的。

class Time
{
    public:
        Time()
        {
            _hour = 1;
            _minute = 1;
            _second = 1;
        }

        Time(const Time& t)
        {
             _hour = t._hour;
            _minute = t._minute;
            _second = t._second;
            cout << "Time::Time(const Time& t)" << endl;
        }
    private:
        int _year;
        int _minute;
        int _second;
};

类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。拷贝构造函数的使用场景：使用已存在对象创建新对象、函数参数类型为类类型对象或函数返回值类型为类类型对象。

知识点21

运算符重载：C++ 为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通函数类似。运算符有几个操作数，重载就有几个参数。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator 操作符(参数列表)

注意：

（1）不能通过连接其他符号来创建新的操作符：比如 operator@

（2）重载操作符必须有一个类类型参数

（3）用于内置类型的运算符，其含义不能改变，例如：内置整型+，不能改变其含义

（4）作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的 this。

（5）.*   : :   sizeof   ?:   .   注意以上5个运算符不能重载。

知识点22

赋值运算符重载：

赋值运算符重载格式：

参数类型：const T&，传递引用可以提高传参效率。

返回值类型：T&，返回引用可以提高返回的效率，有返回值的目的是为了支持连续赋值

检测是否自己给自己赋值

返回*this：要符合连续赋值的含义

class Date
{
public:
        
    //......

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

    //......
};

赋值运算符只能重载成类的成员函数不能重载成全局函数，其他运算符重载可定义为全局函数。原因是赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。默认生成的赋值重载跟拷贝构造行为一样：内置类型成员——值拷贝/浅拷贝；自定义类型成员会去调用他的赋值重载。

注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。