1. 类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。

class Date {
   
   };

其实在==空类中并不是什么都没有==，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认成员函数： 用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

当我们平时在写数据结构的代码时，例如在写栈的代码时，可能会忘记初始化就去进行增删查改操作，在我们写完代码后可能忘记将我们初始化好的栈释放掉。这样会导致我们的代码出现一系列的问题，但我们又无法避免，所以C++在C语言的基础上增加了类的默认成员函数。其中构造函数、析构函数、拷贝构造和赋值运算符重载是我们重点讲解的内容。剩下两个平常用的很少，遇到的时候我们在后续讲解。

2. 构造函数

概念

当我们在使用类来初始化一个对象时，通常都需要调用他的Init公有方法给对象进行初始化。未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

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

构造函数有如下特性：

• 函数名与类名相同。
• 无返回值。
• 对象实例化时编译器自动调用对应的构造函数。
• 构造函数可以重载。
• 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
• 构造函数对内置类型不做处理，对于自定义类型会调用他的默认构造函数。
• 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

我们先来上手一个构造函数，来看一下他如何用。

我们可以看到编译器帮助我们自动调用了构造函数，而构造函数的功能就是帮助我们初始化对象，下面我们来看一下构造函数的几大特性。

特性

💕 (1) 构造函数支持重载和缺省参数

