这故事发生在很久以前，那场雨淋湿小镇的屋檐......................................................................
目录
2 . 【this指针的特性】
前言
本篇介绍了C++中类和对象相关的知识，欢迎指正！
一、【面向过程与面向对象编程的区别】
C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
这里就举个例子，比如我们需要洗一件衣服：
针对洗衣服这个问题，C语言关注的就是：
而对于C++而言就不太一样，因为C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
二、【类的介绍】
2.1【类的引入】
我们知道在之前学习C语言时，学习到了一个非常重要的知识——结构体，其实结构体已经可以表示一个对象了，比如我们用它来表示人，只需要知道人的各个属性即可正常表示
但是这种表示其实还是太片面了，也就是说这样表示一个人只能让其具备人的属性，并不具备人的技能，换句话说就是结构体内只能声明变量而不能定义函数：
struct Person { int height;//身高 int weight;//体重 char name;//姓名 int age;//年龄 char sex;//性别 //........... }; int main() { struct Person person; return 0; }而在C++中，结构体内不仅可以声明变量，也可以定义函数。
比如：
之前在数据结构中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。using namespace std; struct Person { public://下面的是类中定义的函数，叫做成员函数， void introduce_self(int age, char name)//这里的age,name都是形参，并不是类中的成员变量 {//成员函数也支持缺省参数，写在public下表示其是公有的，能从外部直接访问。 cout << " my name is " << name << " and I am " << age << endl; } private://以下是类中声明的变量，叫做成员变量，写在private下面表示其是私有变量，不能从外部直接 int _height;//身高 //访问 int _weight;//体重 char _name;//姓名 int _age;//年龄 char _sex;//性别 //........... }; int main() { struct Person person; person.introduce_self(18, 'A'); return 0; }而上面相较于结构体中使用struct，在C++中更喜欢用class来定义对象和类。
2.2【类的定义】
class className { // 类体：由成员函数和成员变量组成 };class为定义类的关键字，ClassName为类的名字。”{ }“中为类的主体，注意类定义结束时后面分号不能省略。这点与结构体相同。
类体中的内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。
【类的两种定义方式】：
1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
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; }; // 其他方式也可以的，主要看具体要求。一般都是加个前缀或者后缀标识区分就行。2.3【类的访问限定符及封装】
1.【访问限定符】
C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
【访问限定符说明】
1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止， 如果后面没有访问限定符，作用域就到 “ } ” 即类结束。
4. class的默认访问权限为private，struct为public(因为struct要兼容C)
【注意】：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别
【那么C++中struct和class的区别是什么】？
C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来
定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。【注意】：在继承和模板参数列表位置，struct和class也有区别。
2.【封装】
面向对象的三大特性：封装、继承、多态。
在类和对象阶段，主要是研究类的封装特性，那什么是到底封装呢？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。封装本质上是一种管理，让用户更方便使用类。
这里举个例子：
而对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。
在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。
2.4【类的作用域】
类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 “ :: ”作用域操作符指明该成员属于哪个类域。
class Person { public: void PrintPersonInfo(); private: char _name[20]; char _gender[3]; int _age; }; // 这里需要指定PrintPersonInfo是属于Person这个类域 void Person::PrintPersonInfo() { cout << _name << " " << _gender << " " << _age << endl; } int main() { Person person; person.PrintPersonInfo(); return 0; }2.6【类的实例化】
用类类型创建对象的过程，称为类的实例化
1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。
类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。
谜语："年纪不大，胡子一把，主人来了，就喊妈妈" 谜底：山羊就比如下面的成员变量_age,我们可以试着为他赋值：
class Person { public: void PrintPersonInfo(); private: char _name[20]; char _gender[3]; int _age; }; // 这里需要指定PrintPersonInfo是属于Person这个类域 void Person::PrintPersonInfo() { cout << _name << " " << _gender << " " << _age << endl; } int main() { /*Person person; person.PrintPersonInfo();*/ Person._age = 100;// 编译失败：error C2059: 语法错误:“.” return 0; }
说明Person类是没有空间的，只有Person类实例化出的对象才有具体的空间。而其具有的各成员变量也并没有定义，类本身并未为其开辟空间，只是对其声明，明确其自身所具有的成员变量。
class A { }; class B { public: void Init(int year) { cout << "Init" << endl; } }; class C { public: void introduce_self(int age, char name) { cout << " my name is " << name << " and I am " << age << endl; } private: int _height;//身高 int _weight;//体重 char _name;//姓名 int _age;//年龄 char _sex;//性别 //........... }; int main() { cout << "空类大小为" << sizeof(A) << endl; cout << "只有成员函数的类大小为" << sizeof(B) << endl; cout << "具有成员变量和成员函数的类大小为" << sizeof(C) << endl; return 0; }
打个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设
计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象
才能实际存储数据，占用物理空间。
2.7【类对象模型的大小的计算】
class A { public: void PrintA() { cout<<_a<<endl; } private: char _a; };【问题】：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？
【类对象的存储方式猜测】：
【方式一、对象中包含类的各个成员】：
【缺陷】：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。
【方式二、代码只保存一份，在对象中保存存放代码的地址】：
【方式三、只保存成员变量，成员函数存放在公共的代码段】：
class A//空类 { }; class B//仅有成员函数 { public: void Init(int year) { cout << "Init" << endl; } }; class C//具有成员变量和成员函数 { public: void introduce_self(int age, char name) { cout << " my name is " << name << " and I am " << age << endl; } private: int _height;//身高 int _weight;//体重 char _name;//姓名 int _age;//年龄 char _sex;//性别 //........... }; int main() { cout << "空类大小为" << sizeof(A) << endl; cout << "只有成员函数的类大小为" << sizeof(B) << endl; cout << "具有成员变量和成员函数的类大小为" << sizeof(C) << endl; return 0; }【结论】：
实际上是采用方式3来进行存储的，一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐，同C语言结构体中的内存对齐注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。分配一个字节的目的是为了占位。
【结构体内存对齐规则】
1. 第一个成员在与结构体偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。【注意】：
对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
VS中默认的对齐数为8【面试题】
1. 结构体怎么对齐？ 为什么要进行内存对齐？答：参看【C语言中的自定义类型】
2. 如何让结构体按照指定的对齐参数进行对齐？能否按照3、4、5即任意字节对齐？答：能，硬件是根据默认对齐数进行访问数据的，默认对齐数可以通过#pragma pack来修改
3. 什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景答：参照【C语言数据在内存中的存储】
2.8【this指针】
1 .【this指针的引出】
这里首先定义一个日期类：
class Date { public: /*void Init(int year, int month, int day) { _year = year; _month = month; _day = day; }*/ void Init(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;// 日 }; int main() { Date d1, d2,d3; d1.Init(); d2.Init(2022, 1, 11); d3.Init(2022, 1, 12); d1.Print(); d2.Print(); d3.Print(); return 0; }【对于上述类，有这样的一个问题】：
Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？
C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
2 . 【this指针的特性】
1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
2. 只能在“成员函数”的内部使用
3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给
this形参。所以对象中不存储this指针。
4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传
递，不需要用户传递
【面试题】
1. this指针存在哪里？答：this变量是形参，形参存在函数开辟的栈帧里，会随着函数的调用结束而销毁。
2. this指针可以为空吗？答：可以为空具体要看是使用场景，下面是例子：
class A { public: void Print() { cout << "Print()" << endl; } private: int _a; }; int main() { A* p = nullptr;//这里由于成员函数存在公共代码段，所以并不会出现空指针的解引用，即使出现也不是 p->Print();//编译错误，而是程序崩溃。 return 0; }class A { public: void PrintA() { cout << _a << endl; } private: int _a; }; int main() { A* p = nullptr; p->PrintA();//这里就会程序崩溃，因为cout << _a << endl;会被编译器转换为 return 0;//cout <<this._a<<endl;,其中this为空，存在空指针的解引用。 }
三、【类中的默认成员函数】
我们都知道如果一个类中什么成员都没有，简称为空类。
那么空类中真的什么都没有吗？其实并不是，任何类都有它自己的默认成员函数，默认成员函数：用户没有显式实现（即用户没有主动进行编写），编译器会自动生成的成员函数称为默认成员函数。任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
3.1【构造函数】
主要分为普通构造函数和默认构造函数
1.【概念】对于以下Date类：
using namespace std; class Date { public: void InitDate(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.InitDate(2024, 2, 11); d1.Print(); return 0; }对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？
【这里我们就需要用到C++的构造函数】：
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
2.【特性】
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。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(2015, 1, 1); // 调用带参的构造函数 // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明 // 以下代码的函数：声明了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类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再 //生成 // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用 Date d1; d1.Print(); return 0; }
6. 关于编译器生成的默认成员函数，我们可能会有很多疑惑：、
在不显示的实现构造函数的情况下，编译器会自动生成默认的构造函数。但是默认构造函数好像看起来又没什么用？d1对象调用了编译器生成的默认构造函数，但是d1对象的成员变量_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数好像并没有什么用？？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看
下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认构造
函数。class Time { public: Time() { cout << "Time()" << endl; _hour = 0; _minute = 0; _second = 0; } private: int _hour; int _minute; int _second; }; class Date { public: void Print() { cout << _year << "-" << _month << "-" << _day << endl; } private: // 基本类型(内置类型) int _year; int _month; int _day; // 自定义类型 Time _t; }; int main() { Date d1; //d1.Print(); return 0; }
【注意】：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 = 1970;//比如这里就是提前给了初始值，值得注意的是，这里即使给了缺省值仍然是声明 int _month = 1;//不是定义，定义再初始化列表中进行。 int _day = 1; // 自定义类型 Time _t; }; int main() { Date d; return 0; }7.无参的构造函数和全缺省带参的构造函数都称为默认构造函数，并且默认构造函数只能同时存在一个。而半缺省或者带参无缺省值的只能叫构造函数，其中默认构造函数编译器在你不写的情况下会自动生成。
虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
【编译器生成的默认构造的特点】：
// 1、我们不写才会生成，我们写了任意一个构造函数就不会生成了
// 2、内置类型的成员不会处理（C++11，声明支持给缺省值）
// 3、自定义类型的成员才会处理，回去调用这个成员的默认构造函数
// 总结：一般情况都需要我们自己写构造函数，决定初始化方式
// 成员变量全是自定义类型，可以考虑不写构造函数，但是这些自变量类型最好写上。
3.【 初始化列表】
什么是初始化列表，简单来说就是在对象进行构造时对其进行初始化，主要体现在对其成员变量的定义，但是每个成员变量只能定义一次，并且定义的顺序跟类中成员变量的声明顺序相同，其作用主要体现在当类中定义const及具有常性属性的变量时，需要在定义时就要对其初始化，这时就会用到初始化列表。
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。举例：
#include <stdio.h> #include <iostream> using namespace std; class Date { public: Date(int year=1,int month=1,int day=1)//这里的成员变量只是声明，而对应的1则代表给出的缺省值 :_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.Print(); return 0; }【注意】
1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
引用成员变量
const成员变量
自定义类型成员(且该类没有默认构造函数时)3.初始化列表是每个成员定义的地方，不管你写不写，每个成员都要走初始化列表
4.C++11支持给缺省值，这个缺省值给初始化列表，如果初始化列表没有显示给值，就用这个缺省值，如果显示给值了，就不用这个缺省值
5.能用初始化列表就用初始化初始化列，有些场景还是需要初始化列表和函数体混着用
6. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
7.成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
【注意】：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。
构造函数，也是默认成员函数，我们不写，编译器会自动生成
4.【explicit关键字】
就是对象在构造的时候会出现隐式类型转换，当不想让隐式类型转换发生时，即可加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.的用法 //d1 = { 2211,1,1 };//2.的用法 // 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转 //换的作用 } int main() { Test(); return 0; }上述代码可读性不是很好，用explicit修饰构造函数，将会禁止构造函数的隐式转换。
3.2【析构函数】
1.【概念】
通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对象本身的销毁，局部对象的销毁工作是由编译器完成的。而是对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。2 .【特性】
析构函数是特殊的成员函数，其特征如下：
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。【注意】：析构函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。typedef int DataType; class Stack { public: Stack(size_t capacity = 3) { _array = (DataType*)malloc(sizeof(DataType) * capacity); if (NULL == _array) { perror("malloc申请空间失败!!!"); return; } _capacity = capacity; _size = 0; } void Push(DataType data) { // CheckCapacity(); _array[_size] = data; _size++; } // 其他方法... ~Stack() { cout << "~Stack" << endl;// if (_array) { free(_array); _array = NULL; _capacity = 0; _size = 0; } } private: DataType* _array; int _capacity; int _size; }; void TestStack() { Stack s; s.Push(1); s.Push(2); } int main() { TestStack(); return 0; }5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员会调用它自己的析构函数。
class Time { public: ~Time() { cout << "~Time()" << endl; } private: int _hour; int _minute; int _second; }; class Date { public: ~Date() { cout << "~Date()" << endl; } 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.【概念】
在科幻电影中，我们经常会看到克隆人的身影，也就是说利用你自身来克隆出另一个与你自身一样的人，我们称其为你的克隆人。那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？
那么这里的拷贝构造函数与克隆人十分类似，它的侧重点主要体现在构造上，它的作用对象有两个，一个是已经存在的对象，用来做拷贝的模板，另一个是不存在的需要构造的对象。
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
2.【特征】
拷贝构造函数也是特殊的成员函数，其特征如下：
1. 拷贝构造函数是构造函数的一个重载形式。2. 拷贝构造函数的参数只有一个且必须是同类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。至于为什么会产生无限递归，后面会讲解。
解决方式就是将传值调用改为传引用调用，这是由于如果采用传值调用，函数在调用之前会先进行传参，传参又会形成新的拷贝构造，如此往复就会形成无限递归。
这里举个例子（我们自身先提供拷贝构造）：
采用传引用调用时：#include <stdio.h> #include <iostream> using namespace std; class Date { public: Date(int year = 1900, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } // Date(const Date d) // 错误写法：编译报错，会引发无穷递归 Date(const Date& d)// 正确写法 { cout << "copy" << endl; _year = d._year; _month = d._month; _day = d._day; } private: int _year; int _month; int _day; }; void func1(Date d) { } int main() { Date d1; Date d2=d1; Date d3(d1); func1(d3); return 0; }这里就要牵扯到下一个知识：“ 赋值重载 ”。
如果我们采用传值调用：
using namespace std; class Date { public: Date(int year = 1900, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } // Date(const Date d) // 错误写法：编译报错，会引发无穷递归 Date(const Date d) { cout << "copy" << endl; _year = d._year; _month = d._month; _day = d._day; } private: int _year; int _month; int _day; }; void func1(Date d) { } int main() { Date d1; //Date d2=d1; Date d2(d1); //func1(d3); return 0; }
如上图所示，当在执行func1函数时，可以看到func1函数当中并未有具体的功能语句，但是其·却调用了拷贝构造，说明函数在传参的过程中就会调用拷贝构造，当执行date d3(d1)时; d1传参给拷贝构造的形参d，这时就会调用类A的拷贝构造函数，d1需要以值方式传进函数中作为实参，在值传递时候，传参期间会产生一个临时变量来接收d1（注意这里的接受实际上是对d1中的值进行拷贝，既然是拷贝又是自定义类型就需要调用拷贝构造），假定该临时变量叫做dd1，一旦调用拷贝构造就要再次进行传参这时的实参变为dd1那么如果仍然是值传递，那么传参的过程中又是对dd1的拷贝，又会用一个临时变量来进行拷贝dd1，假定该临时变量叫做ddd1那么拷贝的过程中又会调用拷贝构造，如此循环往复，就会形成无限递归。
那么问题就很明显了，值传递，会进行形参实例化，类类型实例化，会再调用拷贝构造函数，就会一直调用，因此结果就是无穷递归......
而当我们使用传引用调用时，这里第一次调用拷贝构造时传递的是d1的引用，是直接使用d1的空间，不涉及将d1拷贝给另一临时变量。
不会再使用临时对象来接收d1。
3. 若未显式定义拷贝构造，即我们使用的编译器会生成默认的拷贝构造函数。 那么默认的拷贝构造函数会对对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。这里就类似于C语言中的拷贝，只是将将对象的值进行拷贝，这样也会带来一些麻烦。比如在栈这个类当中，如果直接进行值拷贝，由于栈里的成员变量有一个是在堆上开辟空间，所以在程序结束系统会自动调用它的析构函数释放其开辟的空间，如果我们进行传值拷贝，比如有一个st1栈对象，现在用其来拷贝构造st2另一个栈对象，st1栈对象里用来开辟空间的指针_a1，中存放的值也会被拷贝到st2当中，使得st2中的_a2与_a1指向的是一块空间，可是当_a1使用完成调用析构函数，_a2试用结束也会调用析构函数，这样就会导致同一块空间被连续析构两次，引发错误。
下面是例子：
//这里我们会发现程序崩了，这是因为在对S2进行S1的拷贝构造时将s1中的_array的值也拷贝给了s2 typedef int DataType;//就会导致在后面进行析构函数时，_array就会析构两次， 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(s1); return 0; }
虽然传值拷贝会带来很多麻烦，但是编译器针对内置类型和自定义类型其处理方式是不相同的，在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。
这里举个例子：
class Time { public: Time() { _hour = 1; _minute = 1; _second = 1; } Time(const Time& t) { _hour = t._hour; _minute = t._minute; _second = t._second; cout << "Time::Time(const Time&)" << endl; } private: int _hour; int _minute; int _second; }; class Date { public: void Print() { cout << _year << _month << _day << endl; } private: // 基本类型(内置类型) int _year = 1970; int _month = 1; int _day = 1; // 自定义类型 Time _t; }; int main() { Date d1; // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数 // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数 Date d2(d1); d2.Print(); return 0; }
编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？
当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？//这里我们会发现程序崩了，这是因为在对S2进行S1的拷贝构造时将s1中的_array的值也拷贝给了s2 typedef int DataType;//就会导致在后面进行析构函数时，_array就会析构两次， 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(s1); return 0; }5. 拷贝构造函数典型调用场景：
使用已存在对象创建新对象
函数参数类型为同类型对象
函数返回值类型为同类型对象【注意】
我们不写，编译器默认生成的拷贝构造，跟之前的构造函数特性不一样
1.内置类型， 值拷贝
2.自定义的类型，调用它自身的的拷贝构造
总结：Date不需要我们实现拷贝构造，默认生成就可以用
Stack需要我们自己实现深拷贝的拷贝构造，默认生成会出问题
下面再看一个例子：
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; }
由上图中可以看出，
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用
尽量使用引用。其中主要看该引用变量在函数调用结束以后是否还存在，若存在，则可以使用引用，若不存在则传值返回即可。3.【浅拷贝和深拷贝】
【浅拷贝】
也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
就像一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一不想分享就你争我夺，玩具损坏。
可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。父母给每个孩子都买一份玩具，各自玩各自的就不会有问题了。
【深拷贝】
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。
3.4【赋值运算符重载】
我们知道内置类型之间可以通过常见的运算符来进行相关交互，比如利用“+，+=，—，==，=......"等，但是自定义类型并不能通过这些运算符进行相关运算，那么他们是如何实现他们之间的交互呢？这里就要运用到运算符重载。
1.【运算符重载】
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)主要是用来让自定义类型能够像内置类型一样进行计算，这里举个例子：
比如我们现在要判断两个日期之间是否相等和他们之间存在的大小关系我们第一种实现思路是在类外写一个函数将这两个日期类进行引用传参，分别访问两日期类之间的成员变量，在进行判断,会出现什么问题呢？首要的问题就是要访问成员变量就要先把成员变量的类型置为公有，或者使用“友元函数”。
// 全局的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(2018, 9, 26); Date d2(2018, 9, 27); cout<<(d1 == d2)<<endl; }但这里我们如果使用运算符重载则会很方便，我们分别将“==”，“<”,"<=",">",">="这些运算符重载为日期类能够使用的形式：
class Date { public: Date(int year = 1, int month = 1, int day =1 ) { _year = year; _month = _month; _day = _day; }//返回类型设置为bool类型 bool operator==(const Date& d)//这里加入const的目的是防止误改了传入的日期类 { return _year == d._year && _month == d._month && _day == d._day; } bool operator<(const Date& d) { if (_year < d._year) { return true; } else if(_year == d._year && _month < d._month) { return true; } else if (_year == d._year && _month == d._month && _day < d._day) { return true; } else//这里情况包括年大，年等月大，年等月等天大 { return false; } } bool operator<=(const Date& d)//这里复用<和==即可 { return *this < d || *this == d; } bool operator>(const Date& d)//由于>是<=的反面，这里复用<=即可 { return !(*this <= d); } bool operator>=(const Date& d) { return !(*this < d); } private: int _year; int _month; int _day; }; int main() { Date d1; Date d2(2, 2, 2); Date d3; Date d4(4, 4, 4); cout << (d1 < d2) << endl; cout << (d1 > d2) << endl; cout << (d1 == d3) << endl; cout << (d1 >= d3) << endl; cout << (d1 <= d3) << endl; cout << (d4 > d2) << endl; }
【注意】：
1.不能通过连接其他符号来创建新的操作符：比如operator@
2.重载操作符必须有一个类类型参数
3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐
藏的this。
5." . * " ," , " , " :: " , " sizeof " , " , " , " ? ": . 注意以上5个运算符不能重载。2.【 赋值运算符重载】
我们知道内置类型使用的赋值运算符 “ = ” ，它的本质其实是将右值的值拷贝给左值，并且左值需要是可修改的。那么针对于自定义类型应该如何赋值呢？如果像内置类型一样直接进行拷贝就要使用拷贝构造，并且也要注意传参时也要防止无限递归，我们这里还有一种新的方式是赋值运算符重载，即对 “ = ”进行重载
1. 【赋值运算符重载格式】
参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义赋值运算符只能重载成类的成员函数不能重载成全局函数,// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现
一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值
运算符重载只能是类的成员函数
class Date { public: Date(int year=1, int month=1 , int day=1 ) { _year = year; _month = month; _day = day; }//返回类型设置为bool类型 bool operator==(const Date& d)//这里加入const的目的是防止误改了传入的日期类 { return _year == d._year && _month == d._month && _day == d._day; } bool operator<(const Date& d) { if (_year < d._year) { return true; } else if(_year == d._year && _month < d._month) { return true; } else if (_year == d._year && _month == d._month && _day < d._day) { return true; } else//这里情况包括年大，年等月大，年等月等天大 { return false; } } bool operator<=(const Date& d)//这里复用<和==即可 { return *this < d || *this == d; } bool operator>(const Date& d)//由于>是<=的反面，这里复用<=即可 { return !(*this <= d); } bool operator>=(const Date& d) { return !(*this < d); } bool operator!=(const Date& d) { return (!(*this == d)); } Date& operator=(const Date& d)//这里设置为Date&的目的是*this函数调用后仍然存在，并且也能够使用d1=d2=d3这种连续赋值的操作。 { if (*this != d)//如果出现d1=d1这种自身进行赋值，直接返回即可 { _year = d._year; _month = d._month; _day = d._day; } return *this; } void Print() { cout << _year << "/" << _month << "/" << _day << endl; } private: int _year; int _month; int _day; }; int main() { Date d1; d1.Print(); Date d2(2023,7,28); d2.Print(); d2 = d1; d2.Print(); cout << (d1==d2) << endl; /*Date d2(2, 2, 2); Date d3; Date d4(4, 4, 4); cout << (d1 < d2) << endl; cout << (d1 > d2) << endl; cout << (d1 == d3) << endl; cout << (d1 >= d3) << endl; cout << (d1 <= d3) << endl; cout << (d4 > d2) << endl;*/ }
用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。
【注意】：
内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值
【注意】：
如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必
须要实现。这点与拷贝构造相同
3.【前置++和后置++的重载方式】
由于前置++和后置++符号相同但是返回值不相同，需要在他们的运算符重载的函数当中加入参数，用来区分，并构成函数重载。所以他们既是运算符重载又是函数重载，
class Date { public: // 前置++：返回+1之后的结果 // 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率 Date& operator++() { _day += 1; return *this; } // 后置++： //这里为了区别前置++和后置++，一般在后置++重载时在其参数中添加（int）以表示区分。 // 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载 // C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递 // 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1 // 而temp是临时对象，因此只能以值的方式返回，不能传引用返回 Date operator++(int) { Date temp(*this); _day += 1; return temp; } Date(int year = 1900, 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; }; int main() { Date d; Date d1(2022, 1, 13); d = d1++; // d: 2022,1,13 d1:2022,1,14//这里涉及赋值运算符及将d1拷贝给了d， d.Print();//由此也可看出，不写拷贝构造和赋值运算符重载时，会默认生成但是只能进行浅拷贝 d1.Print(); d = ++d1; // d: 2022,1,15 d1:2022,1,15 d.Print(); d1.Print(); return 0; }
4.【取地址及const取地址操作符重载】
这两个默认成员函数一般不用重新定义 ，编译器默认会生成。这里如果要自己写按照下面的方式：
class Date { public: Date* operator&() { return this; } const Date* operator&()const { return this; } private: int _year; // 年 int _month; // 月 int _day; // 日 };这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！
四、【两种特殊的成员】
4.1【const成员】
将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
这里简单来说就是，当this指针被const修饰时，我们在进行函数调用时就需要注意权限问题
这里举个例子：
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//这里在这里加上const，本质上是修饰形参中的this指针 { 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(); }
1. const对象可以调用非const成员函数吗？
答：不能会涉及权限的放大
2. 非const对象可以调用const成员函数吗？答：可以权限的缩小
3. const成员函数内可以调用其它的非const成员函数吗？答：不能
4. 非const成员函数内可以调用其它的const成员函数吗？答：可以
4.2【static成员】
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化
面试题：实现一个类，计算程序中创建出了多少个类对象。class A { public: A() { ++m; ++n; } A(const A& a) { ++m; ++n; } ~A() { m--; } static void Print() { //cout << x << endl;不能访问非静态，因为没有this cout << m << endl; cout << n << endl; } private: // 静态成员变量属于所有A对象，属于整个类 // 声明 static int m;// 累积创建了多少个对象 static int n;// 正在使用的还有多少个对象 int x = 2; };【特性】
1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制【问题】
1. 静态成员函数可以调用非静态成员函数吗？
答：不能直接调用，可通过实例化的对象进行调用
2. 非静态成员函数可以调用类的静态成员函数吗？
答：可以
五、【友元】
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。友元分为：友元函数和友元类
5.1【友元函数】
问题：现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。因为cout的
输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。这里举个例子，就比如我们使用的输入和输出（cout，cin），当使用对象为自定义类型时其对应的 “ << ” 和 “ >> ” ,这两个操作符就不再适用。需要对其进行重载但是由于this指针的存在会导致参数不匹配即_cout为第二个参数，this为第一个参数。
就会导致函数调用出现问题：// d1 << cout; ——》d1.operator<<(&d1, cout);
不符合常规调用因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
class Date { public: Date(int year, int month, int day) : _year(year) , _month(month) , _day(day) {} ostream& operator<<(ostream& _cout) { _cout << _year << "-" << _month << "-" << _day << endl; return _cout; } private: int _year; int _month; int _day; };这里只能将重载函数写到全局中，抵消this指针的影响：
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; }但是这里仍然存在问题，因为成员变量都封装在类里，在外面无法直接访问，这里就需要加入友元函数，具体如下：
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; }友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同5.2.【友元类】
【特点】
1.友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
2.友元关系是单向的，不具有交换性。
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接
访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
3.友元关系不能传递
如果C是B的友元， B是A的友元，则不能说明C时A的友元。
友元关系不能继承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; };5.3 【内部类】
【概念】：
如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
【注意】：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访
问外部类中的所有成员。但是外部类不是内部类的友元。
【特性】：
1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。class A { private: static int k; int h; public: class B // B天生就是A的友元,即B能访问A中变量，A不能访问B中变量。 { 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; }
六、【匿名对象】
匿名对象，简单来说就类似于匿名结构体，就是在定义对象时，不给对象名字，它的作用域只在它作用的那一行，但是如过使用const引用会延长匿名对象生命周期，此时它的生命周期跟接收它的值的变量相同。
class A { public: A(int a = 0) :_a(a) { cout << "A(int a)" << endl; } ~A() { cout << "~A()" << endl; } private: int _a; }; class Solution { public: int Sum_Solution(int n) { //... return n; } }; int main() { A aa1; // 不能像下面这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义 //A aa1(); // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字， // 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数 A(); A aa2(2); const A& ref = A();//该匿名对象的生命周期，等同于ref。 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. 用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。
在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象。
总结
类和对象的知识就到这里了，感谢观看！
.............................................................................那些只是旅行季节我的一厢情愿，一厢情愿
————《爱的期限》
5068
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
