⚡ CYBER_PROFILE ⚡
/// SYSTEM READY ///
WARNING \]: DETECTING HIGH ENERGY
**🌊 🌉 🌊 心手合一 · 水到渠成**
|------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------|
| **\>\>\> ACCESS TERMINAL \<\<\<** ||
| [**\[ 🦾 作者主页 \]**](https://blog.csdn.net/fengtinghuqu520?spm=1000.2115.3001.5343) | [**\[ 🔥 C语言核心 \]**](https://blog.csdn.net/fengtinghuqu520/category_12955956.html) |
| [**\[ 💾 编程百度 \]**](https://blog.csdn.net/fengtinghuqu520/category_13083835.html) | [**\[ 📡 代码仓库 \]**](https://blog.csdn.net/fengtinghuqu520/article/details/147275999?spm=1001.2014.3001.5502) |
---------------------------------------
Running Process: 100% \| Latency: 0ms
*** ** * ** ***
#### 索引与导读
* [一、什么是面向对象编程？](#一、什么是面向对象编程？)
*
* [OOP的三大特性](#OOP的三大特性)
* [二、类的概念与定义](#二、类的概念与定义)
*
* [2.1）什么是类？](#2.1）什么是类？)
* [2.2）类的基本结构与命名规范](#2.2）类的基本结构与命名规范)
*
* [1）关键字与标识符](#1）关键字与标识符)
* [2）分号的必要性](#2）分号的必要性)
* [3）成员变量与成员函数](#3）成员变量与成员函数)
* [2.3）struct 与 class 的演进与区别](#2.3）struct 与 class 的演进与区别)
*
* [C 语言的struct vs C++ 中的 struct：](#C 语言的struct vs C++ 中的 struct：)
* [2.4）成员函数的 Inline 特性](#2.4）成员函数的 Inline 特性)
* [二、访问限定符](#二、访问限定符)
*
* [1.1）三大访问限定符](#1.1）三大访问限定符)
* [1.2）限定符的作用域：管辖范围](#1.2）限定符的作用域：管辖范围)
* [1.3）行业通用的"黄金法则"](#1.3）行业通用的“黄金法则”)
* [三、类域](#三、类域)
*
* [:: 作用域操作符](#:: 作用域操作符)
* [四、类的实例化](#四、类的实例化)
* [五、类的对象大小](#五、类的对象大小)
*
*
* [5.1）成员变量与成员函数的大小存储](#5.1）成员变量与成员函数的大小存储)
* [5.2）编译器如何找到函数](#5.2）编译器如何找到函数)
* [六、C++类实例化对象的 内存对齐的规则](#六、C++类实例化对象的 内存对齐的规则)
*
*
* [代码示例](#代码示例)
* [七、空指针访问规则](#七、空指针访问规则)
*
* [7.1）绝对禁区：解引用](#7.1）绝对禁区：解引用)
* [7.2）调用普通成员函数](#7.2）调用普通成员函数)
* [7.3）调用虚函数](#7.3）调用虚函数)
* [7.4）静态成员](#7.4）静态成员)
* [💻结尾--- 核心连接协议](#💻结尾— 核心连接协议)
## 一、什么是面向对象编程？
**面向对象编程** 简称**OOP**，是一种程序设计思想
* 将现实世界中的事物抽象为**对象（Object）** ，并将**数据（属性）**与**处理数据的方法（行为）** 封装在一起
> 如果说**过程化编程（如 C 语言）** 是按照**第一步、第二步、第三步** 的步骤来解决问题，那么`OOP`就是通过 **指挥不同的对象协作** 来解决问题
### OOP的三大特性
1. **封装 (Encapsulation)**
封装是将数据和操作数据的方法绑定在一起，并隐藏对象的内部实现细节。
* 做法： 使用访问限定符（如 private, public）。
* 好处： 安全性。外部代码不能随便修改对象内部的敏感数据，只能通过预留的接口（方法）进行交互。
2. **继承 (Inheritance)**
继承允许一个类（子类）获取另一个类（父类）的属性和方法。
* 做法： `class Student : public Person { ... };`
* 好处： 代码复用。你不需要为每一个新类重写相同的代码。例如，"学生"和"老师"都可以继承"人"这个类的基本属性。
3. **多态 (Polymorphism)**
多态是指同一个接口，在不同的对象上表现出不同的行为。
* **做法：** 通过函数重写或虚函数实现。
* **好处：** 灵活性。你可以写一个通用的函数，比如"让动物叫"，传入一只狗它会汪汪，传入一只猫它会喵喵
*** ** * ** ***
## 二、类的概念与定义
### 2.1）什么是类？
**类（Class）** 是**面向对象编程（OOP）** 中的核心概念，它是一种用户定义的数据类型，用于**封装数据（属性）**和**操作数据的方法（函数）** ，是**创建对象的蓝图或模板**
*** ** * ** ***
### 2.2）类的基本结构与命名规范
#### 1）关键字与标识符
`class` 是 `C++` 的保留字，用于声明一个新的类型。`Stack` 是用户自定义的类名，建议采用**大驼峰命名法**
#### 2）分号的必要性
在 `C++` 中，类定义的末尾必须有一个分号` ;`
#### 3）成员变量与成员函数
* **成员变量：** 描述对象的"状态"。
* **成员函数：** 描述对象的"行为"
```cpp
//定义一个动态的栈
class Stack {
//成员函数
void Init() {}
void Push(int x) {}
//成员变量
int a;
int top;
int capacity;
};
```
* **如何去调用这个类里面的功能**
```cpp
int main() {
Stack s1;
Stack s2;
s1.Init();
s2.Push(1);
s2.Push(2);
s2.Push(3);
return 0;
}
```
*** ** * ** ***
### 2.3）struct 与 class 的演进与区别
#### C 语言的struct vs C++ 中的 struct：
* `class` 的**成员默认访问权限** 是` private（私有）`
* `struct` 的**成员默认访问权限** 是` public（公有）`
`C++`兼容C中的`struct`的用法，同时也将`struct`升级为类
*** ** * ** ***
### 2.4）成员函数的 Inline 特性
**定义在类里面的成员函数默认认为 inline**
**什么是 Inline（内联）？** 内联函数告诉编译器在调用该函数的地方直接展开代码，以减少函数调用的开销（如压栈、跳转、返回）
> 🔗[Lucy的空间骇客裂缝：inline函数](https://blog.csdn.net/fengtinghuqu520/article/details/156986078?spm=1011.2415.3001.10575&sharefrom=mp_manage_link)
**自动内联的条件：** 只要函数体直接写在类声明内部，编译器就会将其视为内联
*** ** * ** ***
## 二、访问限定符
`C++` 一种实现封装的方式，**用类将对象的属性与方法结合在一块**，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用
### 1.1）三大访问限定符
访问限定符
public
private
protected
> `C++` 有一个`后门`叫 `friend` 关键字，**可以让特定的外部函数或类突破 `private`防线** **（但要慎用，会破坏封装性）**
*** ** * ** ***
### 1.2）限定符的作用域：管辖范围
访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止，如果后面没有访问限定符，作用域就到`}`即类结束
* **代码示例**
```cpp
class Hacker {
public: // --- public 的管辖范围开始 ---
void attack() {}
void defend() {}
private: // --- public 结束，private 开始 ---
int ip_address;
int port;
public: // --- private 结束，新的 public 开始 ---
void disconnect() {}
}; // --- 作用域结束
```
**虽然 C++ 允许你在类里写无数个 `public`/`private` 块，但行业规范通常建议将同类型的权限归并在一起。通常的顺序是：先写 `public`（方便阅读接口），再写 `private`（隐藏数据）**
*** ** * ** ***
### 1.3）行业通用的"黄金法则"
一般成员变量都会被限制为 `private`/`protected`，需要给别人使用的成员函数会放为 `public`
* 如果把成员变量设为 `public`，任何人都可以在外部随意修改它：
```cpp
// 错误示范
obj.age = -100; // 外部可以直接把年龄设为负数，逻辑崩坏
```
* 如果设为 `private`，并通过 `public` 的函数来访问，你就可以把关：
```cpp
// 正确示范
void setAge(int a) {
if (a < 0 || a > 150) {
cout << "非法数据！" << endl;
return;
}
_age = a;
}
```
* 在 `C++` 中，我们通常提供 `Getxxx()` 和 `Setxxx()` 接口来**控制对私有数据的读写** **后面我们会讲**
*** ** * ** ***
## 三、类域
### :: 作用域操作符
类定义了一个新的作用域，类的所有成员都在类的作用域中。
在类体外定义成员时，需要使用`::`作用域操作符指明成员属于哪个类域
```cpp
class MyClass {
public:
void printMessage(); // 成员函数声明
private:
int data;
};
// 在类体外使用 :: 操作符定义成员函数
void MyClass::printMessage() {
std::cout << "This is defined outside the class." << std::endl;
}
```
**`::`** 明确指定了后续的成员属于哪个类，从而进入了该类的作用域，**是连接成员声明（在类内）与成员定义（在类外）的标准语法**
* **代码示例**
```cpp
class Stack {
public:
void Init(); // 成员函数声明
private:
int* _array;
int _capacity;
int _top;
};
```
**错误写法**
```cpp
void Init() {
_array = nullptr;
_top = _capacity = 0;
}
```
*编译器错误：找不到`_array`的声明*
**正确写法**
```cpp
void Stack::Init() {
_array = nullptr;
_top = _capacity = 0;
}
```
*正确：编译器知道在 `Stack` 类的作用域内查找 `_array`*
*** ** * ** ***
## 四、类的实例化
```cpp
#include