---

☑️前言

?本章给大家带来的是C++类和对象！在面向对象编程中，类是用来描述某个类别对象通用属性和行为的模板，它是一种抽象的数据类型，包括成员变量和成员函数。而对象则是类的实例，是具体存在的数据，拥有自己的状态和行为。当我们创建一个对象时，就是根据类的定义来分配内存，创建对象实例，并初始化对象的成员变量以及相关状态。
?类具有封装、继承和多态等特性。封装性将数据和操作数据的行为封装在一个类的内部，并且只向外部提供必要的接口，以保证数据的安全性和一致性。继承机制允许我们从已有的类中派生出新的类，新的类可以沿用基类的数据和行为，也可以自定义扩展新的数据和行为。多态是指同一函数或方法在不同情况下表现出不同的行为，可以通过虚函数和接口来实现。(本章只涉及封装这一特性，继承和多态的讲解在后续文章会推出)
?类和对象这一节的知识点，贯穿了整个C++的学习，深刻理解类和对象和熟练使用类和对象是后面C++学习的坚实的基础。

---

1. 本篇文章篇幅较长，建议通过目录精准定位阅读，或者使用电脑阅读体验更好噢~

2. 接下来就进入【C++】类和对象的学习吧~

---

✅类和对象【?上篇?】

一. 面向过程和面向对象初步认识

1. 面向过程和面向对象是两种不同的编程思想。

2. 面向过程是一种以任务为中心的编程思想，它将问题分解为一系列的任务，并通过函数的方式来解决。在面向过程编程中，函数是主要的组织单元，其目的是尽可能地利用计算机的硬件资源，强调对计算机的直接控制，而不是对问题的分析和抽象。我们熟知的C语言就是面向过程的~

3. 面向对象是以对象为中心的编程思想，它将问题分解为一系列相互作用的对象，并通过类的方式来描述。在面向对象编程中，类是主要的组织单元，其目的是将问题抽象成一组相互协作的对象，强调对问题的分析和抽象，而不是对计算机的直接控制。

4. 面向过程和面向对象都是编程的思想，它们各有优缺点，适用于不同的场景。面向过程适用于解决简单的问题，有较高的效率，但不太适合大型复杂系统的开发。而面向对象适用于解决复杂的问题，具有非常好的可扩展性和可维护性，但它的效率可能不如面向过程。

5. 在C++中，既可以面向过程编程，也可以面向对象编程，这取决于我们的编程需求和风格。

我们拿洗衣服这件事来看，面向过程和面向对象是怎样的呢？

• 面向过程：

• 面向对象：

总共有四个对象：人，衣服，洗衣粉，洗衣机。

整个洗衣服的过程：人将衣服放进洗衣机，倒入洗衣粉，启动洗衣机，洗衣机就会完成洗衣过程并且甩干。

整个过程主要是：**人，衣服，洗衣粉，洗衣机四个对象之间交互完成的，人不需要关心洗衣机具体是如何洗衣服，是如何甩干的。

面向对象思想还可以以送外卖这件事来说明【体会其中的思想】~

1. 以外卖小哥和客户为例，我们可以使用面向对象的思想来描述他们之间的关系。
2. 首先，我们可以定义一个外卖小哥类和一个客户类，用于描述他们的属性和方法。外卖小哥类中可以包含姓名、电话、所属餐厅等属性，以及送货、查询订单等方法；客户类中可以包含姓名、电话、收货地址等属性，以及下单、查询订单等方法。
3. 然后，我们可以在程序中创建多个外卖小哥和客户对象，每个对象对应一个具体的外卖小哥或客户。此外，我们还可以使用继承、接口等机制来进一步封装和抽象类的功能，使程序更加简洁和易于扩展。
4. 最后，我们可以通过对象之间的交互来模拟外卖小哥和客户之间的服务过程。例如，客户可以通过调用外卖小哥的送货方法来让外卖小哥送餐，外卖小哥可以通过调用客户的支付方法来完成订单的支付等。
5. 通过使用面向对象的思想，我们可以更好地描述和设计对象之间的交互，提高程序的可读性和可维护性，使程序更加优雅和易于扩展。

---

二. 与类的完美邂逅❤️

1. 类的引入

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数（结构体被升级成了类）。

比如：之前在数据结构初阶中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。

如下：

typedef int DataType;
struct Stack
{
 	void Init(size_t capacity)
 	{
 		_array = (DataType*)malloc(sizeof(DataType) * capacity);
 		if (nullptr == _array)
 		{
 			perror("malloc申请空间失败");
 			return;
 		}
 		_capacity = capacity;
 		_size = 0;
 	}
 	
 	void Push(const DataType& data)
 	{
 		// 扩容
 		_array[_size] = data;
 		++_size;
 	}
 	
 	DataType Top()
 	{
 		return _array[_size - 1];
 	}
 	
 	void Destroy()
 	{
 		if (_array)
 		{
 			free(_array);
 			_array = nullptr;
 			_capacity = 0;
 			_size = 0;
 		}
 	}
 	
 	DataType* _array;
 	size_t _capacity;
 	size_t _size;
};

int main()
{
 	Stack s;
 	s.Init(10);
 	s.Push(1);
 	s.Push(2);
 	s.Push(3);
 	cout << s.Top() << endl;
 	s.Destroy();
 	return 0;
}

只不过说，C++中更喜欢用class来代替struct作为类。

---

2. 类的定义