class Date
{
   
   
public:
    //无参构造函数
    Date()
    {
   
   
        _year = 1949;
        _month = 10;
        _day = 1;
    }
    //有参构造函数
    Date(int year, int month, int day)
    {
   
   
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
   
   
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
   
   
    Date d1;
    d1.Print();
    Date d2(2023,2,5);
    d2.Print();
    return 0;
}

这里我们可以看到构造函数是支持重载的，但是我们也需要注意一点：无参构造和有参全缺省的构造函数不能同时出现，因为在调用的时候会出现歧义。

最后我们还需要注意的是，当我们在==调用无参构造或者全缺省构造来初始化对象时，不要再对象后面带括号==，因为这会导致编译器分不清我们是在实例化对象还是再进行函数声明。

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

虽然编译器会给我们自动生成一个默认构造函数来完成初始化，但是为什么初始化的结果是一个随机值呢？这是因为构造函数对内置类型不做处理。下面我们会讲。

💕 (3) 构造函数对内置类型不做处理，对于自定义类型会调用他的默认构造函数。

C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：==int/char...==，自定义类型就是我们使用==class/struct/union==等自定义的类型。

这里我们使用stack类、MyQueue类、Date类三者进行一下对比：

class Date
{
   
   
public:
    void Print()
    {
   
   
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

class MyQueue {
   
   
public:
    // 默认生成构造函数，对自定义类型成员，会调用他的默认构造函数
    // 默认生成析构函数，对自定义类型成员，会调用他的析构函数
    void push(int x) {
   
   

    }
    //....
    Stack _pushST;
    Stack _popST;
    int _size = 0;
};
int main()
{
   
   
    Date d1;
    d1.Print();
    MyQueue q;
    return 0;
}

我们可以看到，编译器默认生成的构造函数对不会对内置类型进行处理，但是我们可以看到编译器调用了两次构造和两次析构函数对MyQueue类中的自定义类型进行了处理，而编译器调用的，恰恰是自定义类型中的默认构造函数。

注意： ==C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。==

class Date
{
   
   
public:
    void Print()
    {
   
   
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    //在类中声明时为内置类型提供默认值
    int _year= 1;
    int _month = 1;
    int _day = 1;
};

💕 (4) 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

我们知道，默认构造函数有三种：编译器自动提供的无参构造函数、自己定义的无参构造函数、自己定义的全缺省的构造函数。

但是，如果我们提供了有参构造函数，编译器就不会提供默认构造函数。

3. 析构函数

概念

与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

这里我们先来简单看一下析构函数的用法：

我们可以看到，析构函数和构造函数一样，都是由编译器帮助我们自动调用。

析构函数的特性：

• 析构函数名是在类名前加上字符 ~。
• 无参数无返回值类型。
• 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：==析构函数不能重载==。
• 对象生命周期结束时，C++编译系统系统自动调用析构函数
• 和构造函数一样，编译器生成的默认析构函数，对自定类型成员调用它的析构函数，对内置类型不做处理。

---

特性

那么我们什么时候需要使用析构函数呢？很显然，如果我们的类中没有进行资源的申请（动态开辟内存，打开文件等操作时），那么这个类在函数调用自动销毁时不需要我们做任何处理。所以，我们不需要写析构函数。

但如果我们定义的类中的成员变量指向了一块动态开辟的内存空间，那么我们就必须自己手动写析构函数，如果不处理就会造成内存泄露。

4. 拷贝构造函数

概念

在创建对象时，我们可以创建一个与已存在的对象一摸一样的新对象，那么这个功能就由我们的拷贝构造函数来完成。

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

下面我们先来看一下拷贝构造函数的基本用法：

拷贝构造函数的特性：

• 拷贝构造函数是构造函数的一个重载形式。 当我们使用拷贝构造实例话一个对象时，编译器不在调用构造函数。
• 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
• 若未显示定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
• 默认的拷贝构造函数对内置类型以字节为单位直接进行拷贝（浅拷贝），对自定义类型调用其自身的拷贝构造函数。

---

特征

💕 (1) 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

int main()
{
   
   
    Date d1(2023, 2, 5);
    d1.Print();
    Date d2(d1);
    d2.Print();
    return 0;
}

当我们使用传值的方式写拷贝构造函数时，编译器会直接报错，这是因为可能会引发无穷递归。

==那么为什么会引发无穷递归呢？原因是当我们创建d2对象时，编译器会自动调用拷贝构造函数，但是传值调用的时候形参是实参的一份临时拷贝，所以形参需要先拷贝一份实参，而拷贝的过程又需要调用拷贝构造函数，所以这样下去就会导致无穷递归。==

所以我们必须使用引用来做形参，这样的话在调用拷贝构造的时候，形参就是实参自己，那么就不需要再拷贝一份实参，拷贝构造函数直接就可以完成对待初始化对象的初始化。当然，我们在写拷贝构造函数的时候，一般都在前面加const，这样就可以避免对原对象的修改。

💕 (2) 若未显示定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

如果我们没有实现拷贝构造函数，编译器给我们自动生成一个默认拷贝构造函数。这个默认的拷贝构造函数对内置类型会完成浅拷贝，但如果我们的内置类型有进行资源的申请（例如：动态开辟内存）时，就会出现严重的问题，下面我们举例来看。

typedef int DataType;
class Stack {
   
   
public:
    //构造函数
    Stack()
    {
   
   
        cout << "构造函数Stack()" << endl;
        _array = (DataType*)malloc(sizeof(DataType) * 3);
        if (!_array)
        {
   
   
            perror("malloc fail::");
            exit(-1);
        }
        _capacity = 3;
        _top = 0;
    }
    //...

    //析构函数
    ~Stack()
    {
   
   
        cout << "析构函数~Stack()" << endl;
        if (_array)
        {
   
   
            free(_array);
            _array = nullptr;
        }
        _top = _capacity = 0;
    }
private:
    DataType* _array;
    int _top;
    int _capacity;
};
int main()
{
   
   
    Stack st1;
    Stack st2(st1);
    return 0;
}

当编译器自动生成的默认拷贝构造函数进行初始化栈时，我们发现两个对象中的_array指针竟然指向了同一块空间。这是因为编译器默认生成的拷贝构造函数拷贝数据时，是按照byte进行拷贝的，那么拷贝的时候自然也会将st1的地址拷贝给st2，这就导致了st2和st1指向了同一块空间。当主函数结束的时候，需要调用析构函数来销毁两个对象，但是由于两个对象中的_array都指向了同一块空间，所以导致了同一块空间被释放了两次。

这种情况不仅析构两次有问题，而且在插入数据时，一个对象的改变必然会覆盖另一个对象的数据，所以这种浅拷贝的问题会造成严重的后果，那么我们应该如何避免这种情况的发生呢？这个时候我们就得写一个深拷贝拷贝构造函数了。

Stack(const Stack& s)
    {
   
   
        _array = (DataType*)malloc(sizeof(DataType) * s._capacity);
        if (!_array)
        {
   
   
            perror("malloc fail::");
            exit(-1);
        }
        _top = s._top;
        _capacity = s._capacity;
    }

当然了，如果一个类的成员变量都是自定义类型的话，那么默认成员函数就会去调用成员变量的拷贝构造函数。

所以我们什么时候需要写拷贝构造函数呢？很简单，如果类中有资源申请我们就必须手动实现拷贝构造函数。如果没有的话那就直接使用类提供的默认拷贝构造即可。

拷贝构造函数典型调用场景：

• 使用已存在对象创建新对象
• 函数参数类型为类类型对象
• 函数返回值类型为类类型对象

---

5. 运算符重载

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

• ==函数名字==：关键字operator后面接需要重载的运算符符号。
• ==函数原型==：返回值类型 operator操作符(参数列表)

对于运算符的重载我们需要注意几点：

• 不能通过连接其他符号来创建新的操作符：比如operator@
• 重载操作符必须有一个类类型参数
• 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
• 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
• .* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

我们知道，类中的成员变量一般都是私有的，我们并不能在类外直接修改他们，所以当我们使用重载后的运算符去进行类实例化的对象的操作时，一般都会把运算符在类内进行重载。当我们在类内进行运算符重载时，只需要传递一个一个参数（右操作数），因为左操作数就是编译器给我们自动传递的this指针。这里我们需要注意，当我们将函数放在类内时，不管操作数有几个，this都默认指向第一个操作数。

5.1 前置++和后置++重载

class Date
{
   
   
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
   
   
        _year = year;
        _month = month;
        _day = day;
    }
    //重载前置++
    Date& operator++()
    {
   
   
        _day += 1;
        return *this;
    }
    //重载后置++
    Date operator++(int)
    {
   
   
        Date temp(*this);
        _day += 1;
        return temp;
    }
private:
    int _year;
    int _month;
    int _day;
};

这里我们需要注意的是：

• 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载，C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递。
• 后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1，而temp是临时对象，因此只能以值的方式返回，不能返回引用。

---

5.2 赋值运算符重载

赋值运算符重载作为类的六个默认成员函数之一，如果用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，所以像日期类这样的类是没有必要自己在去实现赋值运算符重载的了。

这里我们需要注意的是，Date d2 = d1是调用拷贝构造给d2完成初始化操作的，在创建对象时就会自动调用，而 Date d2；d2 = d1；这是调用赋值重载函数来给已经创建好的对象d2来完成初始化操作的。

所以，对于没有资源申请的类来说，并不需要写赋值重载函数，而对于有资源申请的类来说，我们必须显示的去调用赋值重载函数。否则不仅会导致赋值对象中动态分配的内存空间没有被释放，而且还会导致被赋值的对象指向的空格键析构两次，也就是造成了同一块空间被释放两次和内存泄漏两个严重的问题。

赋值运算符重载格式

• 参数类型： const T&，传递引用可以提高传参效率
• 返回值类型： T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
• 检测是否自己给自己赋值
• 返回*this ： 要复合连续赋值的含义

当然了，如果赋值的对象是被赋值对象本身的话，我们还可以加一个特殊判定，因为虽然程序不会出现任何的问题，但是赋值本身就是一次拷贝构造，会造成消耗。同时，如果需要实现连续赋值，就必须将赋值重载函数返回对象本身。

这里我们可以实现一下日期类的赋值重载函数：

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

赋值运算符只能重载成类的成员函数不能重载成全局函数

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

// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
   
   
    if (&left != &right)
    {
   
   
        left._year = right._year;
        left._month = right._month;
        left._day = right._day;
    }
    return left;
}

6. 日期类的实现

💕 Date.h

#pragma once
#include<iostream>
using namespace std;
#include<cassert>

class Date
{
   
   
public:
    friend ostream& operator<<(ostream& out, const Date& d);
    friend istream& operator>>(istream& in, Date& d);

