C++类和对象（2）关于类的默认成员函数

类的默认成员函数

默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。
简单的理解就是，当一个类中什么都没有写时，类中会自动生成6个默认成员函数，当然，如果你自己实现了这些函数，编译器就不会自动生成

构造函数

构造函数的主要任务是当对象实例化时初始化对象

class Date
{
public:// 构造函数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;
};

构造函数的特点

1.函数名与类名相同
2.无返回值（连void都不需要）
3.对象实例化时系统会自动调用对应的构造函数
4.构造函数可以重载
5.如果类中没有显式定义构造函数，则C++编译器会自动生成⼀个无参的默认构造函数，⼀旦用户显式定义编译器将不再生成
6.无参构造函数、全缺省构造函数、我们不写构造函数时编译器默认生成的构造函数，都叫做默认构造函
数。但是这三个函数有且只有一个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。
注意： 默认构造函数不只是编译器默认生成的才叫默认构造，实际上无参构造函数，全缺省构造函数也是默认构造，总结来说就是不需要传实参就可以调用的构造函数就叫作默认构造
7.我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。
对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决（后面讲）

注意： 不能认为编译器会自动生成构造函数，我们就可以不写构造函数，因为编译器所生成的构造函数对内置类型不做处理，结果可能不是我们想要的

编译器自动生成的构造函数的机制：
1、编译器自动生成的构造函数对内置类型不做处理。
2、对于自定义类型，编译器会再去调用它们自己的默认构造函数。

总结： 在我们不写的情况下，编译器会自动生成构造函数，但是编译器自动生成的构造函数可能达不到我们想要的效果，所以大多数情况下都需要我们自己写构造函数

析构函数

析构函数与构造函数的功能相反，析构函数负责完成对象的销毁，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。

class Date
{
public:Date()// 构造函数{}~Date()// 析构函数{}
private:int _year;int _month;int _day;
};

析构函数的特点

1.析构函数的函数名是在类名前加上字符~
2.无参数无返回值
3.⼀个类只能有⼀个析构函数。若未显式定义，系统会自动生成默认的析构函数
4.对象生命周期结束时，系统会自动调用析构函数
5.跟构造函数类似，我们不写析构函数时，编译器自动生成的析构函数对内置类型成员不做处理，对自定义类型成员会调用它的析构函数
6.如果类中没有申请资源时，即没有使用new等申请空间资源，只使用了int等变量，就可以不写析构函数，直接使用编译器生成的默认析构函数；如果有使用new进行资源申请时，一定要自己写析构函数，对所申请的空间资源进行释放，否则会造成资源泄漏
7.当存在多个对象时，先定义的对象先析构。因为对象是定义在函数中的，函数调用会建立栈帧，栈帧中的对象构造和析构符合先进先出的原则

编译器自动生成的析构函数机制：
1、编译器自动生成的析构函数对内置类型不做处理。
2、对于自定义类型，编译器会再去调用它们自己的默认析构函数。

拷贝构造函数

如果⼀个构造函数的第⼀个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，拷贝构造函数是⼀个特殊的构造函数

#include <iostream>
using namespace std;
class Date
{
public:// 构造函数Date(int year = 0, int month = 1, int day = 1){_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;
};
int main()
{Date d1(2025, 4, 29); // 这里使用构造函数Date d2(d1); // 用已存在的对象d1创建对象d2 这里用到了拷贝构造return 0;
}

拷贝构造函数的特点

1.拷贝构造函数是构造函数的⼀个重载
2.拷贝构造函数的第⼀个参数必须是类类型对象的引用，使⽤传值方式编译器直接报错，因为语法逻辑上会引发⽆穷递归调用。