在面向对象的编程中，类是表示具有共同特征和行为的对象的模板或蓝图。类定义了一个对象的属性和方法，包括它的数据和行为。

class className
{
	// 类体：由成员函数和成员变量组成
	// 属性，方法，数据，行为
	
};  // 一定要注意后面的分号

1. class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。
2. 类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

class Person
{
public: // 这里先不用理解

	// 展示基本信息	
	void showInfo()
	{
		cout << _name << ' ' << _sex << ' ' << _age << endl;
	}

	char* _name; // 名字
	char* _sex;  // 性别
	int _age;    // 年龄
};

2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加 【类名::】。

一般情况下，更期望采用第二种方式。

成员变量命名规则的建议：

// 我们看看这个函数，是不是很僵硬？
class Date
{
public:
 	void Init(int year)
 	{
 		// 这里的year到底是成员变量，还是函数形参？
 		year = year;
 	}
private:
 	int year;
};

// 所以一般都建议这样
class Date
{
public:
 	void Init(int year)
 	{
 		_year = year;
 	}
private:
 	int _year;
};

// 或者这样
class Date
{
public:
 	void Init(int year)
 	{
 		mYear = year;
 	}
private:
 	int mYear;
};
// 其他方式也可以的，主要看公司要求。一般都是加个前缀或者后缀标识区分就行。

---

三. 增进与类的距离❤️

1. 类的访问限定符及封装

1.1. 访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选
择性的将其接口提供给外部的用户使用。

• 【访问限定符说明】：

1. public修饰的成员在类外可以直接被访问。
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)。
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。
4. 如果后面没有访问限定符，作用域就到 } 即类结束。
5. class的默认访问权限为private，struct为public(因为struct要兼容C)。

【注意】：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别。

• 【面试题】:

问题：C++中struct和class的区别是什么？

1. C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。

2. C++ 中 struct 和 class 的区别主要在于默认的访问权限不同：struct 中默认的访问权限是公共的（public），所有成员都可以被外部访问；而 class 中默认的访问权限是私有的（private），只有在类内部才可以访问。

例如：

struct Person {
    // 默认是public，可以直接访问
    string name;
    int age;
};

class Animal {
    // 默认是private，只有类内部成员才能访问
    string type;
    int weight;
};

3. 除了默认访问权限不同之外，struct 和 class 在其他方面是相同的，它们都可以定义成员变量和成员函数，并且可以使用继承、多态等特性。

4. 在使用时，通常情况下，我们可以使用 struct 来定义基本的数据结构，使用 class 来定义复杂的逻辑实体。但这只是习惯上的用法，使用哪个关键字依赖于具体的需求，而不是固定的规定。

【注意】：在继承和模板参数列表位置，struct和class也有区别，后序给大家介绍。

---

1.2. 封装【⭐重大思想⭐】

面向对象的三大特性：封装、继承、多态。

在本阶段，主要是研究类的封装特性，那什么是封装呢？

【封装】是将对象的数据和行为通过访问控制封装在一起，隐藏了对象内部的工作细节，提供了安全性和可靠性。封装有助于构建高内聚低耦合的程序，提高程序的模块化和可维护性。

【封装】是通过访问控制来实现的，即对外开放必要的接口，而将内部细节隐藏起来，对外部用户保持透明。在C++中，通过定义public、private和protected来访问控制。public表示对外开放的接口，private表示私有的接口，只有内部和友元类可以访问，protected表示受保护的接口，子类也可以访问(protected本章不做讲解)。

【例如1】：在一个电子设备中，我们可以把电源、电路板、屏幕封装成对象，对外只提供开关机、调节亮度、调节音量等少数接口，而屏幕显示、电路板的细节、电源的电压等全部隐藏起来，使用户只能通过有限的接口来使用电子设备。这样可以保证设备的安全，防止用户意外操作导致设备故障。

【例如2】对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

---

2. 类的作用域

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

例如：

class Person
{
public:
 	void PrintPersonInfo();
private:
 	char _name[20];
 	char _gender[3];
 	int  _age;
};

// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
 	cout << _name << " "<< _gender << " " << _age << endl;
}

---

3. 类的实例化

用类类型创建对象的过程，称为类的实例化~

1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。
2. 类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。
3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量。
4. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

---

四. 类对象模型

1. 如何计算类对象的大小

class A
{
public:
	void PrintA()
	{
   		cout<<_a<<endl;
	}
private:
	char _a;
};

【问题】：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？

这里请小伙伴们往下看~

---

2. 类对象的存储方式猜测

1. 对象中包含类的各个成员

【缺陷】：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。那么如何解决呢？

2. 代码只保存一份，在对象中保存存放代码的地址

3. 只保存成员变量，成员函数存放在公共的代码段

【问题】：对于上述三种存储方式，那计算机到底是按照那种方式来存储的？

我们对下面的不同对象分别获取大小来分析看下：

#include <iostream>
using namespace std;

// 类中既有成员变量，又有成员函数
class A1 {
public:
    void f1(){}
private:
    int _a;
};

// 类中仅有成员函数
class A2 {
public:
   void f2() {}
};

// 类中什么都没有---空类
class A3
{};

int main()
{
	cout << sizeof(A1) << endl << sizeof(A2) << endl << sizeof(A3) << endl;
	
	return 0;
}

【结论】：一个类的大小，实际就是该类中 ”成员变量” 之和，当然要注意内存对齐。所以类的储存方式很明显是第三种。

