第二讲 | 手把手教你玩转C++类和对象

珊瑚里的鱼

已于 2025-04-04 10:20:28 修改

阅读量612

点赞数 10

分类专栏： C++ 文章标签： c++ 算法程序人生开发语言 visualstudio visual studio 笔记

于 2025-03-21 15:55:29 首次发布

本文链接：https://blog.csdn.net/2401_87255690/article/details/146177298

版权

C++ 专栏收录该内容

9 篇文章

订阅专栏

类和对象

一、类的定义
- 1.类的定义格式
- 2.访问限定符
- 3.类域
二、实例化
- 1.实例化概念
- 2.对象大小
- - 内存对齐规则
  - 为什么要内存对齐？
三、this指针
四、C++和C语言实现Stack对比
- C实现Stack代码
- C++实现Stack代码
五、类的默认成员函数
六、构造函数
- 构造函数怎么写？
- 构造函数特性
- - 初始化列表
七、析构函数
- 析构函数怎么写？
- 析构函数特性
八、拷贝构造函数
- 拷贝构造函数的特点
- 第一个参数传引用传参和传值传参有什么区别？
- 为什么建议加const？
- 示例辅助理解
九、赋值运算符重载
- 运算符重载/重载运算符函数
- 赋值运算符重载
- - 赋值运算符重载的特点
十、取地址运算符重载
- const成员函数
- 取地址运算符重载
十一、类型转换
十二、static成员
- 求1+2+3+...+n
十三、友元
十四、只需了解的内容：内部类、匿名对象、对象拷贝时的编译器优化
- 内部类
- - 求1+2+3+...+n 改进
- 匿名对象
- 对象拷贝时的编译器优化

一、类的定义

1.类的定义格式

定义类的关键字class，class和struct类似，可以定义多种数据类型的复合体。
class关键字后面是类的名字，这里类的名字就是类类型，这与结构体不同，结构体中，struct和名字一起才是结构体类型。下面示例中，Stack st;的Stack是类的类型，st是对象（C++中叫对象，也可以叫变量，因为C++兼容C，C++不是纯面向对象的语言，还带着点儿面向过程），类对象与结构体变量一样，访问成员用.，若是指向类的指针，访问成员用->。
{}中为类的主体（简称类体），注意类定义结束时后面分号;不能省略。
类体中内容称为类的成员：类中的变量称为类的属性（特征、值）或成员变量; 类中的函数称为类的方法或者成员函数。
为了区分成员变量与函数参数，一般习惯上成员变量会加一个特殊标识，如成员变量前面或者后面加_ 或者m(member)开头，注意C++中这个并不是强制的，只是一些惯例，具体看公司的要求。编译器是向上编译的，成员变量声明在成员函数的上面还是下面呢？答案是都可以，因为类是一个整体，先在函数内部搜索成员变量，没找到的话再在整个类中搜索。也就是说，类是整体搜索，其他的是向上搜索。
C++中struct也可以定义类，C++兼容C中struct的用法，同时struct升级成了类，这样就不需要使用typedef了，struct后面的名字就是类型，明显的变化是struct中可以定义函数，一般情况下我们还是推荐用class定义类。
定义在类里面的成员函数默认为inline（注意是定义，不是声明）。正常情况下函数的定义和声明都是分离的，但是被频繁调用的小函数的声明和定义是不用分离的，这个小函数可以直接定义在类里，直接定义在类里的函数默认为inline。

函数的定义和声明分离的好处：

会避免命名冲突。若函数定义在.h里，这个函数就是全局函数，多个.cpp包含这个头文件会有多个同名函数的命名冲突、链接冲突问题。
方便看类的框架。项目中的类是很复杂的，函数都定义在类里不方便看，所以在项目中的.h里会定义类，短小函数直接定义在类里，成为内联函数；大一点的函数做声明（在类里）和定义（在.cpp里）的分离。

定义类之后与C语言的不同：

C++类里数据（成员变量）与方法（成员函数）是放在一起的。例如，C中栈的实现的.h文件中，数据和方法是分离的，数据（成员变量）是放在结构体里。而C++是将数据和方法放在了一起——类。C里函数做了声明和定义分离，C++里也可以，稍后讲解。
C++类里不需要给函数名的前面加前缀。例如之前C中栈、队列的实现的STInit、QueueInit……，C里需要加前缀进行命名区分，而C++里直接写Init即可，不需要进行区分，因为像class Stack{};、class Queue{};等都是一个个类域，而不同的域里面可以定义同名函数，不会有命名冲突。
C++类里可以直接访问数据。C里数据和方法是分离的，需要用到指针访问到结构体里的数据，也就是需要指针作为参数，而C++不用传递指针参数，因为都在类域里面，可以直接访问数据。

#include <iostream>
#include <assert.h>
using namespace std;
class Stack {
public:
	// 成员函数
	void Init(int n = 4)
	{
		array = (int*)malloc(sizeof(int) * n);
		if (nullptr == array)
		{
			perror("malloc申请空间失败");
			return;
		}
		capacity = n;
		top = 0;
	}
	void Push(int x)
	{
		// ...扩容
		array[top++] = x;
	}
	int Top()
	{
		assert(top > 0);
		return array[top - 1];
	}
	void Destroy()
	{
		free(array);
		array = nullptr;
		top = capacity = 0;
	}
private:
	// 成员变量
	int* array;
	size_t capacity;
	size_t top;
};
int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	cout << st.Top() << endl;
	st.Destroy();
	return 0;
}

#include <iostream>
using namespace std;
class Date {
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	// 为了区分成员变量与函数参数，一般习惯上成员变量会加一个特殊标识，
	// 如成员变量前面或者后面加_ 或者m(member)开头
	int _year; // year_ m_year mYear
	int _month;
	int _day;
};
int main()
{
	Date d;
	d.Init(2025, 3, 11);
	return 0;
}

#include <iostream>
using namespace std;
// C++中struct升级成了类
// 1、类⾥⾯可以定义函数
// 2、struct后面的名字就可以代表类型

// C++兼容C中struct的⽤法
typedef struct ListNodeC
{
	struct ListNodeC* next;
	int val;
}LTNode;

// 不再需要typedef，ListNodeCPP就可以代表类型
struct ListNodeCPP
{
	void Init(int x)
	{
		next = nullptr;
		val = x;
	}
	ListNodeCPP* next;
	int val;
};
int main()
{
	ListNodeCPP list;
	list.Init(10);
	return 0;
}

//小函数可以直接定义在类里，直接定义在类里的函数默认为inline
class Stack {
public:
	//成员函数
	void Init(int n = 4);//不是内联函数
	int Top() { return array[top - 1]; }//是内联函数
private:
	//成员变量
	int* array;
	size_t capacity;
	size_t top;
};

2.访问限定符

在这里插入图片描述

C++一种实现封装的方式，用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外不能直接被访问，但在类里能访问。protected和private是一样的，以后继承章节才能体现出他们的区别。
访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止，如果后面没有访问限定符，作用域就到}即类结束。
class、struct定义/声明的成员没有被访问限定符修饰时分别默认为private、public。class定义/声明的成员都没有被访问限定符修饰时默认都为private，编译不通过，所以一定要加上访问限定符。
一般成员变量都会被限制为private/protected，需要给别人使用的成员函数限定为public。
一个类里出现多个同样的访问限定符也是可以的，但是会出现白白定义的问题。例如，下面的例子，就会导致一个public白定义了，一般不会这么做。

//不让访问被private修饰的成员
#include <iostream>
#include <assert.h>
using namespace std;
class Stack {
public:
	// 成员函数
	void Init(int n = 4)
	{
		array = (int*)malloc(sizeof(int) * n);
		if (nullptr == array)
		{
			perror("malloc申请空间失败");
			return;
		}
		capacity = n;
		top = 0;
	}
	void Push(int x)
	{
		// ...扩容
		array[top++] = x;
	}
	int Top()
	{
		assert(top > 0);
		return array[top - 1];
	}
	void Destroy()
	{
		free(array);
		array = nullptr;
		top = capacity = 0;
	}
private:
	// 成员变量
	int* array;
	size_t capacity;
	size_t top;
};
int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);

	//不让访问被private修饰的成员
	cout << st.top << endl;

	cout << st.Top() << endl;
	st.Destroy();
	return 0;
}

//class里定义的成员没有被访问限定符修饰默认为private
//成员函数Init()默认被private修饰
#include <iostream>
#include <assert.h>
using namespace std;
class Stack {
//改成struct Stack，Init就可以被访问
	// 成员函数
	void Init(int n = 4)
	{
		array = (int*)malloc(sizeof(int) * n);
		if (nullptr == array)
		{
			perror("malloc申请空间失败");
			return;
		}
		capacity = n;
		top = 0;
	}
public:
	void Push(int x)
	{
		// ...扩容
		array[top++] = x;
	}
	int Top()
	{
		assert(top > 0);
		return array[top - 1];
	}
	void Destroy()
	{
		free(array);
		array = nullptr;
		top = capacity = 0;
	}
private:
	// 成员变量
	int* array;
	size_t capacity;
	size_t top;
};
int main()
{
	Stack st;
	st.Init();//报错
	st.Push(1);
	st.Push(2);
	cout << st.Top() << endl;
	st.Destroy();
	return 0;
}

若上面的class Stack改成struct Stack，Init就可以被访问了！

