✨前言✨
📘 博客主页：to Keep博客主页
🙆欢迎关注，👍点赞，📝留言评论
⏳首发时间：2023年11月11日
📨 博主码云地址：博主码云地址
📕参考书籍：《C++ Primer》《C++编程规范》
📢编程练习：牛客网+力扣网
由于博主目前也是处于一个学习的状态，如有讲的不对的地方，请一定联系我予以改正！！！
类中的六个默认成员函数
文章目录
- 构造函数
- 析构函数
- 拷贝构造
- 赋值运算符重载
- const成员函数
- 取地址操作符重载
构造函数
构造函数的作用：在创建对象时，同时帮助我们给对象一个初始值，并不是给对象开辟空间
构造函数的定义如下：
1️⃣ 函数名与类名一样
2️⃣ 构造函数是不带返回值的
3️⃣ 构造函数支持重载
4️⃣ 对象进行实例化时，编译器会自动调用构造函数
让我们来看一看以下这段代码，来看一下如何使用构造函数：
class Date {
private:
int _year;
int _month;
int _day;
public:
Date() {
_year = 2023;
_month = 11;
_day = 2;
}
Date(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year << _month << _day << endl;
}
};
int main()
{
Date d1();//编译器会当做是函数的声明，是要去调用函数
Date d2;//调用Date类的不带参数构造函数
d2.print();
Date d3(2024, 11, 2);//调用有参数的构造函数
d3.print();
return 0;
}
如果自己不写构造函数，编译器也是会生成默认不带参数的构造函数！默认的构造函数有什么作用呢，让我们来看下面这段代码来进一步的理解：
class people {
private:
int _age;
double _height;
double _weight;
public:
people() {
_age = 1;
_height = 1;
_weight = 1;
}
};
class Date {
private:
int _year;
int _month;
int _day;
people p;
public:
void print()
{
cout << _year<<" " << _month<<" "<< _day << endl;
}
};
int main()
{
Date d1();//编译器会当做是函数的声明，是要去调用函数
Date d2;//调用Date类的默认构造
d2.print();
}
我们可以发现，在d2这个对象中_year等是一个随机值，对于people这个类型的变量p是可以进行初始化的！事实上，在C++中，int/char/指针…等，也就是对于哪些可以直接拿来用的类型我们称为内置类型，像利用union/struct/class等关键字定义的类型，我们称为自定义类型。对于内置类型，构造函数是不进行处理的，对于自定义类型，是会去调用这个类型的默认构造！
编译器默认生成的无参构造函数，用户自己写的不带参数的默认构造函数，以及全缺省的构造函数我们都称之为默认的构造函数，而且一旦我们自己显式的写了构造函数，编译器就不会在生成构造函数了！
在C++11中，打了一个补丁，可以针对内置成员变量给定一个缺省值！注意此时成员变量仍然是一个定义，并没有因为给定这个缺省值就初始化了一个空间！
析构函数
与构造函数功能相反，析构函数的作用就是对象销毁时，自动调用析构函数，从而完成对象中的资源清理工作！
语法格式如下：
1️⃣ 也是与类名相同的函数，函数名前面要加上~
2️⃣ 析构函数同样也是无参数也无返回值
3️⃣ 析构函数不能构成重载,一个类中只可以有一个析构函数，若用户显式写出，编译器就不在生成
4️⃣ 析构函数会在对象生命周期结束后，自动调用！
结合下列代码：
#include <iostream>
using namespace std;
class Date {
private:
int _year;
int _month;
int _day;
public:
Date()
{
_year = 2023;
_month = 11;
_day = 2;
}
//析构函数
~Date()
{
cout << "Date()" << endl;
}
void print()
{
cout << _year << " " << _month << " " << _day << endl;
}
};
class Stack {
int* _x;
int _top;
int _capacity;
public:
Stack(int capacity = 3)
{
_x = (int*)malloc(sizeof(int) * capacity);
if (_x == nullptr)
{
cout << "申请空间失败" << endl;
return;
}
_capacity = capacity;
_top = 0;
}
void print()
{
cout << _top << " " << _capacity << endl;
}
~Stack()
{
free(_x);
_top = _capacity = 0;
_x = nullptr;
}
};
int main()
{
Date d1;
Stack st1;
return 0;
}
析构函数类似于构造函数，对于内置类型，是不做处理的，对于自定义类型，是会去调用它的析构函数进行处理！对于我们之前所学的栈，一般就需要我们自己写析构函数，因为栈需要向系统申请资源开辟空间！这时我们需要利用析构函数，将这块资源进行清理，防止资源泄露！Date类可以使用默认的析构函数，Date类中全是内置类型，没有向系统申请空间！
图解如下：
拷贝构造
在C语言学习结构体中，我们知道，是可以传值传参的。在C++中，那么对于自定义类型进行传值传参会发生什么呢？
class Date {
private:
int _year;
int _month;
int _day;
public:
Date()
{
_year = 2023;
_month = 11;
_day = 2;
}
//析构函数
~Date()
{
cout << "Date()" << endl;
}
void print()
{
cout << _year << " " << _month << " " << _day << endl;
}
};
class Stack {
int* _x;
int _top;
int _capacity;
public:
Stack(int capacity = 3)
{
_x = (int*)malloc(sizeof(int) * capacity);
if (_x == nullptr)
{
cout << "申请空间失败" << endl;
return;
}
_capacity = capacity;
_top = 0;
}
~Stack()
{
free(_x);
_top = _capacity = 0;
_x = nullptr;
}
};
void func(Date a)
{
a.print();
}
void func1(Stack st1)
{
}
int main()
{
Date x;
func(x);
Stack st;
func1(st);
return 0;
}
运行代码，我们可以发现会报错！这是为什么呢？这是因为在进行传值传参的过程中，我们进行的只是值拷贝（浅拷贝），而在清理对象资源的时候，会自动调用析构函数，而对于Stack这样的类，同一块空间是会被释放两次！
上述代码图解过程：
在C++中，为了解决上述问题，规定，自定义类型在传值传参必须先调用拷贝构造函数！
拷贝构造函数的特点：
1️⃣ 无参数无返回值，函数名与类名相同，与构造函数构成重载
2️⃣ 函数的参数只有一个，是类类型的引用，不可以使用传值方式
在这里需要特别说明一下为什么拷贝构造函数不可以使用传值方式！先假设拷贝构造是传值传参的，调用函数进行传值传参需要先调用拷贝构造，而拷贝构造又是传值传参，又需要接着调拷贝构造……就这样套娃下去，形成一个无限递归！
改进代码如下：
//拷贝构造
Stack(const Stack& t)
{
_x = (int*)malloc(sizeof(int) * t._capacity);
if (_x == nullptr)
{
perror("malloc fail");
}
_capacity = t._capacity;
_top = t._top;
memcpy(_x, t._x,sizeof(int)*t._capacity);
}
只需要在Stack类中重新写构造函数，实现对资源的拷贝，这样就不会存在对一块空间释放两次的问题！
其实对于Date这样的类，就算我们使用默认生成的拷贝构造，也是可以的，因为Date类中没有向系统申请资源！而对于Stack这样的类就必须我们自己实现，因为它向系统申请开辟了空间，我们需要拷贝这块空间的内容！同时，为了防止拷贝过程中，改变引用中的内容，我们通常会加上const修饰！
class myqueue
{
Stack _pushs;
Stack _pops;
int _size;
};
int main()
{
myqueue q1;
myqueue q2(q1);
return 0;
}
在上面的代码基础上，我们定义一个myqueue类，通过打断点按F11可以发现：拷贝构造对于自定义类型会去调用它的拷贝构造，对于内置类型会完成值拷贝！
学习了拷贝构造，我们可以来看以下这段代码，再来理解一下引用的用途：
Date test()
{
Date x;
x.print();
return x;
}
int main()
{
return 0;
}
你觉得返回的是x还是x拷贝的临时对象呢？实际上，x出了test函数就会销毁，所以只可以返回x的拷贝！如果我们写出如下的代码：
Date& test()
{
static Date x;
x.print();
return x;
}
int main()
{
return 0;
}
此时，由于x出了作用域还没有销毁！所以我们可以通过传引用返回！这样会减少拷贝对象的时间，是不是会大大提高效率呢？
赋值运算符重载
我们知道，内置类型的比较是可以直接用符号来进行比较的！C++为了增强代码的可读性引入了运算符重载的！运算符重载是具有特殊函数名的函数！
函数名字：operator 后面接需要重载的运算符符号()
下面来展示一段代码：
class Date {
public:
int _year;
int _month;
int _day;
public:
Date()
{
_year = 2023;
_month = 11;
_day = 2;
}
void print()
{
cout << _year << " " << _month << " " << _day << endl;
}
};
bool operator==(Date& x,Date& y)
{
return x._year == y._year
&& x._month == y._month
&& x._day == y._day;
}
int main()
{
Date d1;
Date d2;
cout << (d1==d2) << endl;
return 0;
}
为了便于理解，我们暂时先将类的成员改为public，我们通过operator关键字重载==符号，这样我们就可以像内置类型一样，通过 符号来判断是否相等! 在C++中，对于运算符重载，我们一般是放入类中处理，但是传参就要少一个了，因为有一个隐藏的this指针！具体代码可以参考下面：
bool operator==( Date& y)
{
return _year == y._year
&& _month == y._month
&& _day == y._day;
}
此外我们在介绍两个特殊的运算符重载：
//前置++运算符重载
Date& operator++()
{
*this += 1;
return *this;
}
//后置++运算符重载
Date operator++(int)
{
Date tmp(*this);
*this += 1;
return tmp;
}
对于后置++运算符，我们通过给定一个整型来表示这是后置++（注意这个是语法规定）
编译器自己会根据我们所写的符号去调用相应的运算符重载函数（这个是需要我们自己写的）！编译器默认生成的成员函数是赋值运算符的重载，也就是说我们自己不写，也是会自动生成的！
//赋值赋值运算符重载
Date& operator=(const Date& y) //返回值的目的是为了进行连续赋值，引用可以提高返回的效率
{
//防止自己和自己赋值
if (this != &y)
{
_year = y._year;
_month = y._month;
_day = y._day;
}
return *this;
}
和拷贝构造的作用一样，对于内置类型会进行值拷贝（浅拷贝），自定义类型调用它的赋值重载运算符！但是对于Stack这样的类，向系统申请了额外资源的需要我们自己重写赋值重载实现深拷贝！
对于运算符重载需要注意事项：
1️⃣ 对于内置类型运算符的含义不可以改变。例如：不能重载+符号，里面写成了-的含义了
2️⃣ 不可以通过连接其他符号创建新的操作符。例如：opertor@
3️⃣ 重载操作符必须要有一个类类型的参数
4️⃣ 作为类的成员函数重载时，其形参看起来比操作数数目少1，因为成员函数第一个参数是隐藏的this指针
5️⃣.*::(域限定符)sizeof?:(三目操作符).这五个运算符是不可以运算符重载的！
const成员函数
被const修饰的成员函数被称为const成员函数！
//大于重载
bool operator>(Date& t)const //在函数参数后面加上const修饰
{
if (_year > t._year)
{
return true;
}
else if (_year == t._year && _month > t._month) {
return true;
}
else if (_year == t._year && _month == t._month && _day == t._day)
{
return true;
}
return false;
}
实际上const修饰的是隐藏的this指针，变成了const Date类型，表明在该成员函数中不能对类的任何成员修改！还需要注意的是当自定义类型的声明与定义分离时，我们如果要用const进行修饰，那么就要声明和定义一起加上！
当我们定义const对象和非const对象时，调用>重载运算符如图所示！这是为啥呢？原因就是d1是const Date类型对象，传入>重载运算符时第二个参数是Date*类型！可以理解为权限放大，这样是不允许的！权限只可以平移和缩小！
取地址操作符重载
最后两个默认的成员函数是取地址操作符的重载
Date* operator&()
{
return this;
}
const Date* operator&()const
{
return this;
}
一般这两个默认的成员函数不需要我们自己进行重载，直接拿来用就可以了！如果我们想要让别人获取指定的内容可以使用！
//让你只可以拿到地址为0x11223344的内容
Date* operator&()
{
return (Date*)0x11223344;
}
const Date* operator&()const
{
return (const Date*)0x11223344;
}