【注意】：空类的大小为1，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象（表示它存在）。

---

3. 结构体内存对齐规则【⭐面试问题⭐】

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

【面试题】:

1. 结构体怎么对齐？ 为什么要进行内存对齐？
2. 如何让结构体按照指定的对齐参数进行对齐？能否按照3、4、5即任意字节对齐？
3. 什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景?

大家如果有兴趣的话，可以在网上对这些问题搜索了解。

---

五. 类成员函数的this指针

1. this指针的引出

我们先来定义一个日期类 Date:

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;
 	
 	d1.Init(2022,1,11);
 	d2.Init(2022, 1, 12);
 	d1.Print();
 	d2.Print();
 	
 	return 0;
}

对于上述类，有这样的一个问题：

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

C++中通过引入this指针解决该问题，即：C++编译器给每个 “ 非静态的成员函数 “ 增加了一个隐藏的指针参数，让该指针指向当前对象 (函数运行时调用该函数的对象) ，在函数体中所有 “ 成员变量 ” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

即上面Date类里的Print函数实际上是这样：

void Print(Date* const this) // 在参数写会报错
{
	// 在里面写 this 是可以的
    cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
}

// d1 调用的时候可看作这样
d1.Print(); -》 d1.Print(&d1);

当然我们可以不用写，编译器会自动处理。

2. this指针的特性

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
2. 只能在 “成员函数” 的内部使用。
3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this指针是 “ 成员函数 ” 第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

【面试题】:

1. this指针存在哪里？

this 指针是一个指向当前对象的指针，它指向对象在内存中的地址。每个类的非静态成员函数都有一个隐含的 this 指针，指向函数被调用时所作用的对象。也就是说，当我们调用一个成员函数时，编译器会将调用该函数的对象的地址作为 this 指针传递给函数。

this 指针的实际位置取决于编译器的实现。在调用非静态成员函数时，编译器会将 this 指针传递给函数，并将 this 指针存储在栈中或寄存器中。一般情况下，this 指针的存储位置是由编译器决定的，我们无法直接访问它。因此，在代码中使用 this 可以帮助我们引用对象的成员变量和成员函数，但我们无法直接修改 this 的值。

2. this指针可以为空吗？

在 C++ 中，this 指针是一个指向当前调用对象的指针，因此它不应该（不应该，但是可以，只是不能在本函数内使用成员变量和成员函数，因为使用的话，会有this->变量…这样就会出现nullptr解引用问题）为空指针。如果你让 this 指针为空，那么你可能会访问到无效的内存地址，从而导致程序崩溃或者不可预期的结果。

但是，在某些极端情况下，this 指针可能为空。比如，当你使用一个空指针调用一个成员函数时，在函数内部就不能再使用 this 指针了，因为对象已经不存在了。此时，你需要非常小心地在函数内部处理空指针的情况。

再来看下面两道题：

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
 	void Print()
 	{
 		cout << "Print()" << endl;
 	}
private:
 	int _a;
};

int main()
{
 	A* p = nullptr;
 	p->Print();
 	return 0;
}
// 正常运行，Print 函数内没有对 this 指针进行使用。

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{ 
public:
   void PrintA() 
   {
        cout << _a << endl;
   }
private:
 	int _a;
};

int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
}
// 运行崩溃，Print 里对 this 解引用，也就对 nullptr 解引用

---

✅类和对象【?中篇?】

一. 类的6个默认成员函数【⭐重点掌握⭐】

1. 如果一个类中什么成员都没有，简称为空类。
2. 空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

【默认成员函数】：用户没有显式实现，编译器会默认生成的成员函数称为默认成员函数。

这样一个类：里面会自动生成六个默认成员函数：

class Date {};

1. 构造函数?

1.1. 概念

构造函数是一种特殊的函数，用于创建对象时初始化对象的数据成员。它的名称与类名相同，没有返回值，可以有参数，可以重载。当对象被创建时，构造函数会自动调用并初始化对象的成员变量。在 C++ 中，每个类都必须具有至少一个构造函数，如果没有显式定义，编译器会提供一个默认的构造函数。如果类中定义了有参构造函数，那么默认构造函数就不再存在。构造函数可以执行任何与对象初始化相关的工作，例如动态内存分配、文件打开等。同时，构造函数还可以进行参数检查，确保对象被正确地初始化。

对于以下Date类：

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;
 	d1.Init(2022, 7, 5);
 	d1.Print();
 	Date d2;
 	d2.Init(2022, 7, 6);
 	d2.Print();
 	return 0;
}

对于Date 类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

这个时候，构造函数出现了。构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

1.2. 特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特征如下：

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

因此，上面Date类的Init不用写，可以显示写构造函数：

class Date
{
public:
	// 1.无参构造函数
    Date()
    {}
  	
  	// 可重载
    // 2.带参构造函数
    Date(int year, int month, int day)
    {
    	_year = year;
    	_month = month;
        _day = day;
    }
private:
	int _year;
    int _month;
    int _day;
};
  
void TestDate()
{
	Date d1; // 调用无参构造函数
    Date d2(2023, 5, 10); // 调用带参的构造函数
  
    // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
    // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
    // Date d3();
 }

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
   用户显式定义编译器将不再生成。

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;
};
  
int main()
{
 	// 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
 	// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
 	// 因为d1调用的是无参构造，而类里面只有有参构造，显示有了，编译器将不会自动生成无参的
    // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
 	Date d1;
 	
 	return 0;
}

