【C++】——类和对象(中)

类的默认成员函数

在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
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
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;
	}
};

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