//会导致一个public白定义了，一般不会这么做
#include <iostream>
#include <assert.h>
using namespace std;
class Stack {
public:
	// 成员函数
	void Init(int n = 4)
	{
		array = (int*)malloc(sizeof(int) * n);
		if (nullptr == array)
		{
			perror("malloc申请空间失败");
			return;
		}
		capacity = n;
		top = 0;
	}
public:
	void Push(int x)
	{
		// ...扩容
		array[top++] = x;
	}
	int Top()
	{
		assert(top > 0);
		return array[top - 1];
	}
	void Destroy()
	{
		free(array);
		array = nullptr;
		top = capacity = 0;
	}
private:
	// 成员变量
	int* array;
	size_t capacity;
	size_t top;
};
int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	cout << st.Top() << endl;
	st.Destroy();
	return 0;
}

3.类域

类定义了一个新的作用域——类的作用域（简称：类域），类的所有成员都在类的作用域中，在类体外定义成员时，需要使用::作用域操作符（域作用限定符）指明成员属于哪个类域。

类的名字/类的类型::成员

类域影响的是编译的查找规则（两点：先局部再全局、指定域查找），下面程序中声明和定义分离，需要指定类域。Init如果不指定类域Stack，那么编译器就把Init当成全局函数，那么编译时，找不到array等成员的声明/定义在哪里(为什么会找不到呢？编译查找规则中的先局部再全局，最后发现都找不到)，就会报错。指定类域Stack，就是知道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找。

#include <iostream>
using namespace std;
class Stack
{
public:
	// 成员函数
	void Init(int n = 4);
private:
	// 成员变量
	int* array;
	size_t capacity;
	size_t top;
};
// 声明和定义分离，需要指定类域
void Stack::Init(int n)
{
	array = (int*)malloc(sizeof(int) * n);
	if (nullptr == array)
	{
		perror("malloc申请空间失败");
		return;
	}
	capacity = n;
	top = 0;
}
int main()
{
	Stack st;
	st.Init();
	return 0;
}

在类的外面不是不能访问私有的吗?

其实这还是在类的里面，这只是做了函数声明和定义的分离（声明和定义可以分别在不同的文件），声明和定义都是类的成员函数，所以不管是成员函数的声明还是定义都是在类的里面的。

二、实例化

1.实例化概念

类实例化出对象/类的实例化：用类类型在物理内存中创建对象的过程。(类似结构体类型创建变量)
类是对象进行一种抽象描述，是一个模型一样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，用类实例化出对象时，才会分配空间。

成员变量的声明（在类里）：没开空间
类实例化出对象（成员变量的定义）：开空间

一个类可以实例化出多个对象（一对多的关系），实例化出的对象占用实际的物理空间，存储类成员变量。打个比方：类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，设计图规划了有多少个房间，房间大小功能等，但是并没有实体的建筑存在，也不能住人，用设计图修建出房子，房子才能住人。同样类就像设计图一样，不能存储数据，实例化出的对象分配物理内存存储数据，成员属于对象的一部分。

类里的成员变量不能存储数据
用类实例化出的对象能存储数据

在这里插入图片描述