6. 关于编译器生成的默认构造函数，很多小伙伴会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？（默认构造函数是没有参数，不需要传参，或者是全缺省的构造函数）

【是这样的】：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

class Time
{
public:
	// Time 的默认构造
 	Time()
 	{
 		cout << "Time()" << endl;
 		_hour = 0;
 		_minute = 0;
 		_second = 0;
 	}
private:
 	int _hour;
 	int _minute;
 	int _second;
};

class Date
{
private:
 	// 基本类型(内置类型)
 	int _year;
 	int _month;
 	int _day;
 	// 自定义类型
 	Time _t;
};

int main()
{
 	Date d;
 	
 	return 0;
}

可以看到，编译器默认生成的构造函数对自定义类型调用它的默认构造，对内置类型不做处理，这也是C++中的一个坑，居然对内置类型不处理。

【注意】：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。

class Time
{
public:
	Time()
	{
 		cout << "Time()" << endl;
 		_hour = 0;
 		_minute = 0;
 		_second = 0;
	}
private:
 	int _hour;
 	int _minute;
 	int _second;
};

class Date
{
private:
 	// 基本类型(内置类型)
 	int _year = 2023;
 	int _month = 5;
 	int _day = 10;
 	// 自定义类型
 	Time _t;
};

int main()
{
 	Date d;
 	return 0;
}

7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。【注意】：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

---

2. 析构函数?

2.1. 概念

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

【析构函数】：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。析构函数可以确保当对象生命周期结束时，所有相关的资源都被清理和释放，从而避免资源泄露和程序崩溃等问题。

2.2. 特性

析构函数是特殊的成员函数，其特征如下：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
5. 编译器默认生成的析构函数对内置类型不处理，对自定义类型调用它的析构函数。如果我们定义一个栈类，栈的空间需要在堆上申请，如果我们不显示写，编译器默认生成的析构函数对内置类型不处理，此时就会造成内存泄漏的问题，所以，对于一个栈类，需要我们自己显示写析构函数，去完成对资源的清理；如果是一个Date类，它没有向堆申请空间，因此可以不用写析构函数，它的内置类型不处理也没什么问题。

如下：

class Time
{
public:
 	~Time()
 	{
 		cout << "~Time()" << endl;
 	}
private:
 	int _hour;
 	int _minute;
 	int _second;
};

class Date
{
private:
 	// 基本类型(内置类型)
 	int _year = 1970;
 	int _month = 1;
 	int _day = 1;
 	// 自定义类型
 	Time _t;
};

int main()
{
 	Date d;
 	return 0;
}

// 程序运行结束后输出：~Time()
// 在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？

// 因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month, _day三个是内置类
//型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在d销毁时，要将
//其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：main函数中不能直接调用Time类
//的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编
//译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要
//保证其内部每个自定义对象都可以正确销毁，main函数中并没有直接调用Time类析构函数，而是显式调用编译器
//为Date类生成的默认析构函数。

// 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数。

6. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

---

3. 拷贝构造函数?

在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。

那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？----- 当然是可以的！

3.1. 概念

【概念】：拷贝构造函数是一种特殊的构造函数，用于在创建对象时用另一个同类型对象的值来初始化它。当一个对象需要拷贝另一个对象时，通常会调用拷贝构造函数。

例如，下面的代码会触发拷贝构造函数的调用：

MyClass obj1;
MyClass obj2 = obj1;  // 定义一个新对象 obj2 并将 obj1 的值拷贝给它

拷贝构造函数的原型通常为：

MyClass(const MyClass& other);

其中，MyClass 是类名，other 是要拷贝的对象的一个引用。在拷贝构造函数中，可以将 other 中存储的值复制到新的对象中。同时，也可以在这个过程中进行一些其他的操作，如动态内存分配、文件读写等。

需要注意的是：如果不为一个类编写自定义拷贝构造函数，C++ 编译器会自动生成一个默认的拷贝构造函数。默认的拷贝构造函数会简单地将每个成员变量的值从原对象拷贝到新对象中，但并不一定适用于所有情况。在某些情况下，特别是当类中包含指针或动态内存时，需要编写自定义的拷贝构造函数以确保正确的对象创建和销毁。

3.2. 特性

拷贝构造函数也是特殊的成员函数，其特征如下：

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

例如：Date类的拷贝构造函数体为：Date(Date d);

3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。【注意】：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。
4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。但是像stack这样的类就需要显示实现。

【注意】：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

5. 拷贝构造函数典型调用场景：

• 使用已存在对象创建新对象；
• 函数参数类型为类类型对象；
• 函数返回值类型为类类型对象；

class Date
{
public:
 	Date(int year, int minute, int day)
 	{
 		cout << "Date(int,int,int):" << this << endl;
 	}
 	
 	Date(const Date& d)
 	{	
 		cout << "Date(const Date& d):" << this << endl;
 	}
 	
 	~Date()
 	{
 		cout << "~Date():" << this << endl;
 	}
private:
 	int _year;
 	int _month;
 	int _day;
};

Date Test(Date d)
{
 	Date temp(d);
 	return temp;
}

int main()
{
 	Date d1(2022,1,13);
 	Test(d1);
 	return 0;
}

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。也就是Test函数可以写为Date Test(Date& d)。

---

4. 【运算符重载】(日期类为例) ?

4.1. 运算符重载【⭐他在这⭐】

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

• 函数名字为：关键字operator后面接需要重载的运算符符号。
• 函数原型：返回值类型 operator操作符(参数列表)。

