GIF：
目录
后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！ ——By 作者：新晓·故知
一、类与对象
1.面向过程与面向对象：
C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
2.声明类类型
类的引入:
C 语言中，结构体中只能定义变量，在C++ 中，结构体内不仅可以定义变量，也可以定义函数。
//在C语言中 struct ListNode { int val; struct ListNode* next; }; //C语言中最早typedef在分号前 //在C++中 //最明显的标志 struct ListNode { int val; //struct ListNode* next; //写法1因为C++兼容C， //ListNode* next; //写法2因为struct被升级 }; //C++中一般不用再typedef //c++兼容c,也有自己的语法 //c++有两种定义方法： struct Student s1; Student s2;struct Student { void SetStudentInfo(const char* name, const char* gender, int age) { strcpy(_name, name); strcpy(_gender, gender); _age = age; } void PrintStudentInfo() { cout << _name << " " << _gender << " " << _age << endl; } //这里并不是必须加_ //习惯加上用来标识成员变量 //这里成员变量放在函数后面，是因为C++兼容C，且升级后的类是一个整体 //编译器不只是向上找，而是在这个整体里面找 char _name[20]; char _gender[3]; int _age; }; int main() { Student s; s.SetStudentInfo("lilei", "男", 23); return 0; }说明：
这里并不是必须加_
习惯加上用来标识成员变量
这里成员变量放在函数后面，是因为C++兼容C，且升级后的类是一个整体
编译器不只是向上找，而是在这个整体里面找
struct默认成员公有
class默认成员私有
结构的缺陷: 可在结构体外对结构内的数据成员进行修改
C++兼容C struct的用法
C++同时对struct进行了升级，把struct升级成了类
1.结构体名称可以作为类型
2.里面可以定义
3.类的定义
class className
{
// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号1.class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号。
2.类中的元素称为类的成员：类中的数据称为类的属性或者成员变量; 类中的函数称为类的方法或者成员函数。
3.1类的两种定义方式：
1. 声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
2. 声明放在.h文件中，类的定义放在.cpp文件中
在C++中，更多使用第二种方式
3.2通过C语言与C++实现栈对比：
栈：可通过数组实现或链表实现
1.用C语言实现栈
//用C语言定义栈 struct Stack { int* _a; int _top; int _capacity; }; //C语言数据和方法分离，定义数据再定义方法去操纵数据 void StackInit(struct Stack* ps); //如果没有typedef，就必须这样写 //分离的问题： //1.太过自由，无法更好的管理 //2.有些不规范使用会直接操作内部成员，也可能会存在误用说明：
1.C语言数据和方法分离，定义数据再定义方法去操纵数据
2.分离的问题：
（1）太过自由，无法更好的管理
（2）有些不规范使用会直接操作内部成员，也可能会存在误用//C语言太过自由 struct Stack { int* _a; int _top; int _capacity; }; void StackInit(struct Stack* ps) { ps->_a = NULL; ps->_top = 0; //写法2：ps->_top=-1; 写法不同，top不同 ps->_capacity = 0; } void StackPush(struct Stack* ps, int x) {} int StackTop(struct Stack*ps) {} int main() { struct Struct st; StackInit(&st); StackPush(&st, 1); StackPush(&st, 2); StackPush(&st, 3); StackPush(&st, 4); printf("%d\n", StackTop(&st)); printf("%d\n",st._a[st._top]); //写法1：直接操作内部成员 //printf("%d\n", st._a[st._top-1]); //写法2：直接操作内部成员，存在误用情况 return 0; }2.用C++实现栈
//用C++实现栈 //1.数据和方法封装到一起，类里面 //2.允许自由访问的设计成共有，不允许自由访问的设计成私有 class Stack { public： void Init() {} void Push(int x) {} void Top() {} private: int* _a; int _top; int _capacity; };C++中通过类实现低耦合
1.数据和方法封装到一起，类里面
2.允许自由访问的设计成共有，不允许自由访问的设计成私有3.封装是更严格的管理设计
class Stack { public: void Init() {} void Push(int x) {} int Top() {} private: void Checkcapacity(); private: int* _a; int _top; int _capacity; }; int main() { Stack st; st.Init(); st.Push(1); st.Push(2); st.Push(3); st.Push(4); cout << st.Top() << endl; return 0; }c++实现栈（框架）：
Stack.h:
#pragma once //c++实现栈（框架） class Stack { public: //Init在类内定义 //在类里面定义的函数默认是inline void Init() { _a = nullptr; _top = 0; _capacity = 0; } //Push和Pop在类内声明 void Push(int x); void Pop(); //实际上，短小函数可以直接在类内定义，长一点函数声明和定义分离 private: //这里是声明，因为没有开辟空间 int* _a; int _top; int _capacity; };说明：
对于没有成员变量的类对象，编译会给他们分配1byte占位，表示对象存在过，类中仅有成员函数。
Stack.cpp:
#include"Stack.h" //c++实现栈（框架） //::域作用限定符 //Push和Pop在类外面实现 void Stack::Push(int x) { //... _top++; } void Stack::Pop() {}test.cpp:
#include<iostream> #include"Stack.h" using namespace std; //c++实现栈（框架） int main() { Stack st1; st1.Init(); cout << sizeof(st1) << endl; return 0; }
4.类的访问限定符及封装
4.1 访问限定符
C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用
说明：
> 三个关键字可以按任意次序出现任意次。
> 类声明格式中的3个部分必须至少要有一个。
> private若排第一时则可以省去。
> 不能在类声明中对数据成员进行初始化。
> 数据成员可以是任何数据类型, 但不能用auto, register, extern来进行说明。
【访问限定符说明】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
4.2 封装
【面试题】 面向对象的三大特性：封装、继承、多态。在类和对象阶段，我们只研究类的封装特性，那什么是封装呢？封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。封装本质上是一种管理：类也是一样，我们使用类数据和方法都封装到一下。不想给别人看到的，我们使用protected/private把成员封装起来。开放一些共有的成员函数对成员合理的访问。所以封装本质是一种管理。
5.类的作用域
类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员，需要使用 :: 作用域解析符指明成员属于哪个类域。class Person { public: void PrintPersonInfo(); private: char _name[20]; char _gender[3]; int _age; }; // 这里需要指定PrintPersonInfo是属于Person这个类域 void Person::PrintPersonInfo() { cout<<_name<<" "_gender<<" "<<_age<<endl; }
6.类的实例化
用类类型创建对象的过程，称为类的实例化1. 类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间
7.类对象模型
7.1 如何计算类对象的大小
class A { public: void PrintA() { cout<<_a<<endl; } private: char _a; };问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？
7.2 类对象的存储方式猜测
1.对象中包含类的各个成员
缺陷：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。那么如何解决呢？2.只保存成员变量，成员函数存放在公共的代码段
问题：对于上述两种存储方式，那计算机到底是按照那种方式来存储的？我们再通过对下面的不同对象分别获取大小来分析看下
// 类中既有成员变量，又有成员函数 class A1 { public: void f1(){} private: int _a; }; // 类中仅有成员函数 class A2 { public: void f2() {} }; // 类中什么都没有---空类 class A3 {};sizeof(A1) : __4_ sizeof(A2) : _1___sizeof(A3) : _1___4
结论：一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。
7.3 结构体内存对齐规则
1. 第一个成员在与结构体偏移量为0的地址处。2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的对齐数为83. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。【面试题】1. 结构体怎么对齐？ 为什么要进行内存对齐2. 如何让结构体按照指定的对齐参数进行对齐3. 什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景
8.this指针
8.1 this指针的引出
我们先来定义一个日期类Date
class Date { public : void Display () { cout <<_year<< "-" <<_month << "-"<< _day <<endl; } void SetDate(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.SetDate(2018,5,1); d2.SetDate(2018,7,1); d1.Display(); d2.Display(); return 0; }对于上述类，有这样的一个问题：Date类中有SetDate与Display两个成员函数，函数体中没有关于不同对象的区分，那当s1调用SetDate函数时，该函数是如何知道应该设置s1对象，而不是设置s2对象呢？C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。class Date { public: void Print() { cout << _year << "-" << _month << "-" << _day << endl; } //处理结果，引入this指针，是一个隐含的形参，谁调用就传谁的地址 //实参和形参的位置不能显式的显示出来 //const在*之前修饰的是指向内容，在*之后修饰的指针本身 //void Print(Date* this) //真正声明：void Print(Date* const this) //{ // cout << this->_year << "-" << this->_month << "-" << this->_day << endl; //} //void Print() //{ // cout << this << endl; // cout << this->_year << "-" << this->_month << "-" << this->_day << endl; //} void Init(int year, int month, int day) { _year = year; _month = month; _day = day; } //处理结果 //隐含的this指针 //void Init(Date*this int year, int month, int day) //真正声明：void Init(Date* const this int year, int month, int day) //{ // this->_year = year; // this->_month = month; // this->_day = day; //} //void Init(int year, int month, int day) //{ // const this = nullptr; //this指针本身不能被修改，因为它被const修饰，但指向的对象可以被修改 // cout << this << endl; //this指向的对象可以被修改 // this->_year = year; // _month = month; // _day = day; //} private: int _year; // 年 int _month; // 月 int _day; // 日 }; int main() { Date d1, d2; d1.Init(2022, 5, 1); d2.Init(2022, 7, 1); //this指针处理后实际形式，但显视这样调用会报错，编译器自动处理 //d1.Init(&d1,2022, 5, 1); //d2.Init(&d2,2022, 7, 1); //虽然不能显视，但可以去用this cout << "d1:" << &d1 << endl; cout << "d2:" << &d2 << endl; //d1、d2调用的是同一个函数 d1.Print(); d2.Print(); //this指针处理后实际形式，但显视这样调用会报错，编译器自动处理 //d1.Print(&d1); //d2.Print(&d2); return 0; } //d1、d2调用的是同一个函数,在调用时会将函数处理，注释部分为处理结果说明：
1.处理结果，引入this指针，是一个隐含的形参，谁调用就传谁的地址
2.实参和形参的位置不能显式的显示出来
3.const在*之前修饰的是指向内容，在*之后修饰的指针本身4.this指针本身不能被修改，因为它被const修饰，但指向的对象可以
8.2 this指针的特性
1. this指针的类型：类类型* const2. 只能在“成员函数”的内部使用3. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。4. this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递
【面试题】1. this指针存在哪里2. this指针可以为空
解：
1.一般是在栈，也有编译器会使用寄存器优化在在寄存器中。
this是把对象的地址作为实参传递，是形参。而形参在栈帧。
2.this指针可以为空
空指针是一个存在的地址，但是预留出来的，不存储数据，不能去访问。
//1.下面程序编译运行结果是？ A.编译报错 B.运行崩溃 C.正常运行 class A { public: void PrintA() { cout << _a << endl; } private: int _a; }; int main() { A* p = nullptr; p->PrintA(); //编译器内部处理： //p->PrintA(p); }//1.下面程序编译运行结果是？ A.编译报错 B.运行崩溃 C.正常运行 class A { public: void PrintA() { cout << _a << endl; //实际访问this指针解引用，但空指针，程序崩溃 //cout << this->_a << endl; } private: int _a; }; int main() { A* p = nullptr; p->PrintA(); //编译器内部处理： //p->PrintA(p); }
//2.下面程序编译运行结果是？ A.编译报错 B.运行崩溃 C.正常运行 class A { public: void Show() { cout << "Show()" << endl; } private: int _a; }; int main() { A* p = nullptr; p->Show(); }//2.下面程序编译运行结果是？ A.编译报错 B.运行崩溃 C.正常运行 class A { public: void Show() { cout << this << endl; cout << "Show()" << endl; } private: int _a; }; int main() { A* p = nullptr; //虽然p是空指针，但传过去的给this指针，this指针可以为空，const this不能被修改，但可以初始化，p传参给this的过程完成初始化，传参不会报错 p->Show(); //这里不是解引用，对象里面只有成员变量，这个函数不在对象里面，而是在一个公共代码区域，只需去找call地址，像普通函数调用一样 p->_a; //这里是解引用，访问空指针，会报错 }
“p->_a”被编译器优化，已被忽略！
