@TOC

前言：类的6个默认成员函数，我们了解三个，讲完剩下的成员函数，其实类和对象的大致内容已经结束，最后我们在了解一些C++类和对象的剩下的的细节，我们就正式结束类和对象

如果你还对前面三个默认成员函数不太了解，建议先阅读这篇博客
类的成员函数

1. 运算符重载

运算符重载

在一个自定义变量里，如果我们想实现对它的加减乘除，是无法直接使用的，因此C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数

关键字operator 后面接需要重载的运算符符号

函数原型： 返回值类型 operator操作符(参数列表)

举个例子：

// 重载 ==
bool operator==(const Date& d)
{
	return _year = d._year；
	&& _month = d._month;
	&& _day = d._day;
}

注意：

• 重载操作符必须有一个自定义类型参数
• 运算符重载定义在类外时不能访问类中的私有成员，因此重载成成员函数
• 作为类成员函数重载时，成员函数的第一个参数为隐藏的this

赋值运算符重载

1. 关于赋值运算符重载：

• 参数类型：const T&，传递引用可以提高传参效率
• 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
• 检测是否自己给自己赋值
• 返回 *this

我们以下例子将使用日期类
例如：

class Date
{
public:
	Date()
	{}
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

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

	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(2024, 5, 23);
	Date d2 = d1;
	// Date d2;
	// 实际上operator=的调用
	// d2.operator=(d1);
	d1.Print();
	d2.Print();
	return 0;
}

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

// 假设我们在类外面重载成全局函数
// 注意：在类外是没有 this 指针的
Date& operator=(Date& this, const Date& d)
{
 	if (&this != &d)
 	{
 		this._year = d._year;
		this._month = d._month;
 		this._day = d._day;
 	}
 	return this;
}

我们将写好的代码拿去运行一下，我们发现无法编译

其实，赋值运算符比较特殊如果不显式实现，编译器会生成一个默认的。如果在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了

3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝

这里我们要格外注意：
系统默认生成一个默认赋值运算符重载它和之前的拷贝构造一样，发生的是浅拷贝，内置类型成员变量可以直接使用，而自定义类型成员变量需要我们自己调用对应类的赋值运算符重载

前置++和后置++重载

关于前置++和后置++：

• 前置++：返回+1之后的结果
• 后置++：是先使用后+1，因此需要返回+1之前的旧值

格式：

• 因为前置++和后置++符号一样，我们为了要想正确完成重载，C++规定，后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递

// 前置++
Date& operator++()
{
	_day += 1;
	return *this
}
// 后置++
Date& operator++(int)
{
	Date temp(*this);
	_day += 1;
	return temp;
}
// 前置--
Date& operator--()
{
	_day -= 1;
	return *this
}
// 后置--
Date& operator--(int)
{
	Date temp(*this);
	_day -= 1;
	return temp;
}

最后补充一点，关于运算符重载，并不是所有的运算符都需要重载，而是要根据自定义的类需要重载哪些运算符！

注意以下运算符不能重载：

• .*
• ::
• sizeof
• ?:
• .

讲到这里类和对象的大致内容已经结束，剩下两个成员函数，我们简单了解一下

2. 成员函数的补充

const成员

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