【注意】：

• 不能通过连接其他符号来创建新的操作符：比如operator@ 。
• 重载操作符必须有一个类类型参数。
• 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义。
• 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this。
• .* ，:: ， sizeof ， ?: ，. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

如以下代码：

// 全局的operator==
class Date
{ 
public:
 	Date(int year = 1900, int month = 1, int day = 1)
   	{
        _year = year;
        _month = month;
        _day = 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;
}

void Test ()
{
    Date d1(2023, 5, 9);
    Date d2(2023, 5, 10);
    cout<<(d1 == d2)<<endl;
}

///

class Date
{ 
public:
 	Date(int year = 1900, int month = 1, int day = 1)
   	{
        _year = year;
        _month = month;
        _day = day;
   	}
    
    // bool operator==(Date* this, const Date& d2)
    // 这里需要注意的是，左操作数是this，指向调用函数的对象
    bool operator==(const Date& d2)
 	{
        return _year == d2._year;
            && _month == d2._month
            && _day == d2._day;
 	}
private:
 	int _year;
 	int _month;
 	int _day;
};

4.2. 前置++ 和 后置++ 重载

• 在 C++ 中，前置递增运算符 ++ 和后置递增运算符 ++ 都可以被重载。这两个运算符的行为有所区别，需要注意。(如何区分是前置++还是后置++呢？后置++运算符重载只需要参数列表加个int即可，这样就区分开来了，--也是一样的。)

• 前置递增运算符会先将对象自身加 1，然后返回修改后的对象。例如：

MyClass& operator++()
{
    // 对自身进行修改
    ++m_value;
    return *this;
}

在使用前置递增运算符时，可以直接使用：

MyClass obj;
++obj;

这会将 obj 里的m_value的值加 1，并返回修改后的 obj 对象。

后置递增运算符会先返回未修改的对象，然后再将对象加 1。例如：

MyClass operator++(int) {
    MyClass temp(*this); // 复制自身，用于返回未修改对象的副本
    ++(*this); // 修改自身
    return temp; // 返回复制的对象
}

使用如下：

MyClass obj;
MyClass obj2 = obj++;
MyClass obj3 = obj; 

在上面的代码中，后置递增运算符返回未修改的 obj 对象的副本，然后将 obj 的值加 1。因此，在语句 MyClass obj2 = obj++; 中，obj2 将被赋值为 obj 原来的值，而不是修改后的值。

总之，重载前置递增运算符和后置递增运算符可以让用户定义的类型支持递增操作，但是需要注意前置和后置递增运算符的不同行为，以及后置递增运算符返回的未修改对象的副本。

• 对一个日期类重载前置++和后置++如下：

class Date
{
public:
 	Date(int year = 1900, int month = 1, int day = 1)
 	{
 		_year = year;
 		_month = month;
 		_day = day;
 	}
 	// 前置++：返回+1之后的结果
 	// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
 	Date& operator++()
 	{
 		_day += 1;
 		return *this;
 	}
 	// 后置++：
 	// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
 	// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
 	// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1
 	// 而temp是临时对象，因此只能以值的方式返回，不能返回引用
 	Date operator++(int)
 	{
 		Date temp(*this);
 		_day += 1;
 		return temp;
 	}
private:
 	int _year;
 	int _month;
 	int _day;
};

---

4.2. 赋值运算符重载【⭐这是默认的⭐】

1. 赋值运算符重载格式(以Date类为例):

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

如下Date类的重载：

class Date
{ 
public :
 	Date(int year = 1900, 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& 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 ;
};

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

看代码：

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

// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
 	if (&left != &right)
 	{
 		left._year = right._year;
 		left._month = right._month;
 		left._day = right._day;
 	}
 	return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

【原因】：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。【注意】：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

阅读以下代码，体会对自定义类型的处理：

class Time
{
public:
 	Time()
 	{
 		_hour = 1;
 		_minute = 1;
 		_second = 1;
 	}
 	Time& operator=(const Time& t)
 	{
 		cout << "Time& operator=(const Time& t)" << endl;
 		if (this != &t)
 		{
 			_hour = t._hour;
 			_minute = t._minute;
 			_second = t._second;
 		}
 		return *this;
 	}
private:
 	int _hour;
 	int _minute;
 	int _second;
};

class Date
{
private:
 	// 基本类型(内置类型)
 	int _year = 2023;
 	int _month = 1;
 	int _day = 1;
 	// 自定义类型
 	Time _t;
};

int main()
{
 	Date d1;
 	Date d2;
 	d1 = d2;
 	return 0;
}

既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
public:
 	Stack(size_t capacity = 10)
 	{
 		_array = (DataType*)malloc(capacity * sizeof(DataType));
 		if (nullptr == _array)
 		{
 			perror("malloc申请空间失败");
 			return;
 		}
 		_size = 0;
 		_capacity = capacity;
 	}
 
 	void Push(const DataType& data)
 	{
 		// CheckCapacity();
 		_array[_size] = data;
 		_size++;
 	}
 
 	~Stack()
 	{
 		if (_array)
 		{
 			free(_array);
 			_array = nullptr;
			 _capacity = 0;
			 _size = 0;
 		}
 	}
private:
 	DataType *_array;
 	size_t _size;
 	size_t _capacity;
};

int main()
{
 	Stack s1;
 	s1.Push(1);
 	s1.Push(2);
 	s1.Push(3);
 	s1.Push(4);
 
 	Stack s2;
 	s2 = s1;
 	
 	return 0;
}

【注意】：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

5. 取地址及const取地址操作符重载?

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

class Date
{ 
public :
 	Date* operator&()
 	{
 		return this ;
 	}
 	