3.拷贝构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引用，后面的参数必须有缺省值。
4.自定义类型的对象进行函数传参时，一般推荐使用引用传参，例如Print(Date& d)，如果使用传值传参，如Print(Date d)，就会调用一次拷贝构造函数
5.若未显式定义拷贝构造，编译器会⾃动⽣成拷贝构造函数。⾃动⽣成的拷贝构造对内置类型成员变量会完成值拷贝/浅宝贝(⼀个字节⼀个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。如果一个类中全是内置类型，没有指向什么资源，编译器自动生成的拷贝构造函数就可以完成拷贝，不需要显示实现。但是如果类中有指向资源，此时若是浅拷贝，那就会将所指向的内容的地址也拷贝到另一个对象，那么此时对象对该资源的修改会影响到另一个对象。所以此时需要自行实现拷贝构造函数，进行深拷贝

6.传值返回会产生一个临时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名(引用)，没有产⽣拷贝。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引⽤相当于⼀个野引用，类似⼀个野指针⼀样。传引用返回可以减少拷贝，但是⼀定要确保返回对象，在当前函数结束后还在，才能用引用返回。

编译器自动生成的拷贝构造函数机制：
1、编译器自动生成的拷贝构造函数对内置类型会完成浅拷贝（值拷贝）。
2、对于自定义类型，编译器会再去调用它们自己的默认拷贝构造函数。

赋值运算符重载

由于一般的运算符只能对内置类型使用，所以当我们的自定义类型需要使用运算符时，就需要自己实现运算符了

运算符重载

例如：

d1 == d2;// 有运算符时 可读性高（书写简单）
IsSame(d1, d2);// 没运算符则只能通过函数判断 可读性差（书写麻烦）

运算符重载是具有特殊名字的函数，他的名字是由operator和后⾯要定义的运算符共同构成。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体
例如：

// 对 == 进行重载
bool operator==(const Date& d1,const Date& d2)// 运算符重载函数
{// 函数体
}

注意：
1.重载运算符函数的参数个数和该运算符作用的运算对象数量⼀样多。一元运算符有⼀个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数
2.如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少⼀个
例如：

D1 == D2;
// 非成员函数 此时D1传给d1  D2传给d2 两个参数
bool operator==(const Date& d1,const Date& d2)// 运算符重载函数
{// 函数体
}// 成员函数 此时D1传给this指针 D2传给d 一个参数
bool operator==(const Date& d)// 运算符重载函数
{// 函数体
}

3.不能通过连接其他符号来创建新的操作符：比如operator@
4.sizeof 、:: 、.* 、?: 、. 以上5个运算符不能重载
5.重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如：operator+(int x, int y)
6. 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，方便区分
7. 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调用时就变成了对象<<cout（应该为cout<<对象），不符合使用习惯和可读性。重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象

例子：

class Date
{
public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}void Print(){cout << _year << "年" << _month << "月" << _day << "日" << endl;}// 运算符重载函数 此时该运算符重载函数作为类的成员函数bool operator==(const Date& d){return _year == d._year&&_month == d._month&&_day == d._day;}
private:int _year;int _month;int _day;
};// 也可以选择放外面
//bool operator==(const Date& d1, const Date& d2)// 运算符重载函数
//{
//	return d1._year == d2._year
//		&&d1._month == d2._month
//		&&d1._day == d2._day;
//}

注意： 上面的例子中，如果将运算符重载函数放在外面时，这样运行会错误，因为类外的函数无法访问类内的私有成员变量，此时需要将类内私有成员变量设为public或者使用友元函数进行解决

赋值运算符重载

赋值运算符重载是⼀个默认成员函数，⽤于完成两个已经存在的对象直接的拷贝赋值

class Date
{
public:Date(int year = 0, 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(2025, 4, 29); // 调用构造函数Date d2(d1); // 调用拷贝构造函数Date d2 = d1; // 调用赋值运算符重载Date d3 = d1; // 注意注意 这是调用拷贝构造函数 下面会讲解return 0;
}

赋值运算符特点

1. 赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数
2. 赋值运算重载的参数建议写成const 当前类类型引用，否则会传值传参会有拷贝，则需要调用拷贝构造函数，加上const是因为我们在函数体内不会对其进行修改，所以最好可以加上
3. 返回值建议写成当前类类型引用，如：Date& operator=(const Date& d)，引用返回可以提高效率，有返回值的目的是为了支持连续赋值。并且注意这里是 return *this，因为赋值完之后，我们返回的是左操作数，这里的this指针指向的就是左操作数，所以只能通过this进行访问
4. 没有显式实现时，编译器会自动生成⼀个默认赋值运算符重载，默认赋值运算符重载⾏为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)，对⾃定义类型成员变量会调用他的赋值重载函数。所以需要注意该自定义类型是否有申请空间资源，如果有，需要自己定义赋值运算符重载。

拷贝构造函数和赋值运算符重载的区别

	Date d1(2025, 4, 29);Date d2(d1);Date d3 = d1;

我们知道第二行代码会调用拷贝构造函数，第三行呢？
需要注意 第三行并不是调用赋值运算符重载，而也是调用拷贝构造函数，因为d3这个对象是即将创建的，即还不能算作存在，所以这是用一个已存在的对象去构造初始化另一个即将创建的对象

区别：
拷贝构造函数：用一个已经存在的对象去构造初始化另一个即将创建的对象
赋值运算符重载函数：在两个对象都已经存在的情况下，将一个对象赋值给另一个对象

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

取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器自动生成的就可以够我们⽤了，不需要去显示实现。
除非当我们不想让别人取到当前类对象的地址，就可以自己实现，随便返回一个地址。

class Date
{ 
public :Date* operator&() // 取地址操作符重载{return this;// return nullptr;}const Date* operator&()const // const取地址操作符重载{return this;// return nullptr;}
private :int _year; // 年int _month; // ⽉int _day; // ⽇
};