类的6个默认成员函数

当类中没有任何成员时，称作空类
但是呢，编译器会自动生成6个默认成员函数，所以当一个类中没有任何成员时，还是存在6个默认函数的

默认成员函数：使用者没有实现，编译器自动生成；使用者自己实现，则使用以实现的

构造函数

概念

观察下面代码

class Date
{
public:void Init(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.Init(2022, 12, 4);d1.Print();return 0;
}

对于 Date类而言，难道只能通过共有函数 Init给对象进行初始化吗？而且如果每次创建对象都需要调用此方式初始化，是不是很麻烦呢？
由此，便引入构造函数的概念，可以在对象创建时就进行初始化

构造函数是一个特殊的成员变量，名字与类名相同，创建类类对象时由编译器自动调用，以确保，每个数据成员都有一个适当的初始值，并且在对象整个生命周期内只调用一次
功能类似于C语言中的Init

特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称为构成，但其功能不是开辟空间创建对象，而是初始化对象

1. 函数名与类名相同
2. 没有返回值
3. 对象实例化（定义）时编译器会自动调用相应的构造函数
4. 构造函数可以重载

class Date
{
public://无参构造函数Date(){}//含参构造函数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;
};void test()
{Date d1;//调用无参构造函数d1.Print();Date d2(2022, 12, 4);//调用含参构造函数d2.Print();
}

这里有一个点需要注意，Date d1调用无参构造函数时，不可以加上（），因为会造成函数声明

5. 如果使用者没有在类中实现构造函数，编译器便会自动生成一个无参的默认构造函数；不过如果使用者已经实现，则编译器不会再生成

class Date
{
public://没有构造函数void Print(){cout << _year << " " << _month << " " << _day << endl;}
private:int _year;int _month;int _day;
};
void test()
{Date d1;d1.Print();
}

6. 在5中可以观察到，当使用者不在类中实现构造函数，编译器会自动生成默认构造函数，但是呢，运行的结果却是随机值，似乎没有任何用处。既然这样的话，还不如使用者自己在类中实现需要的构造函数，但真的是如此吗？？？
   原因是在C++中，把类型分为内置类型（基本类型）和自定义类型。内置类型：语言提供的数据类型，例如int/char/double等；自定义类型：使用者自己定义的类型，例如class/struct/union等
   编译器生成的默认构造函数只会对自定义类型起作用
   之后为了解决默认构造函数不处理内置类型的问题，规定内置类型成员变量在类中声明时可以进行赋值

7. 只有无参构造函数，全缺省构造函数和编译器默认生成的构造函数称为默认构造函数，并且默认构造函数只能存在一个
   不传参数就可以调用的构造函数，就称作默认构造

class Date
{
public://无参构造函数Date(){_year = 2022;_month = 12;_day = 5;}//全缺省构造函数Date(int year = 2022, int month = 12, int day = 5){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};void test()
{Date d;
}

因为默认构造函数只能存在一个，所以程序会崩溃

析构函数

概念

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

特性

1. 析构函数名是在类名前面加上~
2. 无参数无返回值类型
3. 一个类只能有一个析构函数，若使用者没有在类中实现，系统便会自动生成默认的析构函数。析构函数不能重载
4. 对象生命周期结束时，编译器才会调用析构函数。这里的生命周期包括生：局部域,全局域，malloc申请的空间

class Stack
{
public:Stack(int capacity = 4){cout << "Stack(int capacity = 4)" << endl;_a = (int*)malloc(sizeof(int) * capacity);if (_a == nullptr){perror("malloc fail");exit(-1);}_top = 0;_capacity = capacity;}~Stack(){cout << "~Stack()" << endl;free(_a);_a = nullptr;_top = _capacity = 0;}void Push(int x){//..._a[_top++] = x;}private:int* _a;int _top;int _capacity;
};int main()
{Stack sk;sk.Push(1);sk.Push(2);sk.Push(3);sk.Push(4);return 0;
}

在创建对象的同时构造函数进行初始化，结果如下

将四个数值全部插入栈之后，结果如下

此时_top的值为4，表示此时栈中已经存在四个数值

当程序跑到return 0时，主函数生命周期结束（全局域）调用析构函数，此时监视结果如下

5. 默认构造函数只处理自定义类型成员变量，所以类似的，编译器生成的默认析构函数，对自定义类型成员变量才会调用它的析构函数

class M
{
public:~M(){cout << "~M()析构函数" << endl;_m = 0;}
private:int _m;
};
class Date
{
public:void Init(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}void Print(){cout << _year << " " << " " << _month << " " << _day << endl;}
private://内置类型int _year;int _month;int _day;//自定义类型M _m;
};
int main()
{Date d1;return 0;
}

对象 d1的成员变量，包括内置类型和自定义类型。其中内置类型在 d1销毁时不需要资源清理，也就是不需要调用析构函数；自定义类型在 d1销毁时需要调用其本身的析构函数，也就是调用 M类的析构函数，从而销毁 _m。虽然 Date中没有显示析构函数，但编译器会默认生成一个析构函数，其目的是在内部调用 M的析构函数，也就解释了运行结果为什么会打印 ~M()析构函数

7. 判断析构函数是否需要使用者实现的方法是，如果类中没有申请资源，析构函数可以不写，直接使用编译器默认生成的析构函数；如果有资源申请，一定要写，否则会造成资源泄漏

总结
面对需求：编译器默认生成的就可以，就不要自己写，不满足就自己写
Stack的析构函数需要自己写
Date的不需要自己写，默认生成的就可以

拷贝构造函数

概念

拷贝构造函数也称拷贝初始化，只有一个形参，且整个形参是对相同类类型对象的引用（一般由const修饰），在用已存在的类类型对象创建对象时由编译器自动调用

特性

1. 拷贝构造函数是构造函数的一个重载形式
2. 拷贝构造函数的参数只有一个且必须是相同类类型对象的引用；如果使用传值方式，将会引发无穷递归，编译器会报错

class Date
{
public:Date(int year = 2022, int month = 12, int day = 5){_year = year;_month = month;_day = day;}Date(const Date d){_year = d._year;_month = d._month;_day = d._day;}
private:int _year;int _month;int _day;
};void test()
{Date d1;Date d2(d1);
}

传值调用的本质就是拷贝一份数据传递给相应的函数

3. 若使用者没有在类中实现拷贝构造函数，编译器会生成。拷贝对象时按照内存存储字节序完成拷贝，称为浅拷贝

class Date
{
public:Date(int year = 2022, int month = 12, int day = 5){_year = year;_month = month;_day = day;}
private://内置类型int _year;int _month;int _day;
};void test()
{Date d1;Date d2(d1);
}
int main()
{test();return 0;
}

监视结果如下

在编译器生成的默认拷贝构造函数中，内置类型按照字节方式直接拷贝，自定义类型是调用其拷贝构造函数完成拷贝

4. 既然编译器生成的默认构造函数已经可以完成字节序的值拷贝，那么还有自己在类中实现的必要吗？？？

观察下面的代码

class Stack
{
public:Stack(int capacity = 4){cout << "Stack(int capacity = 4)" << endl;_a = (int*)malloc(sizeof(int) * capacity);if (_a == nullptr){perror("malloc fail");exit(-1);}_top = 0;_capacity = capacity;}~Stack(){cout << "~Stack()" << endl;free(_a);_a = nullptr;_top = _capacity = 0;}void Push(int x){//..._a[_top++] = x;}private:int* _a;int _top;int _capacity;
};int main()
{Stack sk1;sk1.Push(1);sk1.Push(2);sk1.Push(3);sk1.Push(4);Stack sk2(sk1);return 0;
}

运行结果如下

程序直接崩溃，为什么呢，上面也是没有自己写拷贝构造函数，程序正常运行，在这里为什么就不行呢

接下来用一张图来进行解释

如果类中没有涉及资源申请，拷贝构造函数便不需要自己实现；如果涉及到资源申请，拷贝构造函数必须要自己实现，否则就是浅拷贝，程序便会崩溃

改进如下

Stack(const Stack& sk){cout << "Stack(const Stack& sk)" << endl;_a = (int*)malloc(sizeof(int) *sk._capacity);if (_a == nullptr){perror("malloc fail");exit(-1);}memcpy(_a, sk._a, sizeof(int) * sk._top);_top = sk._top;_capacity = sk._capacity;}

sk1,sk2中_a所指的不是同一块空间，便完成了深拷贝

需要写析构函数的类，都需要写深拷贝的拷贝构造
不需要写析构函数的类，默认生成的浅拷贝的拷贝构造就可以满足

5. 拷贝构造函数使用场景

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

赋值运算符重载

运算符重载

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

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

1. 不能通过连接其他符号来创建新的操作符：例如operator@
2. 重载操作符必须有一个类类型参数
3. 用于内置类型的运算符，其含义不能改变
4. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
5. .* / :: / sizeof / ?: / . 这五个运算符不能重载

重载 ==
operator==

class Date
{
public:Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}bool operator==(const Date& d2){return _year == d2._year&& _month == d2._month&& _day == d2._day;}}
private:int _year;int _month;int _day;
};

int main()
{Date d1(2022, 12, 5);Date d2(2022, 12, 25);cout << (d1 == d2) << endl;return 0;
}

重载>

bool operator>(const Date& d2){if (_year > d2._year){return true;}else if (_year == d2._year && _month > d2._month){return true;}else if (_year == d2._year && _month == d2._month && _day > d2._day){return true;}return false;}

重载>= 只需要赋用上面两种运算符即可

bool operator>=(const Date& d2){return *this > d2 || *this == d2;}

重载+=和重载+

class Date
{
public://判断日期的有效性int Getmonthday(int year, int month){int monthdayarray[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;}else{return monthdayarray[month];}}Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}Date& operator+=(int day){_day += day;while (_day > Getmonthday(_year, _month)){_day -= Getmonthday(_year, _month);_month++;if (_month == 13){++_year;_month = 1;}}return *this;}Date operator+(int day){Date ret(*this);ret += day;return ret;}
private:int _year;int _month;int _day;
};
int main()
{Date d(2022, 12, 5);d += 50;return 0;
}

赋值运算符重载

1. 赋值运算符重载格式

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

Date类，没有资源的申请赋值重载较为简单

class Date
{
public://判断日期的有效性int Getmonthday(int year, int month){int monthdayarray[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;}else{return monthdayarray[month];}}Date(int year = 1, int month = 1, int day = 1){_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;}
private:int _year;int _month;int _day;
};
int main()
{Date d1(2022, 12, 5);Date d2;d2 = d1;return 0;
}

Stack类，有资源的申请，赋值重载较为复杂

class Stack
{
public:Stack(int capacity = 4){cout << "Stack(int capacity = 4)" << endl;_a = (int*)malloc(sizeof(int) * capacity);if (_a == nullptr){perror("malloc fail");exit(-1);}_top = 0;_capacity = capacity;}Stack& operator=(const Stack& sk){if (this != &sk){free(_a);_a = (int*)malloc(sizeof(int) * sk._capacity);if (_a == nullptr){perror("malloc fail");exit(-1);}memcpy(_a, sk._a, sizeof(int) * sk._top);_top = sk._top;_capacity = sk._capacity;}return *this;}~Stack(){cout << "~Stack()" << endl;free(_a);_a = nullptr;_top = _capacity = 0;}void Push(int x){//..._a[_top++] = x;}private:int* _a;int _top;int _capacity;
};
int main()
{Stack sk1;sk1.Push(1);sk1.Push(2);sk1.Push(3);Stack sk2;sk2.Push(10);sk2.Push(20);sk2.Push(30);sk1 = sk2;return 0;
}

存在三种情况，
sk1中的_a申请的空间比sk2中的_a申请的空间大，相等，小，为了简便处理，在赋值时，先将sk1中_a申请的空间释放，接着将sk2整体拷贝给sk1即可

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数
   因为类中的成员变量是私有的，在类外不能进行访问的

赋值运算符如果使用者没有在类中实现，编译器会生成一个默认的

3. 使用者没有在类中实现赋值运算符重载时，编译器会生成一个默认的，且以值的方式逐字节拷贝（浅拷贝）。内置类型成员变量是直接赋值，而自定义类型成员变量需要调用相应类的赋值运算符重载完成赋值

既然编译器生成的默认构造函数已经可以完成字节序的值拷贝，那么还有自己在类中实现的必要吗？？？

这里与上面拷贝构造的思想类似，就不加赘述

如果类中没有涉及资源管理，赋值运算符不需要写；如果涉及到资源管理使用者必须在类中实现

前置++ 后置++ ++重载

先区分，前置与后置的区别，主要区别就是，返回的结果不同，前置返回的结果是++后的数值；后置返回的结果是++之前的数值，也就是本身；对于- -也是同样的道理

//前置++
Date& operator++()
{*this += 1;return *this;
}
//后置++，多一个参数，为了与前置区分
Date operator++(int)
{Date ret(*this);*this += 1;return ret;
}

const成员函数

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

class Date
{
public:Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}void Print(){cout << _year << " " << _month << " " << _day << endl;}
private:int _year;int _month;int _day;
};
int main()
{Date d1(2022, 12, 5);d1.Print();const Date d2;d2.Print();return 0;
}

改善之后
const修饰成员函数，实际是修饰该成员变量隐含的this指针

void Print()const{cout << _year << " " << _month << " " << _day << endl;}

总结：
凡是内部不改变成员变量的，也就是*this对象数据的，此类成员函数都应该加上const进行修饰

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

这里两类默认成员函数一般不需要重新定义，编译器会默认生成