 	const Date* operator&()const
 	{
 		return this ;
 	}
private :
 	int _year ; // 年
 	int _month ; // 月
 	int _day ; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

---

二. 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; // 日
};

void Test()
{
 	Date d1(2022,1,13);
 	d1.Print();
 	const Date d2(2022,1,13);
 	d2.Print();
}

int main()
{
	Test();
	return 0;
}

思考下面的几个问题：

1. const对象可以调用非const成员函数吗？不可以~！
2. 非const对象可以调用const成员函数吗？可以~！
3. const成员函数内可以调用其它的非const成员函数吗？不可以~！
4. 非const成员函数内可以调用其它的const成员函数吗？可以~！

---

三. 日期类的实现

Date.h

#include <iostream>
#include <assert.h>
using namespace std;

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

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

		assert(CheckDate());
	}

	// 拷贝构造可以不用写，默认生成的就够用
	Date(const Date& d)
	{
		_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;
	}
	// 析构函数可以不用写，某人生成的就够用
	~Date()
	{
		// 没必要
		_year = _month = _day = 0;
	}

	int GetMonDay(int year, int month)
	{
		static int day[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };

		if (month == 2 && 
			((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
		{
			return 29;
		}

		return day[month];
	}

	bool CheckDate()
	{
		if (_year >= 1 &&
			_month >= 1 &&
			_month <= 12 &&
			_day <= GetMonDay(_year, _month))
		{
			return true;
		}

		return false;
	}

	void Print();

	bool operator==(const Date& d) const;
	bool operator!=(const Date& d) const;

	bool operator>(const Date& d) const;
	bool operator>=(const Date& d) const;
	bool operator<(const Date& d) const;
	bool operator<=(const Date& d) const;

	Date operator+(int day) const;
	Date& operator+=(int day);
	Date operator-(int day) const;
	Date& operator-=(int day);
	Date& operator++(); // 前置++
	Date operator++(int); // 后置++
	Date& operator--(); // 前置++
	Date operator--(int); // 后置++

	int operator-(const Date& d) const; // 两个日期相差多少天

private:
	int _year;
	int _month;
	int _day;
};

inline ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日";
	return out;
}
inline istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;

	d.CheckDate();

	return in;
}

date.cpp

#include "Date.h"

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

bool Date::operator==(const Date& d) const
{
	return _year == d._year && _month == d._month && _day == d._day;
}

bool Date::operator!=(const Date& d) const
{
	return !(*this == d);
}

bool Date::operator>(const Date& d) const
{
	if ((_year > d._year) ||
		(_year == d._year && _month > d._month) ||
		(_year == d._year && _month == d._month && _day > d._day))
	{
		return true;
	}

	return false;
}
bool Date::operator>=(const Date& d) const
{
	return *this > d || *this == d;
}

bool Date::operator<(const Date& d) const
{
	return !(*this >= d);
}
bool Date::operator<=(const Date& d) const
{
	return !(*this > d);
}

Date Date::operator+(int day) const
{
	Date tmp(*this);
	tmp += day;

	return tmp;
}
Date& Date::operator+=(int day)
{
	if (day < 0)
	{
		return *this -= -day;
	}

	_day += day;
	while (_day > GetMonDay(_year, _month))
	{
		_day -= GetMonDay(_year, _month);
		_month++;

		if (_month == 13)
		{
			_month = 1;
			_year++;
		}
	}

	return *this;
}

Date Date::operator-(int day) const
{
	Date tmp(*this);
	tmp -= day;

	return tmp;
}
Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += -day;
	}

	_day -= day;
	while (_day <= 0)
	{
		_month--;
		if (_month == 0)
		{
			_month = 12;
			_year++;
		}
		_day += GetMonDay(_year, _month);
	}

	return *this;
}

Date& Date::operator++() // 前置++
{
	return *this += 1;
}
Date Date::operator++(int) // 后置++
{
	Date tmp(*this);
	*this += 1;

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

	return tmp;
}

int Date::operator-(const Date& d) const // 两个日期相差多少天
{
	int flag = 1;
	Date min = d;
	Date max = *this;

	if (*this < d)
	{
		min = *this;
		max = d;
		flag = -1;
	}

	int count = 0;
	while (min != max)
	{
		++min;
		++count;
	}

	return count;
}

test.cpp

#include "Date.h"

void test1()
{
	Date d1;
	d1.Print();
	Date d2 = d1;
	d2.Print();
	Date d3(2023, 4, 8);
	d2 = d3;
	d2.Print();
	d3.Print();
}

void test2()
{
	Date d1(1998, 2, 5);
	cout << d1 << endl;
	Date d2;
	cin >> d2;
	cout << d2 << endl;
	cout << (d1 < d2) << endl;
	cout << (d1 <= d2) << endl;
	cout << (d1 > d2) << endl;
	cout << (d1 >= d2) << endl;
	cout << (d1 == d2) << endl;
	cout << (d1 != d2) << endl;
}