#include <iostream>
using namespace std;
class Date {
public:
	// 成员函数
	void Init(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;
};
int main()
{
	//Date实例化出的对象d1、d2
	//定义变量/对象，开空间
	Date d1;
	Date d2;
	d1.Init(2025, 3, 12);
	d1.Print();
	d2.Init(2025, 3, 13);
	d2.Print();
	return 0;
}

2.对象大小

分析一下类实例化出的对象中有哪些成员呢？

类实例化出的每个对象，都有独立的数据空间，所以对象中肯定包含成员变量。

那么成员函数是否包含呢？

首先函数被编译后是一段指令，对象中没办法存储，这些指令存储在一个单独的区域(代码段)，那么对象中非要存储的话，只能是成员函数的指针。那么对象中是否有存储指针的必要呢？Date实例化d1和d2两个对象，d1和d2都有各自独立的成员变量_year/_month/_day存储各自的数据，但是d1和d2的成员函数Init/Print指针却是一样的，存储在对象中就浪费了。例如，如果用Date实例化100个对象，那么成员函数指针就重复存储100次，那就太浪费了。这里需要再额外哆嗦一下，其实函数指针是不需要存储的，函数指针是一个地址，调用函数被编译成汇编指令[call 地址]，其实编译器在编译链接时，就要找到函数的地址，不是在运行时找，只有动态多态是在运行时找，就需要存储函数地址，这个我们以后会讲解。

结论：类实例化出的对象中只存储成员变量，没有成员函数。

在这里插入图片描述

C++规定类实例化的对象大小也要符合内存对齐（与结构体类似）的规则。

sizeof(类型/变量/对象)是在编译时就运算的，也是按内存对齐规则运算的。

内存对齐规则

第一个成员在与结构体偏移量为0的地址处。
其他成员变量要对齐到对齐数的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。
VS中默认的对齐数为8。
结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐数取最小）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

#include<iostream>
using namespace std;
// 计算⼀下A/B/C实例化的对象是多⼤？
class A
{
public:
	void Print()
	{
		cout << _ch << endl;
	}
private:
	char _ch;
	int _i;
};
class B
{
public:
	void Print()
	{
		//...
	}
};
class C
{};
int main()
{
	A a;
	B b;
	C c;
	cout << sizeof(a) << endl;
	//cout << sizeof(A) << endl;
	cout << sizeof(b) << endl;
	cout << sizeof(c) << endl;

	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	return 0;
}

在这里插入图片描述

上面的程序运行后，我们看到没有成员变量的B和C类对象的大小是1，为什么没有成员变量还要给1个字节呢？因为如果一个字节都不给，怎么表示对象存在过呢！所以这里给1字节，纯粹是为了占位标识对象存在。我们可以打印出类对象b、c的地址，也可以说明对象存在过。其实像这样的没有成员变量的类很常见，例如，仿函数（以后讲解）。

在这里插入图片描述

#include<iostream>
using namespace std;
// 计算⼀下Stack实例化的对象是多⼤？
class Stack
{
public:
	void Init()
	{
		//...
	}
	//...
private:
	int* array;
	size_t capacity;
	size_t top;
};
int main()
{
	Stack st;
	cout << sizeof(Stack) << endl;
	return 0;
}

在这里插入图片描述

为什么要内存对齐？

这是硬件设计的原因导致的。为了访问未对齐的内存，处理器需要作两次内存访问，而对齐的内存访问仅需一次访问。

有关于为什么要内存对齐的详细解释: https://blog.csdn.net/m0_46216098/article/details/128962902?spm=1001.2014.3001.5506

三、this指针

在这里插入图片描述

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1、d2调用Init和Print函数时，由于对象当中是不存储成员函数的，即d1、d2调用的是同一个函数，那么该函数是如何知道应该访问的是d1对象还是d2对象呢？那么这里就要看到C++给了一个隐含的this指针解决这里的问题。为什么说是隐含的呢？因为这是编译器编译后悄悄添加的。实际上是把对象的地址传给this，通过this去访问对象的成员变量。

this是一个关键字，用来存储对象的地址。
非静态成员函数都会有一个隐含参数——类类型* const this。(这里的const可以理解为不能改变this存储的对象的地址)
编译器编译后，类的成员函数默认都会在形参第一个位置增加一个当前类类型的指针，叫做this指针。比如Date类的Init的真实原型为， void Init(Date* const this, int year, int month, int day)。
类的成员函数中访问成员变量，本质都是通过this指针访问的。如Init函数中给_year赋值， this->_year = year;
C++规定不能在实参（例如，当d1、d2调用Init和Print函数时，会有隐含的d1、d2的地址作为实参，即this指针）和形参的位置显示的写this指针(实参形参位置都不用写是因为编译时编译器会处理)，但是可以在成员函数体内显示使用this指针。

区分：

类实例化出的对象的成员变量（成员变量的定义）：开空间
类中的成员变量（成员变量的声明）：没开空间

指针的2个const:
例如：const int* p1;、int* const p2;

const在*的左边，const修饰的是指针指向的内容。指针指向的内容不能被改变，但是指针本身可修改，所以p1可以不初始化，即便初始化了后面也可以修改。
const在*的右边，修饰的是指针本身。指针本身不能被修改，防止后面被修改，所以必须要初始化，上述p2没初始化会报错，可以写成int* const p2 = nullptr;。但是指针指向的内容是可以改变的，像下面的示例，this->_year = year;就行得通。

因为C中数据（在结构体里）和方法（全局函数）是分离的，C中在函数里访问结构体里的成员变量需要传递结构体指针，再解引用实现。
C++实际上也传递了类实例化出的对象的指针给this，通过指针this来访问成员函数里的成员变量。
二者本质一样，都传递指针

#include<iostream>
using namespace std;
class Date
{
public:
	 //实际上是void Init(Date* const this, int year, int month, int day)
	void Init(int year, int month, int day)
	{
		// 编译报错：error C2106: “=”: 左操作数必须为左值
		// this = nullptr;
		
		_year = year;// 实际：this->_year = year;
		this->_month = month;
		this->_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	// 这⾥只是声明，没有开空间
	int _year;
	int _month;
	int _day;
};
int main()
{
	// Date类实例化出对象d1和d2
	Date d1;
	Date d2;
	d1.Init(2024, 3, 31);// 实际：d1.Init(&d1, 2024, 3, 31);
	d1.Print();
	d2.Init(2024, 7, 5);// 实际：d2.Init(&d2, 2024, 3, 31);
	d2.Print();
	return 0;
}

在这里插入图片描述

选择题：

下面程序编译运行结果是（）

A、编译报错 B、运行崩溃 C、正常运行

#include <iostream>
using namespace std;
class A
{
public:
	void Print()
	{
		cout << "A::Print()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

下面程序编译运行结果是（）

A、编译报错 B、运行崩溃 C、正常运行

#include <iostream>
using namespace std;
class A
{
public:
	void Print()
	{
		cout << "A::Print()" << endl;
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

this指针存在内存哪个区域的 ()

A. 栈 B.堆 C.静态区 D.常量区 E.对象里面

解析：

前两道：

前两道选择题无论如何都不能选编译报错，因为对空指针的访问不会编译报错，而是会报运行崩溃。但是第一题不会运行崩溃，原因是没有空指针的访问（对空指针进行解引用）。

为什么没有空指针的访问呢？p->Print()看似是对空指针解引用，但成员函数的指针是没有存进对象里的，所以这里就是没有对空指针进行解引用。这也说明，看到箭头不一定是解引用。

那么成员函数的地址从哪里来的？成员函数的地址/指针是在编译时就确定的，因为函数的调用p->Print()就变成了call这个函数的地址，这样就能通过地址找到函数了。
在这里插入图片描述

指针p的功能？汇编里面没有对p进行访问，p->Print()，编译器看到这个地方是p指针去调用Print()，编译时会找Print()出处，即在A类里找成员函数Print()，在编译时确定Print()的地址（call这个函数的地址）。该过程没有解引用。

这里实际上实参形参有隐含的this指针，若是对象调用成员函数，则把对象的地址传递过去；若是对象的指针调用成员函数，直接就把对象的地址作为实参传递过去。在这里p就是对象的地址，p是空指针，所以this也是空指针。题目2中函数体内访问成员变量对空指针进行解引用this->_a，会运行崩溃。题目1中空指针没有解引用，正常运行。

第三题：

算对象的大小要不要算this指针？没有吧，所以，对象里面没有this指针。

成员变量在对象里，成员变量用对象去访问

静态数据、全局数据存在静态区
常量数据（例如，常量字符串）存在常量区
动态开辟在堆

局部数据存在栈，函数调用建立栈帧就在栈这个区域

this指针是个形参，函数的参数是存在栈帧里面的，所以this指针存在内存栈区域的。

（但是，不同的编译器情况不一样，若在vs编译器下，会认为this指针需要被频繁调用，所以会将this存储在寄存器里，在vs2019下，ecx存储传递this指针的值。了解即可，答案还是存在内存栈里。）

四、C++和C语言实现Stack对比

面向对象三大特性：封装、继承、多态，下面的对比我们可以初步了解一下封装。

通过下面两份代码对比，我们发现C++实现Stack形态上还是发生了挺多的变化，底层和逻辑上没啥变化。

C++中数据和函数都放到了类里面，通过访问限定符进行了限制，不能再随意通过对象直接修改数据，这是C++封装的一种体现，这个是最重要的变化。这里的封装的本质是一种更严格规范的管理，避免出现乱访问修改的问题。当然封装不仅仅是这样的，我们后面还需要不断的去学习。

C++中有一些相对方便的语法，比如Init给的缺省参数会方便很多，成员函数每次不需要传对象地址，因为this指针隐含的传递了，方便了很多，使用类型不再需要typedef用类名就很方便。

在我们这个C++入门阶段实现的Stack看起来变了很多，但是实质上变化不大。等着我们后面看STL中的用适配器实现的Stack，大家再感受C++的魅力。

C实现Stack代码

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	// 满了， 扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
int main()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	STPush(&s, 3);
	STPush(&s, 4);
	while (!STEmpty(&s))
	{
		printf("%d\n", STTop(&s));
		STPop(&s);
	}
	STDestroy(&s);
	return 0;
}

C++实现Stack代码

#include<iostream>
#include <assert.h>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	// 成员函数
	void Init(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
	void Pop()
	{
		assert(_top > 0);
		--_top;
	}
	bool Empty()
	{
		return _top == 0;
	}
	int Top()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}
	void Destroy()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	// 成员变量
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
int main()
{
	Stack s;
	s.Init();
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	while (!s.Empty())
	{
		printf("%d\n", s.Top());
		s.Pop();
	}
	s.Destroy();
	return 0;
}

五、类的默认成员函数

默认成员函数就是用户没有显式实现（自己写），编译器会自动生成的成员函数称为默认成员函数（但是我们写了，编译器就不会自动生成）。一个类，我们不写的情况下编译器会默认生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解一下即可。其次就是C++11以后还会增加两个默认成员函数，移动构造和移动赋值，这个我们后面再讲解。那么问题来了，我们不写，编译器就能自动生成的话我们为什么要学类的默认成员函数呢？我们要从两个方面去学习：

我们不写时，编译器自动生成的成员函数行为是什么，是否满足我们的需求。
编译器自动生成的成员函数不满足我们的需求，我们需要自己实现，那么如何自己实现？

所以在每学完一个类的默认成员函数，可以用自己的话对照两个问题把核心知识点过一遍。

在这里插入图片描述

因为类的默认成员函数也是成员函数，会有隐含的this指针的。

六、构造函数

构造函数是特殊的成员函数（不能以对普通成员函数的理解去理解它），需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象（我们常使用的局部对象在栈帧创建时，空间就开好了），而是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代了Init。

构造函数怎么写？

函数名与类名相同。
无返回值无返回类型。 (返回值啥都不需要给，也不需要写void)
对象实例化时系统会自动调用对应的（参数匹配）构造函数。（构造函数和默认构造函数的区分：包含与被包含关系，默认构造函数有3个，带参构造是构造函数但不是默认构造函数)
构造函数可以重载。（可以有多个构造函数构成重载，为什么要有多个构造函数呢？函数有多个初始化的方式。）

构造函数特性

如果类中没有显式定义（自己写）构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
默认构造函数有3个：无参构造函数、全缺省构造函数、我们不写构造时编译器自动生成的无参的默认构造函数。但是这三个函数有且只有一个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义；无参构造或全缺省构造显示定义了,那么编译器就不能自动生成无参默认构造。要注意默认构造函数不只是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结一下就是不传实参就可以调用的构造就叫默认构造。补充一点，默认成员函数与默认构造是不一样的。

我们不写，编译器默认生成的无参构造，对内置类型的成员变量是否初始化是不确定的，是否初始化取决于编译器。也就是说，我们不写，编译器自动生成的无参构造大部分情况下不能满足我们的需求，一般情况下需要传递参数完成初始化工作，所以大多数的类的构造函数还是需要我们自己写，确定初始化方式。例如，Date类，若不想输出随机数，就不能依靠编译器自动生成的无参构造，而是要自己写构造；再比如，Stack类，里面有动态开辟的空间，若知道初始化空间的大小，需要传递参数，那么编译器自动生成的无参构造也不能满足初始化对象的需求，还是需要显示定义构造。
对于自定义类型的成员变量，要求调用这个成员变量的默认构造函数初始化。例如，像MyQueue这样的类，成员变量都是自定义类型的，那就不用显示定义MyQueue的构造函数，而是编译器自动生成MyQueue类的构造函数会调用两个成员变量Stack类的构造函数，完成了两个成员的初始化。
如果这个成员变量，没有默认构造函数，那么就会编译报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表稍后讲解。

注：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

构造函数最大特点：根据传递的参数自动调用构造函数，构造函数调用和普通函数调用不一样。

对象实例化时系统会自动调用对应的（参数匹配）构造函数：

没有实参，在实例化出的对象后面不加空括号()
有实参，在实例化出的对象后面加上实参列表，例Date d1(2025, 3, 15);

全缺省构造好用：既可以无参构造，也可以带参构造

在这里插入图片描述

#include <iostream>
using namespace std;
class Date {
public:
	// 1. 无参构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2. 带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	 3. 全缺省构造函数
	//Date(int year = 1, int month = 2, int day = 3)
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	//Date d1();
	d1.Print();

	//Date d2(2025);
	//Date d2(2025, 3);
	Date d2(2025, 3, 15);
	d2.Print();
	return 0;
}

#include <iostream>
using namespace std;
typedef int STDataType;
class Stack {
public:
	//Stack类的构造函数
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc fail!");
			exit(1);
		}
		_top = 0;
		_capacity = n;
	}
	//...
private:
	STDataType* _a;
	size_t _top;
	size_t _capacity;
};
//MyQueue类，两个Stack实现队列
class MyQueue {
public:
private:
	Stack pushst;
	Stack popst;
	int _n;
};
int main()
{
	Stack st;
	Stack st1(8);
	MyQueue mq;
	//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
	return 0;
}

在这里插入图片描述

初始化列表

“没有默认构造函数，那么就会编译报错”是个什么场景呢?例如MyQueue类，有两个自定义类型Stack的成员变量，写了Stack类的带参构造函数，所以编译器不自动生成无参默认构造，但是由于写的也不是默认构造，所以自定义类型Stack的成员变量就没有默认构造，编译器会报错。那么这个构造函数实现不了对这两个成员变量的函数体内赋值初始化，还有一种方式可以实现初始化成员变量——初始化列表。

之前我们实现构造函数时，初始化成员变量主要使用函数体内赋值，对象实例化时初始化对象还有一种方式，就是初始化列表，初始化列表的使用方式是在构造函数参数列表下面以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值（参数/常量值）或表达式。（两种初始化成员变量的方式可以混着来）
初始化列表核心：每个成员变量在初始化列表中只能出现一次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方（与对象整体初始化区分，对象整体定义初始化：Date d1;）。即便成员变量声明时有缺省值，那这个缺省值也是给初始化列表的。在构造函数体内初始化的成员变量也会走初始化列表，还是只能在初始化列表中出现一次，因为是每个成员变量定义初始化的地方。
引用成员变量，const成员变量，没有默认构造函数的类类型成员变量，必须放在初始化列表位置进行初始化，否则会编译报错。（引用必须初始化，初始化后不能修改。被const修饰后不能修改，所以必须初始化）
C++11支持在成员变量声明的位置给缺省值（缺省值可以是表达式、值、构造函数的参数类型的值），但是这个行为不是初始化。缺省值是给初始化列表的，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。
尽量使用初始化列表初始化，因为那些你不在初始化列表初始化的成员也会走初始化列表（在构造函数体内初始化的成员变量也会走初始化列表），如果这个成员在声明位置给了缺省值且没有在初始化列表显示初始化，初始化列表会用这个缺省值初始化。若这个成员在声明位置给了缺省值且也在初始化列表显示初始化，还是会用初始化列表里的值初始化。如果你没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定，对于没有显示在初始化列表初始化的自定义类型成员，编译器会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。
初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持一致。（下面有对应的练习题）

总结：
无论是否显示写初始化列表，每个构造函数都有初始化列表；
无论是否在初始化列表显示初始化成员变量，每个成员变量都要走初始化列表初始化；

在这里插入图片描述

在这里插入图片描述
初始化列表按照成员变量在类中声明的顺序进行初始化。先初始化a2，但是初始值是a1且a1没有初始化，是随机值，所以a2是随机值。再初始化a1，a1在初始化列表中显示初始化了，所以a1为1。最后选D。

#include <iostream>
using namespace std;
class Time {
public:
	// 带参构造函数
	Time(int hour)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};
class Date {
public:
	//构造函数
	Date(int& x, int year = 1, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
		,_n(12)
		,_ret(x)
		,_t(24)
	{

	}
	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	int& _ret; // 引用成员变量
	const int _n; // const成员变量
	Time _t; // 没有默认构造函数的类类型成员变量
};
int main()
{
	int i = 1;
	Date d1(i);
	d1.Print();
	return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;
class Time {
public:
	// 带参构造函数
	Time(int hour)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};
class Date {
public:
	// 构造函数
	Date()
		:_month(3)
	{
		cout << "Date()" << endl;
	}
	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	// 注意这⾥不是初始化，这⾥给的是缺省值，这个缺省值是给初始化列表的
	// 如果初始化列表没有显⽰初始化，默认就会⽤这个缺省值初始化
	int _year = 2025;
	int _month;
	int _day = 18;
	const int _n = 1; // const成员变量
	Time _t = 1; // 没有默认构造函数的类类型成员变量
	int* _ptr = (int*)malloc(10);
};
int main()
{
	Date d1;
	d1.Print();
	return 0;
}

在这里插入图片描述

class Date {
private:
	int _year = 1;
	int _month = 1;
	int _day; // 没写缺省值，也没在初始化列表初始化，是否初始化取决于编译器
};

对于这些成员变量，想在初始化列表或在函数体内初始化都行：

class Date {
private:
	int _year;
	int _month;
	int _day;
};

class Date {
public:
	// 构造函数
	Date(int& x, int year = 1, int month = 1, int day = 1)
		// 初始化列表
		:_year(year)
		,_month(month)
		,_n(12)
		,_ret(x)
		,_t(24)
	{
		_day = day;// 函数体内赋值，也要走一遍初始化列表
	}
private:
	int _year;
	int _month;
	int _day;
	int& _ret; // 引用成员变量
	const int _n; // const成员变量
	Time _t; // 没有默认构造函数的类类型成员变量
};

//每个成员变量在初始化列表中只能出现一次，因为初始化列表可以认为是每个成员变量定义初始化的地方
class Date {
public:
	// 构造函数
	// 两种初始化成员变量的方式可以混着来
	Date(int& x, int year = 1, int month = 1, int day = 1)
		// 初始化列表
		:_year(year)
		,_month(month)
		,_n(12) // 
		,_ret(x)
		,_t(24)
	{
		// 函数体内赋值，也要走一遍初始化列表
		_day = day;
		_n = 2; // error
	}
private:
	int _year;
	int _month;
	int _day;
	int& _ret; // 引用成员变量
	const int _n; // const成员变量
	Time _t; // 没有默认构造函数的类类型成员变量
};

没写Stack类的默认构造，编译器调用MyQueue类的默认构造调用编译器自动生成的Stack的无参默认构造，也能运行：

#include <iostream>
using namespace std;
class Stack {

};
class MyQueue {
public:
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	MyQueue mq;
	return 0;
}

MyQueue类成员变量没有默认构造函数，编译报错：

#include <iostream>
using namespace std;
class Stack {
public:
	Stack(int n)
	{
		cout << "Stack(int n)" << endl;
	}
private:
	//...
};
class MyQueue {
public:
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	MyQueue mq;// 编译报错，不具有默认构造函数
	return 0;
}

可以用初始化列表的方式初始化MyQueue类成员变量：

#include <iostream>
using namespace std;
class Stack {
public:
	Stack(int n)
	{
		cout << "Stack(int n)" << endl;
	}
private:
};
class MyQueue {
public:
	// 无参构造函数
	MyQueue(int n = 4)
		:pushst(n)
		,popst(n)
	{}
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	MyQueue mq;
	return 0;
}

在这里插入图片描述

也可以写MyQueue的构造：
显示写了MyQueue类的默认构造但是啥也没写，也会初始化MyQueue类对象。因为没在初始化列表显示初始化的成员变量都会在初始化列表初始化，那么在函数体内初始化还不如走初始化列表呢：

#include <iostream>
using namespace std;
class Stack {
public:
private:
};
class MyQueue {
public:
	// 无参构造函数
	MyQueue()
	{}
private:
	Stack pushst;
	Stack popst;
	int _n = 0;//
};
int main()
{
	MyQueue mq;
	return 0;
}

在这里插入图片描述

MyQueue类，没显示定义构造，对于自定义类型成员变量调用它的默认构造，对于内置类型成员变量可以用缺省值初始化。

七、析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁。对对象本身的销毁是不需要我们管的，比如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，全局对象也一样，只不过是在程序结束时，他就释放了。C++规定对象在销毁时会自动调用析构函数，完成对象中资源（例如，动态开辟的资源）的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date没有Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

析构函数怎么写？

析构函数名是在类名前加上字符~。（~：按位取反，可以理解为与构造函数功能相反）
无参数无返回值。(这里跟构造类似，也不需要加void)
一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
对象生命周期结束时，系统会自动调用析构函数。

析构函数特性

跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定义类型成员会调用他的析构函数。
还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。例如，MyQueue类，显示写MyQueue类的析构，也会自动调用Stack的析构。

如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如Date；
如果默认生成的析构就可以用，也就不需要显示写析构，如MyQueue，对于自定义类型的成员变量，编译器会自动调用这个成员变量的析构函数，编译器默认生成MyQueue的析构函数调用了Stack的析构，释放的Stack内部的资源；
但是有资源申请时，一定要自己写析构，否则会造成内存泄漏（可用内存越来越少），如Stack。

一个局部域的多个对象，C++规定后定义的先析构，类似数据结构栈，后进先出。

对于Stack类里有申请的资源，若不写析构函数，会导致内存泄漏（是不会报错的）。因为main()程序结束，st1、st2释放了，但堆上的空间未释放。
在这里插入图片描述
后定义的对象会先析构，类似数据结构栈，后进先出。st2先析构，st1再析构。

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

小总结：

构造函数不是开空间创建对象，析构函数一般都得自己写
析构函数不是完成对对象本身的销毁，析构函数需要资源释放就自己写
构造、析构里也有this指针

对比一下用C++和C实现的Stack解决之前括号匹配问题isValid，我们发现有了构造函数和析构函数就不会再忘记调用Init和Destory函数了，确实方便了很多。用C写isValid有两点容易出错：STInit()容易写漏，会编译报错；return之前忘写STDestroy()，不会报错，但是会有内存泄漏（可用内存会越来越少）问题。

return了，也就是出了作用域，出了作用域后会自动调用析构函数。

// ⽤最新加了构造和析构的C++版本Stack实现
bool isValid(const char* s) {
    Stack st;//自动调用构造函数
    while (*s)
    {
        if (*s == '[' || *s == '(' || *s == '{')
        {
            st.Push(*s);
        }
        else
        {
            // 右括号⽐左括号多，数量匹配问题
            if (st.Empty())
            {
                return false;//自动调用析构函数
            }
            // 栈⾥⾯取左括号
            char top = st.Top();
            st.Pop();
            // 顺序不匹配
            if ((*s == ']' && top != '[')
            || (*s == '}' && top != '{')
            || (*s == ')' && top != '('))
            {
                return false;//自动调用析构函数
            }
        }
        ++s;
    }
    //栈为空，返回真，说明数量都匹配 左括号多，右括号少匹配问题
        return st.Empty();//自动调用析构函数
}

八、拷贝构造函数

如果一个构造函数的第一个参数是类类型对象的引用，若后面还有任何额外的参数，都要有默认值（缺省值），则此构造函数也叫做拷贝构造函数，也就是说拷贝构造函数是一个特殊的构造函数。

功能：拷贝构造用于一个已经存在的对象拷贝初始化给另一个要创建的对象。

普通初始化：用值初始化成员变量

拷贝构造函数的特点

拷贝构造函数是构造函数的一个重载。
拷贝构造函数的第一个参数必须是类类型对象的引用（建议是const引用），使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。拷贝构造函数也可以多个参数，但是第一个参数必须是类类型对象的引用，后面的参数必须有缺省值。（一般不会写含有缺省值的拷贝构造函数，了解即可）

自定义类型对象传值传参会引发无穷递归，所以，自定义类型传参，引用大用特用！！！

C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。（内置类型没有拷贝构造的概念，可以传值传参）

对于自定义类型对象，调用拷贝构造的几种形式：

同类型对象作为实参，例如：Date d2(d1);
传值传参
传值返回

若未显式定义拷贝构造，编译器会生成自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。

像Date这样的类，成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显示实现拷贝构造。
像Stack这样的类，虽然也都是内置类型的成员变量，但是_a指向了资源，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝（对指向的资源也进行拷贝再拷贝值）。

为什么不显示定义Stack类的拷贝构造函数不符合我们的需求？有两个问题，同一块空间会多次析构和一个值修改了会改变另一个的值。

对象st1拷贝初始化对象st2，会导致2个对象里的_a指向同一块资源，后定义的先析构，st2先析构，会把这块空间释放了，st1再析构，会把这块空间再次析构，同一块空间不能同时析构两次，程序会崩溃。还有一个问题，当st2入栈了一个值，相当于st1也push了一个值，但是st1的top值会在push()函数里面改变，这样的话st1的top值又不对。所以，对于类里有资源的，一定要显示定义拷贝构造函数。

在这里插入图片描述

显示拷贝构造，分别指向两块空间，完成深拷贝。

在这里插入图片描述

像MyQueue这样的类型，内部主要是自定义类型Stack成员，不需要我们显示实现MyQueue的拷贝构造，编译器自动生成的拷贝构造会调用Stack类的拷贝构造。
这里还有一个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要显示写拷贝构造，否则就不需要。因为写了析构说明有资源需要释放，有资源说明就需要自己写深拷贝对这个资源也进行拷贝。

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

相比用传值传参和传值返回，用传引用传参和传引用更不容易出错。传引用传参随便用，但是传引用返回不能随便用。

第一个参数传引用传参和传值传参有什么区别？

传引用传参就没有问题：Date d2(d1);，类实例化对象d2时，对象d1拷贝初始化要创建的对象d2，调用拷贝构造函数Date(Date& d)，调用拷贝构造前先传参，形参是实参的别名，不用开空间，直接在函数体内完成拷贝初始化，不会形成新的拷贝构造。
传值传参有问题：会额外开空间并且还会调用新的拷贝构造函数。
- 先看易懂的普通的传值传参：

调用Func()前先传值传参，把d1传给d，也就是传值传参，即Date d(d1)，类实例化对象d时，对象d1拷贝初始化要创建的对象d，这里的自定义类型对象有拷贝行为就要调用拷贝构造，即传值传参就要调用拷贝构造，这里d是d1的别名，所以就正常调用，完成函数体内拷贝，会回来的。

在这里插入图片描述

- 再看稍复杂的传值传参：

Date d2(d1);，类实例化对象d2时，对象d1拷贝初始化要创建的对象d2，调用拷贝构造函数Date(Date d)，调用拷贝构造前先传值传参，即Date d(d1);，很明显，传值传参后会调用新的拷贝构造，形成了无穷递归，回不来了。

在这里插入图片描述

所以，拷贝构造函数的第一个参数必须是类类型对象的引用。

为什么建议加const？

d是d1的别名，d2的地址是this，本来是d1拷贝初始化d2，这里就写反了，d2这里成员变量是随机值，所以拷贝结果d1、d2的成员变量都是随机值。若加上const就没有问题了，即便写反了编译器会报错提醒你修改，d1是不能被改变的。所以，传引用传参不想改变实参的话就加上const，不过，一般加了引用就会加const。加了const,可以传普通对象，也可以传具有常量、常性这种对象，加不加const都行,普通对象传过来权限可以缩小。

在这里插入图片描述

#include <iostream>
using namespace std;
class Date {
public:
	//构造函数
	Date(int year = 1, 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;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2025, 3, 15);
	d1.Print();

	Date d2(d1);
	d2.Print();
	d1.Print();
	return 0;
}

示例辅助理解

#include <iostream>
using namespace std;
class Date {
public:
	//全缺省构造函数
	Date(int year = 1, 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;
	}
	//构造函数
	Date(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;
};
Date& Func()
{
	Date tmp(2025, 3, 16);
	tmp.Print();
	return tmp;
}
int main()
{
	Date d1(2025, 3, 15);
	d1.Print();

	//这里可以完成拷贝,但不是拷贝构造,只是一个普通构造
	Date d2(&d1);
	d2.Print();

	//这是拷贝构造,通过同类型对象拷贝初始化,而不是指针
	Date d3(d1);
	d3.Print();

	//这也是拷贝构造
	Date d4 = d3;
	d4.Print();

	//Func()返回了一个局部对象的引用作为返回值
	//Func()函数结束,函数栈帧销毁,tmp对象也销毁了,这个引用就是野引用了
	Date ret = Func();
	ret.Print();

	return 0;
}

#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()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
	//显示定义拷贝构造函数
	Stack(const Stack& st)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc fail!");
			exit(1);
		}
		//浅/值拷贝就像memcpy一样
		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		//top、capacity正常浅/值拷贝
		_top = st._top;
		_capacity = st._capacity;
	}
	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newCapacity = 2 * _capacity;
			STDataType* tmp = (STDataType*)realloc(_a, sizeof(STDataType) * newCapacity);
			if (nullptr == tmp)
			{
				perror("realloc fail!");
				exit(1);
			}
			_a = tmp;
			_capacity = newCapacity;
		}
		_a[_top++] = x;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
//两个Stack实现队列
class MyQueue {
public:
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	//拷贝构造
	Stack st2(st1);
	//拷贝构造还可以这样写
	Stack st3 = st1;