例如：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << "Print()" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
	void Print() const
	{
		cout << "Print()const" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
int main()
{
	// 编译器会优先调用符合的函数，如果没有则会根据权限来调用
	// 本质是：权限能缩小，但是不能放大
	// 及非const对象可以调用const成员函数
	// 非const成员函数内可以调用其它的const成员函数
	Date d1(2024,5,23);
	d1.Print();
	const Date d2(2024,5,23);
	d2.Print();
}

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

这两个默认成员函数一般不用重新定义 ，编译器默认会生成！

Date* operator&()
{
	return this ;
}

const Date* operator&()const
{
	return this ;
}

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，我们能够修改别人获取的地址

3. 初始化列表

• 在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值
• 对象中有了一个初始值，因此构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值

初始化列表的概念

初始化列表： 以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式

Date(int year, int month, int day)
		: _year(year)
		, _month(month)
	{
		_day = day
	}
	// 函数体里面能够放数据
//Date(int year, int month, int day)
//{
//		_year = year;
//		_month = month;
//		_day = day;
//}

初始化列表的特征

使用初始化列表时注意：

• 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
• 类中包含以下成员，必须放在初始化列表位置进行初始化：
• • 引用成员变量
• • const成员变量
• • 自定义类型成员(且该类没有默认构造函数时)

例如：

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

class B
{
public:
	B(int a, int ref)
		:_aobj(a)
		,_ref(ref)
		,_n(10)
	{}
private:
	A _aobj; // 没有默认构造函数
	int& _ref; // 引用
	const int _n; // const
};
int main()
{
	B bb(1,2);
	A aa(1);
}

特征：
1. 尽量使用初始化列表初始化

因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先经过初始化列表初始化

2. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

3. 当用户没有显示传参初始化时，编译器会用用户定义的缺省值

public:
	B(int a)
		:b(a) // b = 1;
	{}
private:
	int b = 1;

explicit关键字

构造函数不仅能构造和初始化对象，对于单个参数或除第一个参数无默认值，其余均有默认值的构造函数，还有隐式类型转换的作用，隐式类型转换是在编程中编译器自动进行的一种类型转换方式

class pxt
{
public:
	explicit pxt(int a = 0)
		:_a(a)
	{
		cout << "pxt(int a)" << endl;
	}
	~pxt()
	{
		cout << "~pxt()" << endl;
	}
private:
	int _a;
};
int main()
{
	pxt a1 = 2024;
	// 用一个整形变量给自定义类型对象赋值
	// 编译器会用2024构造一个无名对象，最后用无名对象给a1对象进行赋值
	// 正常情景是能赋值的，但是explicit修饰构造函数后，会禁止构造函数的隐式转换
	return 0;
}

关键字explicit修饰构造函数，将会禁止构造函数的隐式转换

4. static成员

static成员的概念

概念：

• 声明为static的类成员称为类的静态成员,
  用static修饰的成员变量，称之为静态成员变量,
  用static修饰的成员函数，称之为静态成员函数
• 静态成员变量一定要在类外进行初始化

class pxt
{
public:
	void Print()
	{
		cout << _a << endl;
	}
private:
	// 在类中声明
 	static int _a;
 	//如果是静态成员函数，则没有this指针
};
// 在类外定义
int pxt:: _a = 100;

int main()
{
	pxt A;
	A.Print();
}

static成员的特征

特性：

• 静态成员为所有类对象所共享，存放在静态区
• 静态成员变量必须在类外定义，类中只是声明
• 类静态成员可用 类名::静态成员或者 对象.静态成员 来访问
• 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
• 静态成员也是类的成员，受访问限定符的限制

5. 友元

友元： 提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

友元分为：

• 友元函数
• 友元类

友元函数

如果尝试去重载operator<<，我们发现没办法将operator<<重载成成员函数，因为函数的参数位置不一样，cout的输出流对象和隐含的this指针在抢占第一个参数的位置，重载operator>>同理
!

d << cout; -> d.operator<<(&d, cout); 不符合常规调用
因为成员函数第一个参数一定是隐藏的this，所以d必须放在<<的左侧

但是问题来了，如果我们写成全局函数，又无法使用私有的成员变量，这时友元的作用就凸显出来了！

友元函数： 可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字

例如：

class Date
{
	// 不声明友元，将无法调用私有成员
	friend ostream& operator<<(ostream& _out, const Date& d);
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	//void operator<< (ostream& _out)
	//{
	//	_out << _year << " " << _month << " " << _day;
	//}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};

ostream& operator<< (ostream& _out, const Date& d)
{
	_out << d._year << " " << d._month << " " << d._day;
	return _out;
}

int main()
{
	Date d(2024,5,23);
	cout << d << endl;
	// d << cout;
}

关于友元函数有以下几点：

• 友元函数可访问类的私有和保护成员，但不是类的成员函数
• 友元函数不能用const修饰
• 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
• 一个函数可以是多个类的友元函数
• 友元函数的调用与普通函数的调用原理相同

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员

友元类的特征：
友元关系是单向的，不具有交换性
友元关系不能传递
如果C是B的友元， B是A的友元，则不能说明C时A的友元
友元关系不能继承，在继承位置再给大家详细介绍

关于友元关系的单向性我举个例子：

class A
{
	friend class B;
public:
	// ......
private:
	int _year;
	int _month;
	int _day;
};
class B
{
public:
	void test(int year, int month, int day)
	{
	// 直接访问A类私有的成员变量
	// 但是A 不能访问B 中私有的成员变量
	_d._year = year;
	_d._month = month;
	_d._day = day;
}
private:
	int good;
	A _d;
};

B能直接访问A类私有的成员变量，但是A 不能访问B 中私有的成员变量

讲到友元类，我们再来介绍一下一个跟友元类有很大关系的内部类
内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限

注意：内部类就是外部类的友元类，内部类能访问外部类中的所有成员，反之则不能！

class A
{
public:
	// ......
	A(int year = 2024, int month = 5, int day = 20)
		: _year(year)
		,_month(month)
		,_day(day)
	{}
	class B
	{
	public:
		void test(const A& _d)
		{
			cout << _d._year << " " << _d._month << " " << _d._day << endl;
		}
	};
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	A::B b;
	b.test(A());
}

内部类的特征

特性：

• 内部类可以定义在外部类的所有成员
• 内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名
• sizeof(外部类)=外部类，和内部类没有任何关系

6. 类的匿名对象

class pxt
{
public:
	pxt(int a = 0)
		:_a(a)
	{
		cout << "pxt(int a)" << endl;
	}
	~pxt()
	{
		cout << "~pxt()" << endl;
	}
private:
	int _a;
};
int main()
{
	// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
	// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
	// 匿名对象
	pxt();
	// 隐式类型转换
	pxt a1 = 2024;
	return 0;
}

• 生命周期只有一行,会自动调用析构函数
• 匿名对象的特点不用取名字

因此当我们只是想使用类中的某一个函数时，我们能创建匿名对象！

7. 总结

类和对象的所有内容已经了解完毕，类和对象在整个C++上都有举足轻重的作用，大家千万不要忽视，而类和对象的重点在四个成员函数上，下节我将学习C++的内存管理

谢谢大家支持本篇到这里就结束了，祝大家天天开心！