void test3()
{
	Date d1(1998, 2, 5);
	Date d2(1900, 2, 20);

	cout << (d1 - d2) << endl;

	cout << d1 - 5 << endl;
	cout << d1 + 5 << endl;
		
	Date d3 = d1 += 15;
	cout << d1 << endl;
	cout << d3 << endl;

	d1 -= 40;

	cout << d3 - d1 << endl;

	++d3;
	--d1;
	cout << d3 - d1 << endl;
	--d3;
	++d1;
	cout << d3 - d1 << endl;
}

int main()
{
	test1();
	test2();
	test3();

	return 0;
}

---

✅类和对象【?下篇?】

一. 再谈构造函数

1. 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

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

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

---

2. 初始化列表【⭐重点知识⭐】

【初始化列表】：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。 每个类对象实例化调用构造函数都是先要走初始化列表初始化。

例如：

class Date
{
public:
	Date(int year, int month, int day)
 		: _year(year)   // 初始化列表
     	, _month(month)
     	, _day(day)
 	{}
private:
	int _year;
	int _month;
	int _day;
};

【注意】：

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

• 引用成员变量
• 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  // 因为const 修饰的变量也必须初始化
};

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

class Time
{
public:
 	Time(int hour = 0)
 		:_hour(hour)
 	{
 		cout << "Time()" << endl;
 	}
private:
	int _hour;
};

class Date
{
public:
 	Date(int day)  // 没使用初始化列表，但是会走初始化列表，_t 这个自定义类型会调用自己的默认构造
 	{}
private:
 	int _day;
 	Time _t;
};

int main()
{
    Date d(1);
}

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

如下这道题：

class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)
   {}
    
   void Print() 
   {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();
}

A. 输出1  1
B. 程序崩溃
C. 编译不通过
D. 输出1  随机值

答案是D：因为声明次序_a2在_a1前面，因此走初始化列表的时候会先走_a2的初始化，这时将_a1给_a2，_a1是随机值，那么_a2就被初始化为随机值了。

---

3. explicit关键字

构造函数不仅可以构造与初始化对象，对于 单个参数 或者 除第一个参数无默认值 其余均有默认值 的构造函数，还具有类型转换的作用。

例如：

class Date
{
public:
	// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
 	// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
 	/*explicit*/ Date(int year)
 		:_year(year)
 	{}
 	
