目录
1、面向过程和面向对象初步认识
- C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
- C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
举个例子：
就比如我现在要写一个外卖系统，面向过程关注的就是上架商品、点外卖、通知商家、分配骑手、派送、点评等操作，而面向对象关注的就是商家、用户、骑手。
2、类的引入
最初C++被称作“C with Classes”（包含类的C语言），是C语言的继承，进一步扩充和完善了C语言。最开始大佬们是用struct来引str入类
比如在C语言中我们用结构体来定义一个学生：（C语言只能定义变量）
struct Student { char _name[20]; char _gender[3]; int _age; };用C语言的方式结构体只能定义变量，C++是兼容C语言的，在C++中，结构体内不仅可以定义变量，也可以定义函数。
struct Student { void Init(const char* name, const char* gender, int age) { strcpy(_name, name); strcpy(_gender, gender); _age = age; } void Print() { cout << _name << " " << _gender << " " << _age << endl; } char _name[20]; char _gender[3]; int _age; };C++对struct进行升级，把struct升级成了类，有如下标志：
- 结构体名称可以做类型
- 里面可以定义函数
代码演示其变化过程：
struct ListNode { int val; //C语言定义next只能这样定义 struct ListNode* next; //C++可以这样 ListNode* next; //C++可以定义函数，C只能定义成员 void Print() { //…… } }; int main() { //C语言不typedef只能这样定义 struct Student s1; //C++可以这样 Student s2; return 0; }C++里面可以访问其成员也可以访问其函数
struct Student { void Init(const char* name, const char* gender, int age) { strcpy(_name, name); strcpy(_gender, gender); _age = age; } void Print() { cout << _name << " " << _gender << " " << _age << endl; } //这里并不是必须加_ //习惯加这个，用来表示成员变量 char _name[20]; char _gender[3]; int _age; }; int main() { Student s1; s1.Init("张三", "男", 18); s1.Print(); return 0; }
- 注意：
这里的成员变量可以定义在任何位置，不会像C语言那样受到约束，因为C++这里把struct升级成了类，类是一个整体，它会在这个整体内寻找。
虽然C++把struct升级成了类，不过C++还是喜欢用class来代替struct以此来定义类。
- 此段代码中：
int main() { Student s1; return 0; }我们把Student叫做类名，先前C语言s1叫做变量，而到了C++要称之为对象。
3、类的定义
class className { // 类体：由成员函数和成员变量组成 }; // 一定要注意后面的分号
- class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号。
- 类中的元素称为类的成员：类中的数据称为类的属性或者成员变量; 类中的函数称为类的方法或者成员函数。
类的定义有两种方式，具体内容等到下文的类的作用域会讲到。
4、类的访问限定符及封装
访问限定符
要知道我类里定义的东西不是都给你随便用，我若想把里面的东西给你用就定义成公有（public:）。不想给你用的就定义成私有（private:）。想要保护起来的就定义成（protect:）。
C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
- 访问限定符说明：（**都蛮重要的**）
- public修饰的成员在类外可以直接被访问
- protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
- 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
- 如果后面没有访问限定符，作用域就到}类结束
- class的默认访问权限为private，struct为public(因为struct要兼容C)
- 注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别
接下来做具体演示：
- class默认private：
- struct默认public：
- public：
- private：
此时public的作用域一直到private访问限定符之前
- proteced：
现阶段我们认为protected公有和private私有的作用是一样的，都是在类外不能访问。这里不再赘述。
- 【面试题】
问题：C++中struct和class的区别是什么？
解答：C++需要兼容C语言，所以C++中struct可以当成结构体去使用。另外C++中struct还可以用来定义类。和class是定义类是一样的，区别是struct的成员默认访问方式是public，class是的成员默认访问方式是private。
封装
- 【面试题】 面向对象的三大特性：封装、继承、多态。
在类和对象阶段，我们只研究类的封装特性，那什么是封装呢？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
我们都清楚C语言的数据和方法是分离的，我们以栈为例：
//C语言的数据和方法是分离的 struct Stack { int* _a; int _top; int _capacity; }; void StackInit(struct Stack* ps) {} void StackPush(struct Stack* ps, int x) {} int StackTop(struct Stack* ps) {} int main() { struct Stack st; StackInit(&st); StackPush(&st, 1); StackPush(&st, 3); StackPush(&st, 5); return 0; }像C语言这样数据和方法分离会存在一个巨大的问题：太过自由！我没办法去对它很好的管理，就比如我现在想访问栈顶的数据，如若是C语言，我们就可以这样写：
printf("%d\n", StackTop(&st)); //规范 printf("%d\n", st._a[st._top]); //不规范按理来说，第一行的代码才是正确的，合理的，中肯的访问形式，第二行代码直接用结构去操纵成员，虽然也可以，但是会涉及到一个问题：我对top到底是栈顶元素还是栈顶元素的下一个位置？
（如果初始化里的top给的是0，那st.top就是栈顶元素的下一个位置，会越界，如果是-1，那么刚好就是栈顶元素）此时就会出现误用。相反直接调用StackTop函数就完全不会出现这个问题，因为我在之前就已经处理好了，返回的值必是栈顶元素。
- 由此可见，C语言在这一方面太过自由了，接下来来看看C++是如何来解决的。
这就需要用到封装了。C++设计出了类，类里除了可以定义成员变量，还可以定义函数，所以我们就可以把上述栈的初始化，插入，取栈顶全放到类里，也就实现了数据和方法封装到一起。
//1、数据和方法封装到一起，类里面 //2、想给你自由访问的设计成公有，不想给你访问的设计成私有 class Stack { public: void Init() {} void Push(int x) {} int Top(struct Stack* ps) {} private: int* _a; int _top; int _capacity; };并且此段代码还实现了我想给你访问的就设计成公有，不想给你访问的就设计成私有。此时就完美避免了C语言过渡自由懒散的弊端，此时就不能再像C语言那样直接访问成员变量了，而只能用成员函数。
int main() { Stack st; st.Init(); st.Push(1); st.Push(2); st.Push(3); st.Push(4); cout << st.Top() << endl; //cout << st._a[st._top] << endl; //err return 0; }C++通过强制的就能让用的人更规范。并且一般情况设计类，成员数据都是私有或保护，想给你访问的函数是公有，不想给你访问的是私有或保护。
综上，C++的封装本质上就是一种更严格的管理。
就好比如一件珍藏在博物馆里的艺术品，在C语言中，这些艺术品就像是没有受到任何权限限制，也没有工作人员监管，供游客观赏时间长了可能艺术品被人偷走了都不知道，而在C++中，这些艺术品就受到了保护，有工作人员的巡逻，有摄像头的抓拍，也有玻璃罩将其封装到安全范围内。
5、类的作用域
类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员，需要使用 :: 作用域解析符指明成员属于哪个类域。
如下我们定义两个类（栈和队列）
//栈 class Stack { public: void Push(int x) {} }; //队列 class Queue { void Push(int x) {} };这两个类中，我都定义了一个Push函数，此时编译器不会报错，这两个Push函数也不会构成函数重载，因为Stack类和Queue类是完全两个不同的作用域。
再比如我在Stack.h声明如下内容：
现在想在Stack.cpp文件里进行定义，就要指定作用域，否则会报错：
讲到这，我们就可以回过头来想想前面铺垫过的一个问题：类的定义方式：
- 方式1：声明和定义全部放在类体中
需要注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。因此，一般情况下，短小函数可以直接在类里面定义，长一点的声明和定义分离。
- 方式2：声明放在.h文件中，类的定义放在.cpp文件中
此方式就如同上文类的作用域一开始放出来的两张截图。
- 补充：类成员变量仅仅只是声明，不是定义！！因为没有开辟空间。
6、类的实例化
用类类型创建对象的过程，称为类的实例化
- 类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
- 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
- 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间
7、类对象模型
如何计算类对象的大小
现在给出这样一个类：
class Stack { public: //在类里面定义 //在类里定义的函数默认是内联 void Init() { _a = nullptr; _top = 0; _capacity = 0; } //在类里面声明 void Push(int x); void Pop(); private: int* _a; int _top; int _capacity; }; int main() { Stack st; st.Init(); cout << sizeof(st) << endl; //12 }这里我用类定义了一个对象st，现在想求出对象的大小，运行的结果为12，为何为12呢？，这里和C语言求结构体的大小有点相似，不过C语言的结构体不准有函数，方便计算，可是C++里的类里有函数还要成员变量，那么一个类的对象中包含了什么？如何计算一个类的大小？看下文：
类对象的存储方式猜测
- 猜测1：对象中包含类的各个成员
缺陷：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。那么如何解决呢？
- 猜测2：只保存成员变量，成员函数存放在公共的代码段
通过我们刚才得知的结果（12）来看，类对象的存储方式采用的是第二种方式。
为什么计算大小不考虑成员函数呢？我们先来探讨下如若我调用两次相同的成员函数，那么这两个函数是一样的吗？答案是就是同一份函数，我们可以查看反汇编来验证：
通过反汇编得知，调用两次相同的Init()函数call的地址都是一样的，所以就没有必要把函数在对象里面存一份，因为调用的都是同一个函数，如果我每一个函数都存一个函数指针就浪费了。
相反成员变量必须得各自存一份，因为各个成员变量的值是不一样的，我函数是一样的可以不存，但是成员变量就不能不存了，所以我们就可以把函数放到公共代码区里了。也就是说我调用函数是在这个公共代码段里调用的。综上类大小的计算不考虑成员函数。
- 清楚了类的存储方式，来做几个题：
// 类中既有成员变量，又有成员函数 class A1 { public: void f1() {} private: int _a; char _ch; }; // 类中仅有成员函数 class A2 { public: void f2() {} }; // 类中什么都没有---空类 class A3 {}; int main() { A1 a1; A2 a2; A3 a3; cout << sizeof(a1) << endl; // 8 cout << sizeof(a2) << endl; // 1 cout << sizeof(a3) << endl; // 1 return 0; }
- sizeof(a1)： 8 sizeof(a2)： 1 sizeof(a3)： 1
注意：当类里没有成员变量时，至少会给它开一个字节大小的空间，这1个字节不是为例存储有效数据，而是为了占位，表示对象存在过
结论：
- 没有成员变量的类对象，编译器会给它们分配1字节占位，表示对象存在过。
- 一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。
结构体内存对齐规则
- 第一个成员在与结构体偏移量为0的地址处。
- 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的对齐数为8
- 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
- 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
- 【面试题】
- 结构体怎么对齐？ 为什么要进行内存对齐
- 如何让结构体按照指定的对齐参数进行对齐
- 什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景
8、this指针
this指针的引出
在之后的学习中，我们会学到日期类
class Date { public: void Print() { cout << _year << "-" << _month << "-" << _day << endl; } void Init(int year, int month, int day) { _year = year; _month = month; _day = day; } private: int _year; // 年 int _month; // 月 int _day; // 日 }; int main() { Date d1, d2; d1.Init(2022, 5, 16); d2.Init(2022, 5, 17); d1.Print(); d2.Print(); return 0; }
上述定义的日期类中，我们定义了d1和d2两个对象，并且初始化后将其打印。首先一点我们都清楚，我d1和d2调用的Print是同一个函数。
- 但是现在有一个问题？它怎么知道我第一个Print调用的就是5月15号那个，而第二个Print调用的就是5月16号那个呢？调用的Print都是在公共代码段里找的，怎么就能区分出呢？
上述问题就设计到了C++的隐含this指针。this指针是一个隐含的形参。也就意味着我Print函数和Init函数其实是被编译器处理过了，并且实参也会多出传地址，如下：
class Date { public: //Print处理前 void Print() { cout << _year << "-" << _month << "-" << _day << endl; } //Print处理后 void Print(Data* const this) //注意const修饰，指针不能修改，指向的内容可以修改 { cout << this->_year << "-" << this->_month << "-" << this > _day << endl; } //Init处理前 void Init(int year, int month, int day) { _year = year; _month = month; _day = day; } //Init处理后 void Init(Date* const this, int year, int month, int day) { this->_year = year; this->_month = month; this->_day = day; } private: int _year; // 年 int _month; // 月 int _day; // 日 }; int main() { Date d1; Date d2; Date d3; d1.Init(2022, 5, 16); d2.Init(2022, 5, 17); //实参改变 d1.Init(&d1, 2022, 5, 16); d2.Init(&d2, 2022, 5, 17); d1.Print(); d2.Print(); //实参改变 d1.Print(&d1); d2.Print(&d2); return 0; }画图演示处理后实参和形参的对应关系：
谁调用就把谁的地址传过来，此时的this就是形参，整个过程就叫做隐含的this指针
为了更加方便且直观的看出调用的函数区别，我们通过打印地址来看看：
注意：实参和形参的位置不能显示的写出来，就比如this和&都不能明着在实参和形参的位置写出来，编译器会自己帮我们完成，我们无需操作 ，你不能抢了编译器的饭碗。但是我们可以在函数里面显示出this指针，当然你也可以不写，因为编译器会帮你完成。
注意：this指针本身不能修改，因为它是const修饰的，但是this指针指向的对象可以被修改，这点无需强调了。
- 总结：
C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
this指针的特性
其实this指针的特性在上一个模块（this指针的引出）已经讲解的差不多了，这里简要说明：
- this指针的类型：类类型* const
- 只能在“成员函数”的内部使用
- this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
- this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递
之前都是创建对象，如若我现在有一个对象的指针呢？
这里就能明显看出差距了，左边实际上是取对象地址作为实参传过去，而右边是直接传指针p作为实参传过去。
- 【面试题】
1、下面程序编译运行结果是？
A、编译错误 B、运行崩溃 C、正常运行
class A { public: void Show() { cout << "Show()" << endl; } private: int _a; }; int main() { A* p = nullptr; p->Show(); }
- 答案：C
- 解析：首先要明确，空指针的解引用不会报编译错误，可能有人会觉得这里p不是空指针嘛，空指针解引用不应该会出错？别急，我们把私有的成员变量放出来，再解引用对比看看：
其实第130行才是真正的解引用，而第129行不是解引用，还是那句话，对象里面只有成员变量，那我访问成员变量就是到指针指向的空间取访问_a，但是指针指向的空间是空指针，当然就会报错，而show函数不在对象里面，它在公共代码段里头，它就跟普通的函数调用一样，去找到函数的地址即可，即call地址，并且把p作为实参传到形参this指针里头，这也间接证明了this指针可以为空。所以这段程序运行正常
2、下面程序编译运行结果是？
A、编译错误 B、运行崩溃 C、正常运行
class A { public: void PrintA() { cout << _a << endl; } private: int _a; }; int main() { A* p = nullptr; p->PrintA(); }
- 答案：B
- 解析：此题就会出现运行崩溃了。首先，我调用PrintA函数，实参p传到形参this指针，此时编译器对_a进行访问，此时就是空指针的解引用，因为编译器会对改行代码处理如下：
此时的this->_a就是空指针的解引用，当然会运行崩溃。
3、this指针存在哪里？
A、栈 B、堆 C、静态区 D、常量区
- 答案：A
- 解析：this指针是把对象的地址传递过去，它是一个形参，参数的传递是在函数的栈帧，也就是说this指针存在栈里，当然有些编译器会使用寄存器优化
4、this指针可以为空吗？
- 答案：可以