    //打印函数
    void Print()const;

    //构造函数
    Date(int year = 1, int month = 1, int day = 1);

    //获取某个月的天数
    int GetMonthDay(int year, int month);

    //重载==运算符
    bool operator==(const Date &d)const;

    //重载!=运算符
    bool operator!=(const Date &d)const;

    //重载<运算符
    bool operator<(const Date& d)const;

    //重载<=运算符
    bool operator<=(const Date& d)const;

    //重载>运算符
    bool operator>(const Date& d)const;

    //重载>=运算符
    bool operator>=(const Date& d)const;

    //重载+=运算符
    Date& operator+=(int d);

    //重载+运算符
    Date operator+(int d)const;

    //重载-=运算符
    Date& operator-=(int d);

    //重载-运算符
    Date operator-(int d)const;

    //重载d1-d2运算符
    int operator-(const Date& d)const;

    //重载前置++
    Date& operator++();

    //重载后置++
    Date operator++(int);

    //重载前置--
    Date& operator--();

    //重载后置--
    Date operator--(int);

private:
    int _year;
    int _month;
    int _day;
};

//重载左移运算符
inline ostream& operator<<(ostream& out, const Date& d)
{
   
   
    out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
    return out;
}

inline istream& operator>>(istream& in, Date& d)
{
   
   
    in >> d._year >> d._month >> d._day;
    return in;
}

💕 Date.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"Date.h"

//构造函数
Date::Date(int year, int month, int day)
{
   
   
    assert(month < 13 && day <= GetMonthDay(year, month));
    _year = year;
    _month = month;
    _day = day;
}

//获取某个月的天数
int Date::GetMonthDay(int year, int month)
{
   
   
    assert(month > 0 && month < 13);
    int arr[13] = {
   
    0,31,28,31,30,31,30,31,31,30,31,30,31 };
    if (month == 2 && (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)))
    {
   
   
        return 29;
    }
    return arr[month];
}

//打印函数
void Date::Print()const
{
   
   
    cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

//重载==运算符
bool Date::operator==(const Date &d)const
{
   
   
    return (_year == d._year && _month == d._month && _day == d._day);
}

//重载!=运算符
bool Date::operator!=(const Date &d)const
{
   
   
    return !(*this == d);
}

//重载<运算符
bool Date::operator<(const Date& d)const
{
   
   
    return (_year < d._year)
        || ((_year == d._year) && (_month < d._month))
        || ((_year == d._year) && (_month == d._month) && (_day < d._day));
}

//重载<=运算符
bool Date::operator<=(const Date& d)const
{
   
   
    return (*this == d) || (*this < d);
}

//重载>运算符
bool Date::operator>(const Date& d)const
{
   
   
    return !(*this <= d);
}

//重载>=运算符
bool Date::operator>=(const Date& d)const
{
   
   
    return !(*this < d);
}

//重载+=运算符
Date& Date::operator+=(int d)
{
   
   
    if (d < 0)
    {
   
   
        return *this -= -d;
    }
    _day += d;
    while (_day > GetMonthDay(_year, _month))
    {
   
   
        _day -= GetMonthDay(_year, _month);
        _month++;
        if (_month > 12)
        {
   
   
            _year++;
            _month = 1;
        }
    }
    return *this;
}

//重载+运算符
Date Date::operator+(int d)const
{
   
   
    Date tmp(*this);
    tmp += d;
    return tmp;
}

//重载-=运算符
Date& Date::operator-=(int d)
{
   
   
    if (d < 0)
    {
   
   
        return *this += -d;
    }
    _day -= d;
    while (_day <= 0)
    {
   
   
        _month--;
        if (_month == 0)
        {
   
   
            _year--;
            _month = 12;
        }
        _day += GetMonthDay(_year, _month);
    }
    return *this;
}

//重载-运算符
Date Date::operator-(int d)const
{
   
   
    Date tmp(*this);
    tmp -= d;
    return tmp;
}

//重载d1-d2运算符
int Date::operator-(const Date& d)const
{
   
   
    Date max = *this;
    Date min = d;
    int flag = 1;
    if (*this < d)
    {
   
   
        max = d;
        min = *this;
        flag = -1;
    }
    int cout = 0;
    while (min != max)
    {
   
   
        ++min;
        ++cout;
    }
    return cout * flag;
}

//重载前置++
Date& Date::operator++()
{
   
   
    *this += 1;
    return *this;
}

//重载后置++
Date Date::operator++(int)
{
   
   
    Date tmp(*this);
    *this += 1;
    return tmp;
}

//重载前置--
Date& Date::operator--()
{
   
   
    *this -= 1;
    return *this;
}

//重载后置--
Date Date::operator--(int)
{
   
   
    Date tmp(*this);
    *this -= 1;
    return tmp;
}

这里我们还可以扩展两个函数：

（1）将一年中的第几天转换成日期

void DaysToDate()
{
   
   
    int year = 0;
    int days = 0;
    cin >> year >> days;

    static int Day[13] = {
   
    0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    if (((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
        && (days > 60))
    {
   
   
        --days;
    }

    int month = 1;
    while (days > Day[month])
    {
   
   
        days -= Day[month];
        month++;
    }

    printf("%04d-%02d-%02d\n", year, month, days);
}

（2）计算日期是一年中的第几天

//计算日期是一年中的第几天
int Date::DayOfYear() const
{
   
   
    static int Day[13] = {
   
    0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };

    int n = Day[_month - 1] + _day;

    if (_month > 2 && ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0)))
        ++n;

    return n;
}

7. const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

💕 const对象不能调用非const成员函数：

aa是一个const修饰的对象，他只有可读的权限，但是成员函数Print()却不被const修饰，所以它既具有可读，又具有可写的权限，const A 类型的this指针传递给一个A 类型的this指针时，会导致权限的放大，所以编译器会报错。我们可以在Print函数括号的右边加const，将this指针修改为const A*类型。

💕 非const对象可以调用const成员函数：

非const对象具有可读和可写的权限，A 类型的this指针传递给一个const A 类型的this指针时，是属于权限的缩小，所以没有任何问题。

💕 非const成员函数内可以调用其它的const成员函数

_Print()函数在调用Print()函数时，A 类型的this指针被转换成了const A 类型的this指针，属于权限的缩小，所以可以成功，但是，如果要是const成员函数调用其它的非const成员函数时，const A 的this指针向A类型的this指针转换时，属于权限的放大，编译器会报错。

---

8. 取地址及const取地址操作符重载

取地址操作符重载也属于我们类的六个默认成员函数之一，所以平常当我们访问对象的地址时，类也会给我们提供对应的的默认成员函数，所以一般情况下我们都不需要对取地址操作符重载。

当然了我们也可以写一下：

class A
{
   
   
public:
    void Print() const
    {
   
   
        cout << _a << endl;
    }
    A* operator&()
    {
   
   
        return this;
    }
    const A* operator&() const
    {
   
   
        return this;
    }

private:
    int _a = 10;
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需
要重载，比如想让别人获取到指定的内容！