 	/*
 	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
 	// explicit修饰构造函数，禁止类型转换
 	explicit Date(int year, 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;
};

void Test()
{
 	Date d1(2022);
 	
 	// 用一个整形变量给日期类型对象赋值
 	// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
 	d1 = 2023;
 	// 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
}

上述代码可读性不是很好，用explicit修饰构造函数，将会禁止构造函数的隐式转换。

---

二. 锦上添花❀

1. static成员【⭐要注意⭐】

【概念】：声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

【特性】：

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区；
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明；
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问；
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员；
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制。

如下代码：

#include <iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		:_a(a)
	{}

	void Print()
	{
		cout << "int _a: " << _a << "   static int _aa: " << _aa << endl;
	}

	// 静态成员函数没有 this 指针, 所以不能调用非静态成员
	static void func()
	{
		// 这是不行的
		// Print();
		// cout << _a << endl; 
		
		cout << "static void func()" << endl;
	}

private:
	int _a;
	static int _aa;
};

// 静态成员变量在类外面定义，且前面需要指定类并且不用再加 static
int A::_aa = 1;

int main()
{
	A a;
	a.Print();
	// 静态成员函数访问
	A::func();
	a.func();

	return 0;
}

【问题】:

1. 静态成员函数可以调用非静态成员函数吗？ 不行~
2. 非静态成员函数可以调用类的静态成员函数吗? 可以~

---

2. 友元

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

2.1. 友元函数

【问题】：在Date类中尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数 (详细代码可看上面日期类实现)。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但这又会导致类外没办法访问类成员，此时就需要友元来解决。operator>>同理。

【例如】下面代码在类里面定义就不符合常规调用：

class Date
{
public:
	Date(int year, int month, int day)
     	: _year(year)
     	, _month(month)
     	, _day(day)
 	{}
 	
 	// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
	// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
	ostream& operator<<(ostream& _cout)
 	{
     	_cout << _year << "-" << _month << "-" << _day << endl;
     	return _cout;
 	}
private:
	int _year;
	int _month;
	int _day;
};

这时就可以将operator<<定义在类外面并设置为Date类的友元。

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

如下：

class Date
{
	// 在类里面声明友元
 	friend ostream& operator<<(ostream& _cout, const Date& d);
 	friend istream& operator>>(istream& _cin, Date& d);
public:
 	Date(int year = 1900, int month = 1, int day = 1)
 		: _year(year)
 		, _month(month)
 		, _day(day)
 	{}
private:
 	int _year;
 	int _month;
 	int _day;
};

// 定义在全局
ostream& operator<<(ostream& _cout, const Date& d)
{
 	_cout << d._year << "-" << d._month << "-" << d._day;
 	return _cout; 
}
istream& operator>>(istream& _cin, Date& d)
{
 	_cin >> d._year;
 	_cin >> d._month;
 	_cin >> d._day;
 	return _cin;
}
int main()
{
 	Date d;
 	cin >> d;
 	cout << d << endl;
 	
 	return 0;
}

【说明】:

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

---

2.2. 友元类

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

1. 友元关系是单向的，不具有交换性。
   比如下面的Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
2. 友元关系不能传递
   如果C是B的友元， B是A的友元，则不能说明C是A的友元。
3. 友元关系不能继承，在继承位置再给大家详细介绍。

【例如】：将Date类声明为Time类的友元：

class Time
{
   friend class Date;   // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
 	Time(int hour = 0, int minute = 0, int second = 0)
 		: _hour(hour)
 		, _minute(minute)
 		, _second(second)
 	{}
   
private:
   	int _hour;
   	int _minute;
   	int _second;
};

class Date
{
public:
   	Date(int year = 1900, int month = 1, int day = 1)
       	: _year(year)
       	, _month(month)
       	, _day(day)
   	{}
   
   	void SetTimeOfDate(int hour, int minute, int second)
   	{
       	// 直接访问时间类私有的成员变量
       	_t._hour = hour;
       	_t._minute = minute;
       	_t._second = second;
   	}
   
private:
   	int _year;
   	int _month;
   	int _day;
   	Time _t;
};

---

3. 内部类

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

【注意】：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

【特性】：

1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。

class A
{
private:
 	static int k;
 	int h;
public:
 	class B // B天生就是A的友元
 	{
 	public:
 		void foo(const A& a)
 		{
 			cout << k << endl;    //OK
 			cout << a.h << endl;  //OK
 		}
 	};
};

int A::k = 1;

int main()
{
    A::B b;
    b.foo(A());
    
    return 0;
}

---

4. 匿名对象

匿名对象是指没有被命名的对象，它只能在创建时使用，无法在其他地方引用。匿名对象通常用于简化代码，避免创建不必要的变量。

匿名对象的生命周期只在当前这一行，过了这一行就调用其析构函数销毁。如果对这个匿名对象（匿名对象具有常性）const 类名&，这就相当于给这个匿名对象重新赋予了名字，那么此时这个匿名对象的声明周期将会被延长~

例如：

#include <iostream>
using namespace std;

class A
{
public:

	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

	void Print() const
	{
		cout << "void Print()" << endl;
	}

private:
	int _a;
};

void func(const A& a)
{
	cout << "void func(const A& a)" << endl;
	a.Print();
}

int main()
{
	// 1.
	A a1(1);
	a1.Print();
	// 2.
	// 构造一个匿名对象，然后直接调用 Print
	A().Print();
	
	// 他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
	A(12);
	
	// 1.
	A a2(2);
	func(a2);
	// 2.
	func(A(1)); // 直接使用匿名对象调用

	// 匿名对象具有常性，要加 const
	// 延长了这个匿名对象的生命周期
	const A& ra = A(100);

	return 0;
}

---

三. 拷贝对象时编译器的一些优化【⭐留个心眼⭐】

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还
是非常有用的。

【例如】：

class A
{
public:
 	A(int a = 0)
 		:_a(a)
 	{
 		cout << "A(int a)" << endl;
 	}
 	
 	A(const A& aa)
 		:_a(aa._a)
 	{
 		cout << "A(const A& aa)" << endl;
 	}
 	
 	A& operator=(const A& aa)
 	{
 		cout << "A& operator=(const A& aa)" << endl;
 		if (this != &aa)
 		{
 			_a = aa._a;
 		}
 		return *this;
 	}
 	
 	~A()
 	{
 		cout << "~A()" << endl;
 	}
private:
 	int _a;
};

void f1(A aa)
{}

A f2()
{
 	A aa;
 	return aa;
}

int main()
{
 	// 传值传参
 	A aa1;
 	f1(aa1);
 	cout << endl;
 	
 	// 传值返回
 	f2();
 	cout << endl;
 	
 	// 隐式类型，连续构造+拷贝构造->优化为直接构造
 	f1(1);
 	
 	// 一个表达式中，连续构造+拷贝构造->优化为一个构造
 	f1(A(2));
 	cout << endl;
 	
 	// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
 	A aa2 = f2();
 	cout << endl;
 	
 	// 一个表达式中，连续拷贝构造+赋值重载->无法优化
 	aa1 = f2();
 	cout << endl;
 	
 	return 0;
}

---

四. 再次理解封装

现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创建对象后计算机才可以认识。比如想要让计算机认识洗衣机，就需要：

1. 用户先要对现实中洗衣机实体进行抽象------即在人为思想层面对洗衣机进行认识，洗衣机有什么属性，有那些功能，即对洗衣机进行抽象认知的一个过程；
2. 经过1之后，在人的头脑中已经对洗衣机有了一个清醒的认识，只不过此时计算机还不清楚，想要让计算机识别人想象中的洗衣机，就需要人通过某种面相对象的语言(比如：C++、Java、Python等)将洗衣机用类来进行描述，并输入到计算机中；
3. 经过2之后，在计算机中就有了一个洗衣机类，但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的，通过洗衣机类，可以实例化出一个个具体的洗衣机对象，此时计算机才能洗衣机是什么东西。
4. 用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。

在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象。

---

☑️写在最后

?本篇文章分为三个大块，分别是类和对象上，类和对象中和类和对象下，其涉及的知识点颇为丰富，具体有：封装思想，this指针，六大默认成员函数，初始化列表，static成员等等。类和对象可以说是非常的重要，他体现了面向对象这一思想，并且，在以后的C++学习中会反复的用到。所以，本章的知识点值得大家反复阅读，并且大家可以将其知识做成一个思维导图来梳理一遍，这样做，不仅对知识点的印象会更加深刻，也为以后C++的学习打下了夯实的基础！

---

❤️‍?后续将会继续输出有关C++的文章，你们的支持就是我写作的最大动力！

感谢阅读本小白的博客，错误的地方请严厉指出噢~