类的默认成员函数

在C++中，类（class）可以拥有多种成员函数，其中一些成员函数在类定义中没有显式声明时，编译器会隐式地为该类生成。这些由编译器自动生成的成员函数被称为默认成员函数（也称为特殊成员函数）。它们包括：

1. 默认构造函数（Default Constructor）
2. 析构函数（Destructor）
3. 拷贝构造函数（Copy Constructor
4. 拷贝赋值运算符（Copy Assignment Operator）
5. 移动构造函数（Move Constructor） 和 移动赋值运算符（Move Assignment Operator），这是C+11以后引入的，比较复杂，这里就不介绍，重点将前4个。

构造函数

特征：

1. 函数名和类名相同
2. 无返回值
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
   用户显式定义编译器将不再生成。

class Data
{
public://1.无参构造函数/*Data(){int _year = 1;int _month = 1;int _day = 1;}*///2.带参构造函数//Date(int year, int month, int day)//{// 	_year = year;//	_month = month;//	_day = day;//}//3.全缺省构造函数//Date(int year = 1, int month = 1, int day = 1)//{//	_year = year;//	_month = month;//	_day = day;//}
private:int _year;int _month;int _day;
};
int main()
{Data d1;Data d2(2024,7,15);Data d3(2024);return 0;
}

前面我们说过：
“如果没有为类定义任何构造函数，编译器会生成一个默认构造函数。这个构造函数不接受任何参数，并且只进行成员变量的默认初始化（对于内置类型不做任何操作，对于类类型调用其默认构造函数）。如果类中定义了任何构造函数（包括带参数的构造函数），编译器就不会自动生成默认构造函数。”所以，无参构造函数和全缺省构造函数也是默认构造函数，因为这两种构造函数都可以不用传参。这三种默认构造只能存在一个，不能同时存在。
总结：不传实参就可以调用的构造就叫默认构造。

析构函数

析构函数和构造函数功能相反，析构函数不是对对象本身的销毁，而是对对象中资源的清理工作。
如果没有资源需要释放，就不需要析构函数了。

特征：

1. 析构函数名是在类名前加上字符 ~。
2. . 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
5. 跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定义类型成员会调用他的析构函数。
6. 如果类没有申请资源，析构可以不用写。如果没有写析构，也会自动调用析构函数。
7. 如果有资源申请，一定要写析构函数，否则会造成内存泄漏。

#include<iostream>
using namespace std;typedef int STDataType;
class Stack
{
public:Stack(int n = 4){_a = (STDataType*)malloc(sizeof(STDataType) * n);if (nullptr == _a){perror("malloc申请空间失败");return;}_capacity = n;_top = 0;}// ...~Stack(){free(_a);_a = nullptr;_top = _capacity = 0;}
private:STDataType* _a;size_t _capacity;size_t _top;
};// 两个Stack实现队列
class MyQueue
{
public:// 编译器默认生成MyQueue的析构函数调用了Stack的析构，释放的Stack内部的资源// 显示写析构，也会自动调用Stack的析构~MyQueue(){cout << "~MyQueue()" << endl;}
private:Stack pushst;Stack popst;//int size;
};int main()
{MyQueue mq;//stack st1;//stack st2;return 0;
}

拷贝构造函数

什么是拷贝构造：
如果一个构造函数的第一个参数是自身类类型的引用，且额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造函数是一个特殊的构造函数。

特征：

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

像这样:

如果拷贝构造函数的参数是通过值传递的，那么编译器会尝试通过调用拷贝构造函数来复制实参。这意味着在拷贝构造函数内部，每当需要创建一个新对象时（在这种情况下是为了将 other 作为实参传递），编译器又会调用拷贝构造函数。这会导致一个无限递归的调用序列，因为每次调用都需要再次调用拷贝构造函数。
通过使用引用，特别是常量引用，我们避免了这种递归调用，因为引用只是对象的别名，不需要创建对象的副本。

#include<iostream>
using namespace std;
class Date
{
public:Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}//  error C2652: “Date”: 非法的复制构造函数: 第一个参数不应是“Date”// Date d2(d1)Date(const Date& d){_year = d._year;_month = d._month;_day = d._day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year;int _month;int _day;
};

3. C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造来完成。
4. . 若未显式定义拷贝构造，编译器会生成默认的拷贝构造函数。 自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。

浅拷贝会出很大的问题：

浅拷贝并不申请新的资源，导致析构两次，程序崩溃。最好自己动手深拷贝，这个不是重点我就不细说了。

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

赋值运算符重载

运算符重载

1. 当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
2. 运算符重载是具有特名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。
3. 重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。
4. 如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
5. 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。
6. 不能通过连接语法中没有的符号来创建新的操作符:比如operator@。

//bool operator==(Date d1, Date d2)
//{
//	return d1._year == d2._year
//		&& d1._month == d2._month
//		&& d1._day == d2._day;
//}
bool operator==(Date d2)
{return _year == d2._year&& _month == d2._month&& _day == d2._day;
}
int main()
{Date x1(2024, 7, 10);Date x2(2024, 7, 11);//operator==(x1, x2);//x1 == x2;x1.operator==(x2);x1 == x2;return 0;
}

7. 
   注意，以上5个运算符不能重载。
8. 重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如: int operator+(int x,int y)。
9. 一个类需要重载哪些运算符，是看哪些运算符重载后有意义， 比如Date类重载operator-就有意 义，但是重载operator+就没有意义。

bool operator==(const Date& d1, const Date& d2)
{return d1._year == d2._year&& d1._month == d2._month&& d1._day == d2._day;
}int main()
{// 运算符重载函数可以显示调用operator==(d1, d2);// 编译器会转换成 operator==(d1, d2);d1 == d2;return 0;
}

赋值运算符重载

赋值运算符重载是一个默认成员函数，用于完成两个已经存在的对象直接的拷贝赋值，这里要注意跟拷贝构造区分，拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。

赋值运算符重载的特点:
1.赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成
const 当前类类型引用，否则会传值传参会有拷贝
2.有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋
值场景。
3.没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型 damen成员变量会调用他的拷贝构造。

const成员函数

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

1. 类内声明
   类型 函数名（参数列表） const
   {
   函数体
   }
2. 类外定义
   类型 类名::函数名（参数列表） const
   {
   函数体
   }

特点：

1. const成员函数内只能读取类的数据成员，无法修改类的数据成员，否者编译器会报错。

class func
{//默认是private int x;int y;
public:func(int xp = 0, int yp = 0){x = xp;y = yp;}//const成员函数内无法修改类的数据成员，否者编译器会报错void print() const{x = 5;//试图修改x 将引发编译器报错 cout << "x:" << x << "y:" << y << endl;}
};

即const成员函数不能修改类中的变量

2. const成员函数内，不能调用其他非const成员函数

class func
{//默认是private int x;int y;
public:func(int xp = 0, int yp = 0){x = xp;y = yp;}void Print2(){cout << "x:" << x << "y:" << y << endl;}//const成员函数内无法修改类的数据成员，否者编译器会报错void Print() const{//x=5;//试图修改成员变量 将引发编译器报错 Print2(); //试图调用非const成员 引发编译器报错cout << "x:" << x << "y:" << y << endl;}
};

希望这篇博客对你有所帮助！！！