	MyQueue mq1;
	MyQueue mq2 = mq1;
	return 0;
}

九、赋值运算符重载

运算符重载/重载运算符函数

运算符重载不是类的默认成员函数，可以重载在全局。

内置类型是支持常见的运算符的，怎么支持的呢？内置类型是偏简单的类型编译时会转换成对应的指令，运算符编译时也会转换成指令，二者的指令的很多行为匹配，所以支持。而自定义类型是复杂的类型，没有对应的指令，编译器不知道他们的存在，所以不能用对应的运算符运算。那么如何让自定义类型的对象用运算符呢？——运算符重载。

别看都有重载二字，但表达的意思是不一样的。

运算符重载：可以让自定义类型用运算符，可以通过运算符重载函数去控制自定义类型用运算符的行为是什么，比如说比较是否相等、日期减日期等等怎么比较怎么算，我们可以自己控制这里面的逻辑，写在运算符重载函数体里。
函数重载：是支持函数名相同但参数不同的函数同时存在。

当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
运算符重载是具有特殊名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。（operator是一个关键字）
重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符（例如：解引用*、->等）有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。（有一些二元运算符的左右两个对象的位置不能颠倒，例如，-、+=等；有一些二元运算符的左右两个对象的位置能颠倒，例如，==等）
如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐含的this指针，因此运算符重载作为成员函数时，参数个数比运算对象少一个。
运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。
不能通过连接语法中没有的符号来创建新的操作符：比如operator@。
.*、 ::、 sizeof、 ?:（是一个三目操作符）、 .，注意以上5个运算符不能重载。(选择题里面常考）

//.*操作符的运用
#include <iostream>
using namespace std;
class A {
public:
	void Func()
	{
		cout << this << endl;
		cout << "A::Func()" << endl;
	}
};
typedef void(A::* PF)(); //成员函数指针类型 typedef void(A::*)() PF;
//这个就是一中类型，只不过我们不常用，A::*这个表示是A类的成员指针类型是 void()()，
//就是一个返回值为void，没有其他参数的函数，那么合在一起理解，这个就是A类的一个成员函数指针类型
int main()
{
	// C++规定成员函数要加&才能取到函数指针
	PF pf = &A::Func;

	A obj;
	cout << &obj << endl;

	// 对象调用成员函数指针时，使用.*运算符。*pf:对成员函数的指针解引用
	(obj.*pf)();//会传递对象obj的地址
	return 0;
}

重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： int operator+(int x, int y)，会编译报错：“operator +”必须至少有一个类类型的形参。
一个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意义（day天之前的日期或者是日期减日期），但是重载operator*就没有意义。（*既可以表示乘法。也可以表示解引用）
重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。C++规定，后置++重载时，增加一个int形参（仅仅是为了区分），跟前置++构成函数重载，方便区分。
重载<<和>>时，需要重载为全局函数，因为重载为成员函数，隐含的this指针是对象的地址，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性。重载为全局函数把ostream/istream放到第一个形参位置就可以了，第二个形参位置当类类型对象。C++提供流插入、流提取运算符本质上是支持各种类型的输入输出，其中自定义类型要调用对应的运算符重载。

C++里提供流插入、流提取运算符重载的原因：printf、scanf无法支持自定义类型的输出输入。C++支持内置类型的输入输出，是因为库里面已经通过运算符重载将内置类型重载为istream、ostream类的成员函数了。不用指定格式，自动识别类型，例如int i = 9; cout << i;，自动识别类型的本质就是编译器识别出他们俩是作为成员函数的函数重载，转换成对应的运算符重载的调用：

#include <iostream>
using namespace std;
int main()
{
	int i = 9;
	cout << i;
	cout.operator<<(i);//第一个参数this是ostream类的对象cout的地址

	double d = 12.3;
	cout << d;
	cout.operator<<(d);
	return 0;
}

在这里插入图片描述

连续输出多个不同的内置类型，就调用了多次不同的运算符重载（重载为成员函数），这些运算符重载构成函数重载。结合性从左到右，但是C++IO效率比C低，像这种反复调用且较小的函数就可以定义在类里成为内联，就可以提高效率了（还有一个提高C++IO的方法：之前在《C++入门基础》中讲C++输入输出的时候提到的那三行代码也是可以的。）：
在这里插入图片描述
但是流插入、流提取自定义类型对象时，对应的运算符重载为成员函数的话，会有匹配不对的问题：

流插入、流提取自定义类型对象，需要运算符重载为全局函数，但是会面临访问不了私有成员的问题。类外面的全局函数想用对象访问私有成员有两种方法，第一种解决办法就是用公有的getxxx函数访问私有的，但是若是私有成员太多了，这种方法就要写很多公有函数，会很繁琐。第二种解决办法更好，在类里加个友元声明（可以理解为类外面的全局函数变成朋友，都是朋友了就可以访问私有成员啦），没有this，因为这是一个全局函数（对于友元，本节后面会讲解）。但是这还是一个全局函数，全局函数有危险，还是会编译报错的。全局函数多个.cpp文件包含会有命名冲突的问题（多个符号表包含同一个函数会有冲突），解决办法：方法一，全局函数声明（.h）和定义（.cpp）分离；方法二，在.h里定义成inline（小函数，效率高），不会将函数放进符号表里，多个.cpp文件包含不会有命名冲突的问题，inline在调用的地方展开，不会生成函数的一堆指令去生成函数地址放进符号表里。

自定义类型的对象使用流插入、流提取运算符时，对应的运算符重载在类里的友元声明如下，以Date类为例：

friend ostream& operator<<(/*没有const,对象流入流对象cout里，下同*/ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);

为什么流提取运算符重载中没有const引用对象？原因是流提取表示提取进来的值会放进对象里，所以对象是会被改变的，不能加const。

d1 == d2;编译通过的本质是编译器把他转换成对应的重载运算符函数的调用，即operator==(d1, d2);。运算符重载函数也可以显示调用operator==(d1, d2);，不过可读性不强。

从汇编的角度看，函数的调用会转变成call这个函数的地址，这两种写法是一样的：

在这里插入图片描述

运算符重载为全局函数，面临对象访问私有成员的问题，有以下几点可以解决：

私有的放为公有的。（不推荐，按照封装的概念，是不期望数据（成员变量）暴露的）
Date类里提供getxxx函数。（通过公有的成员函数去访问私有的成员变量，但不等于将成员变量开放为公有的。有点麻烦，要写多个getxxx函数。至于后面为什么加const？可获取但不能修改成员变量，具有封装的意义）PS：后面加const在取地址运算符重载中会讲解
友元函数（后面会讲解）
重载为成员函数（前面几种方式都有点复杂，这个较简单实现）

下面的这个示例中，d1 == d2，若写成指针的形式&d1 == &d2，形参用指针类型接收，比较的就是两个对象的地址是否一样，不是比较两个对象了，所以这里就体现了C++的引用具有指针的不可替代性。

//日期类的两个对象是否相等的运算符重载函数——私有放公有
#include <iostream>
using namespace std;
class Date {
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
//private:
	int _year;
	int _month;
	int _day;
};
bool operator==(const Date& x, const Date& y)
{
	//把私有成员放为公有的才能访问,不推荐
	return x._year == y._year
		&& x._month == y._month
		&& x._day == y._day;
}
int main()
{
	Date d1(2025, 3, 16);
	Date d2(2025, 3, 16);
	bool ret = (d1 == d2);
	if (ret)
	{
		cout << "两个日期对象相等" << endl;
	}
	else {
		cout << "两个日期对象不相等" << endl;
	}
	return 0;
}

//日期类的两个对象是否相等的运算符重载函数——Date类里提供getxxx函数
#include <iostream>
using namespace std;
class Date {
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	int GetYear() const
	{
		return _year;
	}
	int GetMonth() const
	{
		return _month;
	}
	int GetDay() const
	{
		return _day;
	}
private:
	int _year;
	int _month;
	int _day;
};
bool operator==(const Date& x, const Date& y)
{
	return x.GetYear() == y.GetYear()
		&& x.GetMonth() == y.GetMonth()
		&& x.GetDay() == y.GetDay();
}
int main()
{
	Date d1(2025, 3, 16);
	Date d2(2024, 3, 16);
	//运算符重载函数也可以显示调用
	bool ret = (operator==(d1, d2));
	//bool ret = (d1 == d2);//编译器会转换成bool ret = (operator==(d1, d2));
	if (ret)
	{
		cout << "两个日期对象相等" << endl;
	}
	else {
		cout << "两个日期对象不相等" << endl;
	}
	return 0;
}

运算符重载函数体内对象会访问私有的成员变量，运算符重载函数放在类外面，会导致对象访问不到私有的成员变量，所以干脆直接把运算符重载成成员函数：

//日期类的两个对象是否相等的运算符重载函数——重载为成员函数
#include <iostream>
using namespace std;
class Date {
public:
	Date(int year = 1, 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;
};
int main()
{
	Date d1(2025, 3, 16);
	Date d2(2024, 3, 16);
	if (d1.operator==(d2))
	//if (d1 == d2)
	{
		cout << "两个日期对象相等" << endl;
	}
	else {
		cout << "两个日期对象不相等" << endl;
	}
	return 0;
}

前置++返回的是++之后，后置++返回的是++之前。

//前置++和后置++
#include <iostream>
using namespace std;
class Date {
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	Date operator++(int)
	{
		Date tmp;
		cout << "后置++" << endl;
		//...
		return tmp;//出了这个函数，tmp会销毁，所以用传值返回
	}
	Date& operator++()
	{
		cout << "前置++" << endl;
		//...
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2025, 3, 16);
	Date d2(2025, 3, 20);

	//d1++;
	d1.operator++(10000);//随便一个整型值都行
	++d2;
	//d2.operator++();
	return 0;
}

//自定义类型对象使用二元运算符[]时转换成调用对应的运算符重载
//完成遍历顺序表中的数据并输出
#include <iostream>
using namespace std;
class SeqList
{
public:
	SeqList(int n = 4)
	{
		_a = (int*)malloc(sizeof(int)*n);
		//...
		_size = 0;
		_capacity = 4;
	}
	~SeqList()
	{
		free(_a);
		_a = nullptr;
		_size = _capacity = 0;
	}
	void PushBack(int x)
	{
		// 扩容
		// ...
		_a[_size++] = x;
	}
	int size()
	{
		return _size;
	}
	int& operator[](size_t i)
	{
		return _a[i];//数据在内存堆上,出了函数不会销毁,所以用传引用返回
	}
private:
	int* _a;
	int  _size;
	int  _capacity;
};
int main()
{
	SeqList s;
	s.PushBack(1);
	s.PushBack(2);
	s.PushBack(3);
	s.PushBack(4);
	//可以读
	for (int i = 0; i < s.size(); i++)
	{
		//cout << s.operator[](i) << " ";
		cout << s[i] << " ";
	}
	cout << endl;
	//也可以写
	for (int i = 0; i < s.size(); i++)
	{
		s[i] += 10;
		cout << s[i] << " ";
	}
	cout << endl;
	return 0;
}

赋值运算符重载

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

赋值运算符重载的特点

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

像Date这样的类，成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显示实现赋值运算符重载。
像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝再拷贝值)。
像MyQueue这样的类，内部主要是自定义类型Stack成员，编译器自动生成的赋值运算符重载会调用Stack的赋值运算符重载，也不需要我们显示实现MyQueue的赋值运算符重载。这里还有一个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要。

//连续赋值场景
#include <iostream>
using namespace std;
class Date {
public:
	//全缺省构造函数——默认构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	Date(const Date& d)
	{
		cout << "Date(const Date& d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//运算符重载
	Date& operator=(const Date& d)
	{
		//减少自己给自己赋值
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d0;
	d0.Print();
	Date d1(2025, 3, 17);
	Date d2(2026, 3, 17);

	//赋值运算符重载，两个已经存在的对象直接的拷贝赋值
	//连续赋值，从右往左依次赋值
	//类比
	//int i, j;
	//i = j = 10;
	d0 = d1 = d2;
	d0.Print();
	d1.Print();
	d2.Print();
	return 0;
}

在这里插入图片描述

//赋值运算符重载与拷贝构造函数的区分
#include <iostream>
using namespace std;
class Date {
public:
	//全缺省构造函数——默认构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	Date(const Date& d)
	{
		cout << "Date(const Date& d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//运算符重载
	Date& operator=(const Date& d)
	{
		//不要自己给自己赋值
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2025, 3, 17);
	Date d2(2026, 3, 17);
	d1 = d1;
	//赋值运算符重载，两个已经存在的对象直接的拷贝赋值
	d2.operator=(d1);//d2 = d1;
	d1.Print();
	d2.Print();

	//拷贝构造，一个已经存在的对象拷贝初始化给另一个要创建的对象
	Date d3(d2);
	d3.Print();

	//注意这里是拷贝构造，不是赋值运算符重载
	//拷贝构造，一个已经存在的对象拷贝初始化给另一个要创建的对象
	//赋值运算符重载，两个已经存在的对象直接的拷贝赋值
	Date d4 = d1;
	d4.Print();
	return 0;
}

在这里插入图片描述

//Date类，不需要显式定义赋值运算符重载，编译器自动生成的就满足我们的需求
#include <iostream>
using namespace std;
class Date {
public:
	//全缺省构造函数——默认构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2025, 3, 17);
	Date d2(2026, 3, 17);
	//赋值运算符重载，两个已经存在的对象直接的拷贝赋值
	d2.operator=(d1);//d2 = d1;
	d1.Print();
	d2.Print();
	return 0;
}

在这里插入图片描述

十、取地址运算符重载

const成员函数

const成员函数：用const修饰的成员函数。关键字const放到成员函数参数列表的后面。
这个const实际上修饰的是该成员函数隐含的this指针指向的内容，表明在该成员函数中不能对类的任何成员变量进行修改。例如，const修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this（this指针也不能被修改），凡是不改变调用对象本身的就可以加const。

#include <iostream>
using namespace std;
class Date {
public:
	//全缺省构造函数——默认构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//void Print(const Date* const this)
	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 这⾥非const对象也可以调⽤const成员函数是⼀种权限的缩⼩
	// 可读可写变只能读
	Date d1(2025, 3, 17);
	d1.Print();

	const Date d2(2026, 3, 17);
	d2.Print();
	return 0;
}

之前提到过的，权限不可放大，但是可以缩小：
在这里插入图片描述

在这里插入图片描述

取地址运算符重载

取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，一般这两个函数编译器自动生成的就可以够我们用了，不需要去显示实现。这两个函数构成函数重载，调用不会产生分歧。除非一些很特殊的场景，比如我们不想让别人取到当前类对象的地址，就可以自己实现一份，胡乱返回一个地址。

#include <iostream>
using namespace std;
class Date
{
public:
	//全缺省构造函数——默认构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//普通取地址运算符重载
	Date* operator&()
	{
		//return this;
		return (Date*)0x012245EF;//不想让别人取到当前类对象的地址
	}
	
	//const取地址运算符重载
	//const成员函数，加了const之后this指针就是const Date*类型的，返回类型也要改成这个
	const Date* operator&() const
	{
		//return this;
		 return nullptr;//不想让别人取到当前类对象的地址
	}
private:
	int _year; 
	int _month; 
	int _day; 
};
int main()
{
	Date d1;
	cout << &d1 << endl;

	//const引用必须初始化
	const Date d2(2025, 3, 17);
	cout << &d2 << endl;
	return 0;
}

在这里插入图片描述

十一、类型转换

有关自定义类型，C++支持单参数内置类型隐式类型转换为自定义类型，多参数内置类型（花括号括起）隐式类型转换为自定义类型，需要有相关内置类型为参数的构造函数，自定义类型隐式类型转换成自定义类型，需要相应的构造函数支持，没有构造函数支持会报错。构造函数前面加explicit就不再支持隐式类型转换。
隐式类型转换会生成一个临时对象。隐式类型转换支持这样的间接传参，例如下面的Stack类。
C++支持任意类型隐式类型转换为自定义类型，这样就方便传参时不用单独去构造对象，而是可以直接传递构造临时对象的参数。

在这里插入图片描述

隐式类型转换必须用const引用临时对象。const能引用对象（左值对象）和整型（右值对象），例如A aa1 = 1; const A& aa2 = aa1;、const A& aa3 = 1;。但是不能普通引用，例如A& aa1 = 1;、B& bb = aa1;，报错原因不是因为类型不同，而是因为1构造出A类（aa1构造出B类）的一个临时对象，临时对象具有常性，像const一样，所以必须const引用。const引用会延长临时对象的生命周期。

#include <iostream>
using namespace std;
class A {
public:
	// 构造函数前面加explicit就不再支持隐式类型转换
	// explicit A(int a1)
	A(int a1)
		:_a1(a1)
	{
		cout << "A(int a1)" << endl;
	}
	// explicit A(int a1, int a2)
	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{
		cout << "A(int a1, int a2)" << endl;
	}
	int Get() const
	{
		return _a1 + _a2;
	}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B {
public:
	// explicit B(const A& a)
	B(const A& a)//const修饰对象a中的成员不被修改,所以Get()成员函数参数列表后也要加上const
		:_b(a.Get())
	{
		cout << "B(const A& a)" << endl;
	}
	void Print() const
	{
		//_b = 9;// error:表达式必须是可修改的左值
		cout << _b << endl;
	}
private:
	int _b = 0;
};
class Stack {
public:
	void Push(const A& aa)
	{}

	void Push(const B& bb)
	{}
};
int main()
{
	// 单参数转换
	// 3(作为构造函数参数)构造出一个A类的临时对象,临时对象拷贝初始化aa1
	// 编译器遇到连续 构造+拷贝构造 -> 优化为直接构造
	A aa1 = 3;
	aa1.Print();

	A aa2(4, 5);
	A aa3 = aa2;
	aa2.Print();
	aa3.Print();

	// const引用
	const A& aa4 = 6;

	// 普通引用
	A& aa5 = aa1;

	// 多参数转换
	// { 6, 7 }构造一个A类的临时对象,这个临时对象拷贝初始化aa6
	// 编译器遇到连续 构造+拷贝构造 -> 优化为直接构造
	A aa6 = { 6, 7 };
	aa6.Print();

	B bb(aa6);
	// 类类型对象之间的类型转换
	B bb1 = aa6;
	bb1.Print();
	// const引用
	const B& bb2 = aa6;
	bb2.Print();// const修饰对象bb2,不能对对象中的任何成员变量进行修改,所以上面的Print()参数列表后面加上const

	Stack st;
	A aa7(8);
	st.Push(aa7);

	st.Push(9);// 隐式类型转换支持这样的间接传参。这种写法更简洁，更好。
			   // 9构造出一个A类的临时对象，临时对象具有常性，需要在形参位置加const
			   // 自定义类型传参引用大用特用

	A aa8(10, 10);
	st.Push(aa8);

	st.Push({ 11, 11 });// 隐式类型转换支持这样的间接传参

	B bb3(aa8);
	st.Push(bb3);
	st.Push(aa8);// 隐式类型转换支持这样的间接传参
	return 0;
}

在这里插入图片描述

十二、static成员

用static修饰的成员变量，称之为静态成员变量，静态成员变量一定要在类外进行初始化。静态成员变量不能在声明位置给缺省值初始化，因为缺省值是给构造函数初始化列表的，静态成员变量不属于某个对象，不走构造函数初始化列表。
静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。
用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。
静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。
非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
突破类域就可以访问静态成员，可以通过指定类域的方式（两种：类名::静态成员或者对象.静态成员）来访问静态成员变量和静态成员函数。
静态成员也是类的成员，受public、protected、private访问限定符的限制。

在类里可以定义两个类型的变量。

类的对象要么是构造出来的，要么是拷贝构造出来的。

可以想象成是以下的场景便于理解：

类：整个小区的建造图纸
类实例化出的对象：根据图纸建造出来的房子
静态成员：小区里的公共区域，是每一栋房子的业主共享的，是类的成员

// 实现⼀个类，计算程序中创建出了多少个类对象？
#include <iostream>
using namespace std;
class A {
public:
	A(int a = 0)
	{
		cout << "A(int a = 0)" << endl;
		++_scount;
	}
	A(const A& a)
	{
		cout << "A(const A& a)" << endl;
		++_scount;
	}
	~A()
	{
		--_scount;
	}

	// 静态成员函数
	static int GetACount()
	{
		// 没有this,不能访问非静态成员
		return _scount;
	}
private:
	// 静态成员变量在类里面声明
	static int _scount;
};
// 静态成员变量在类外初始化
int A::_scount = 0;
int main()
{
	//以下访问方式只适用于静态成员变量为公有的
	/*cout << A::_scount << endl;
	cout << a1._scount << endl;
	cout << a4._scount << endl;*/

	// 提供公有的成员函数访问私有成员,突破类域访问静态成员
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	A a4 = 2;
	//cout << GetACount() << endl;// 根据编译查找规则,先局部再全局,都找不到会报错
	cout << A::GetACount() << endl;// 或者 cout << a1.GetACount() << endl;
	                               // 对象调用静态成员函数,不传递this指针
	return 0;
}

在这里插入图片描述

求1+2+3+…+n

基于以上知识，可以写一道OJ题：

https://www.nowcoder.com/practice/7a0da8fc483247ff8800059e12d7caf1?tpId=13&tqId=11200&tPage=3&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

在这里插入图片描述

用静态成员函数、静态成员变量，调用n次构造函数，实现累加：

class Sum{
public:
    Sum()
    {
        _ret += _i;
        ++_i;
    }
    static int GetRet()
    {
        return _ret;
    }
private:
    static int _i;
    static int _ret;
};

int Sum::_i = 1;
int Sum::_ret = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        Sum arr[n];// 变长数组
        return Sum :: GetRet();
    }
};

OJ都是支持变长数组的用法的，不过，vs不支持变长数组的用法，将变长数组替换成如下写法（new、delete的用法下节会讲解）：

在这里插入图片描述

体现封装，将全局的变量放进类里面，受类域的限制，但是又不属于某个对象，是属于所有对象的，所以每个对象构造的时候都可以访问到静态成员变量。从C++封装的逻辑看，因为不期望别人修改，所以声明成私有的，相当于属于Sum类专属的全局变量，但是生命周期是全局的。

想在类里面任何一个地方访问到变量，这个变量就像一个全局变量一样，生命周期是全局的，但是又是这个类专属的，又受访问限定符的限制，别人都修改不了，那么这个变量就是静态成员变量。封装的逻辑肯定是更好的，要是放在全局，别人都能修改，就不好。

静态成员函数访问静态成员变量是非常方便的。

C++中静态成员函数、静态成员变量的出现就是让我们少用全局变量、全局函数。

全局变量、全局函数的问题：
多个文件包含会有链接问题，可以用static解决，但是static只在当前文件可见，只在当前文件可见另一个意义：在.h里定义全局的静态（成员）变量，多个文件包含其实各有一份这个变量，只不过不是同一个变量（地址不一样），C++里静态成员变量和定义在全局的静态（成员）变量不一样，因为静态成员变量可以做到声明和定义分离，所以不存在多个文件包含的时候命名冲突的问题，用的是同一份。再就是受到类域和访问限定符的限制。

在这里插入图片描述

全局变量/对象在main函数之前创建。d是在main函数之前构造？还是在main函数当中构造？第一次运行到局部静态变量d的时候才会构造，例如，若将局部静态变量到func()函数里，调用func()多次，但是静态变量也只初始化一次：

#include <iostream>
using namespace std;
class A {
public:
	A(int a1 = 0)
		:_a1(a1)
	{
		cout << "A(int a1 = 0)" << _a1 << endl;
	}
private:
	int _a1;
};
void Func()
{
	static A aa;// 局部静态变量
	cout << &aa << endl;
}
A a(2);// 全局变量
int main()
{
	Func();
	Func();
	cout << &a << endl;
	return 0;
}

在这里插入图片描述
所以构造函数调用顺序为E。

main函数结束过程中，会销毁局部变量，后定义的先析构。全局变量、局部静态变量在静态区，他们的生命周期是全局的，他们在main函数结束后才销毁，析构一定是在mian函数之后。main函数结束后，局部静态变量先销毁。所以，析构函数调用顺序为B。

十三、友元

友元函数：外部函数想通过对象访问私有和保护成员，在类里加个友元声明。

可以抽象理解为富二代家（类）的篮球场、游泳池（私有、保护成员）你不能随便去访问，但是你（全局函数）成为他的朋友就可以访问啦。

友元提供了一种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类声明的前面加friend，并且把友元声明放到一个类的里面，没有this，因为这是一个全局函数。
外部友元函数可访问类的私有和保护成员，友元函数仅仅是一种声明，他不是类的成员函数。
友元函数可以在类定义的任何地方声明，不受类访问限定符限制。（一般更喜欢放到类开始的位置）
一个函数可以是多个类的友元函数。
友元类中的成员函数都可以是另一个类的友元函数，都可以访问另一个类中的私有和保护成员。
友元类的关系是单向的，不具有交换性，比如A类是B类的友元，但是B类不是A类的友元。
友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是C的友元。
有时提供了便利。但是友元会增加耦合度（低耦合：关系不紧密。增加代码的可维护性，耦合度越低越好），破坏了封装，所以友元不宜多用。

#include <iostream>
using namespace std;
// 前置声明，否则A的友元函数声明编译器不认识B
class B;
class A
{
	// 友元声明
	friend void func(const A& aa, const B& bb);
	// const B& bb任何一个类型都要找到出处(出处:声明或定义都可以),否则编译器会报错
	// 若把b类放在a类的上面,b里的类型a又找不到了
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B
{
	// 友元声明
	friend void func(const A& aa, const B& bb);
private:
	int _b1 = 3;
	int _b2 = 4;
};
void func(const A& aa, const B& bb)//既是A的友元,也是B的友元。但是会有互相干扰的问题
{
	cout << aa._a1 << endl;
	cout << bb._b1 << endl;
}
int main()
{
	A aa;
	B bb;
	func(aa, bb);
	return 0;
}

#include<iostream>
using namespace std;
class A
{
	// 友元声明
	friend class B;//class b是class a的友元
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B
{
public:
	void func1(const A& aa)
	{
		cout << aa._a1 << endl;
		cout << _b1 << endl;
	}
	void func2(const A& aa)
	{
		cout << aa._a2 << endl;
		cout << _b2 << endl;
	}
private:
	int _b1 = 3;
	int _b2 = 4;
};
int main()
{
	A aa;
	B bb;
	bb.func1(aa);
	bb.func1(aa);
	return 0;
}

十四、只需了解的内容：内部类、匿名对象、对象拷贝时的编译器优化

内部类

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
内部类默认是外部类的友元类。
内部类本质也是一种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使用，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地方都用不了。

// 计算A类的大小
#include <iostream>
using namespace std;
class A {
private:
	static int _k;// 静态成员变量不存在对象里面,在静态区,算a的大小不包括他
	int _h = 1;
public:
	class B // B默认就是A的友元
	{
	public:
		void foo(const A& a)
		{
			cout << _k << endl;// OK
			cout << a._h << endl;// OK
			cout << a._k << endl;
			//cout << _h << endl; //error
		}
		int _b1;
	};
};
int A::_k = 2;
int main()
{
	cout << sizeof(A) << endl;// 算类型的大小也就是算这个类实例化出的对象有多大
	A::B b;// B类实例化出的对象b
	A aa;
	b.foo(aa);
	return 0;
}

在这里插入图片描述

求1+2+3+…+n 改进

class Solution {
    //专属内部类
    //Sum是Solution的友元
    //Sum外部用不了,因为是私用的内部类
    class Sum
    {
    public:
        Sum()
        {
            _ret += _i;
            ++_i;
        }
    };
public:
    int Sum_Solution(int n) {
        Sum arr[n];// 变长数组
        return _ret;
    }
private:
    static int _i;
    static int _ret;
};
int Solution::_i = 1;
int Solution::_ret = 0;

匿名对象

用类型(实参)定义出来的对象叫做匿名对象，相比之前类型对象名(实参)定义出来的叫有名对象。
匿名对象生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。
匿名对象、临时对象生命周期只在当前一行，像一次性纸杯即用即销毁。const引用可以延长匿名对象、临时对象生命周期。

下面的临时对象、匿名对象生命周期分别跟着aa2、aa3走：

// 类型转换中间会产生临时对象
const A& aa2 = 1;
// const引用匿名对象
const A& aa3 = A(3);

#include <iostream>
using namespace std;
class A {
public:
	A(int a = 1)
		:_a1(a)
	{
		cout << "A(int a = 1)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1;
};
class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};
int main()
{
	//有名对象
	A aa1;
	A aa2(3);
	
	// 不能这么定义对象，因为编译器⽆法识别下⾯是⼀个函数声明，还是对象定义
	//A aa1();

	// 但是我们可以这么定义匿名对象，匿名对象的特点不⽤取名字，
	// 但是他的⽣命周期只有这⼀⾏，我们可以看到下⼀⾏他就会⾃动调⽤析构函数
	A();
	A(2);
	
	// 普通写法，类实例化出的对象，利用对象调用成员函数
	//Solution s;
	//s.Sum_Solution(10);
	
	// 匿名对象在这样场景下就很好⽤，当然还有⼀些其他使⽤场景，这个我们以后遇到了再说
	Solution().Sum_Solution(10);//简化调用成员函数的代码量
	return 0;
}

在这里插入图片描述

对象拷贝时的编译器优化

现代编译器会为了尽可能提高程序的效率，在不影响正确性的情况下会尽可能减少一些传参和传返回值的过程中可以省略的拷贝。
如何优化C++标准并没有严格规定，各个编译器会根据情况自行处理。当前主流的相对新一点的编译器对于连续一个表达式步骤中的连续拷贝会进行合并优化，有些更新更"激进"的编译器还会进行跨行跨表达式的合并优化。
linux下可以将下面代码拷贝到test.cpp文件，编译时用g++ test.cpp -fno-elide-constructors的方式关闭构造相关的优化。

#include<iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		:_a1(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a1 = aa._a1;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
};
void f1(A aa)
{}
A f2()
{
	A aa;
	return aa;
}
int main()
{
	// 传值传参
	// 构造+拷⻉构造,没有优化,不会跨行跨表达式,不是连续的构造+拷贝构造
	A aa1;// 构造
	f1(aa1);// 拷贝构造
	cout << endl;

//下面两种写法有优化
	// 隐式类型，连续构造+拷⻉构造->优化为直接构造
	f1(1);
	// ⼀个表达式中，连续构造+拷⻉构造->优化为⼀个构造
	f1(A(2));
	cout << endl;

	cout << "***********************************************" << endl;

	// 传值返回
	// 不优化的情况下传值返回，编译器会⽣成⼀个拷⻉返回对象的临时对象作为函数调⽤表达式的返回值
	

	// ⽆优化 （vs2019 debug）
	// ⼀些编译器会优化得更厉害，将构造的局部对象和拷⻉构造的临时对象优化为直接构造（vs2022 debug）
	f2();
	cout << endl;

	// 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019 debug）
	// ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，将构造的局部对象aa和拷⻉的临时对象和接收返回值对象aa2优化为⼀个直接构造。（vs2022 debug）
	A aa2 = f2();//合三为1本质:aa是aa2的别名
	cout << endl;

	//构造 + 构造可以优化
	//构造+赋值重载不可以优化,拷贝构造与赋值重载的区别

	// ⼀个表达式中，开始构造，中间拷⻉构造+赋值重载->⽆法优化（vs2019 debug）
	// ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，将构造的局部对象aa和拷⻉临时对象合并为⼀个直接构造（vs2022 debug）
	aa1 = f2();
	cout << endl;
	return 0;
}

在这里插入图片描述