前言：丹麦计算机科学家 Bjarne Stroustrup（本贾尼·斯特劳斯特鲁普）在贝尔实验室工作时，希望为 C 语言增加面向对象能力，以支持大型软件系统的开发。最初命名为 “C with Classes”（带类的 C）。

1983 年：正式更名为 C++（“” 是 C 语言中的自增运算符，寓意“C 的进化”）。C 是一门多范式、静态类型、编译型编程语言，支持多编程范式：过程式编程（继承自 C）；面向对象编程（OOP）：封装、继承、多态；泛型编程：通过模板（Templates）实现类型无关的算法和数据结构；函数式编程：Lambda 表达式、函数对象（Functors）；元编程：模板元编程（TMP）、constexpr（编译期计算）；

计算机基础

一、基本单位

bps（bit per second）：比特每秒，最小单位。
Bps（Byte per second）：字节每秒，1 Byte = 8 bits。

以比特（bit）为单位：

单位	缩写	换算关系
比特每秒	bps	1 bps
千比特每秒	Kbps	1 Kbps = 1,000 bps
兆比特每秒	Mbps	1 Mbps = 1,000 Kbps
吉比特每秒	Gbps	1 Gbps = 1,000 Mbps
太比特每秒	Tbps	1 Tbps = 1,000 Gbps

以字节（Byte）为单位（常用于文件传输、存储等场景）：

单位	缩写	换算关系
字节每秒	B/s	1 B/s = 8 bps
千字节每秒	KB/s	1 KB/s = 1,024 B/s ≈ 8,192 bps
兆字节每秒	MB/s	1 MB/s = 1,024 KB/s
吉字节每秒	GB/s	1 GB/s = 1,024 MB/s

通用寄存器（General-Purpose Registers, GPRs）

基本寄存器（共 16 个，在 x86-64 中扩展为 64 位）

寄存器名（64位）	32位	16位	低8位	高8位（仅部分）	主要用途
`RAX`	EAX	AX	AL	AH	累加器：算术运算、函数返回值（整数/指针）
`RBX`	EBX	BX	BL	BH	基址寄存器：常用于内存寻址的基地址
`RCX`	ECX	CX	CL	CH	计数器：循环计数、移位次数、函数参数（Windows 调用约定第4个参数）
`RDX`	EDX	DX	DL	DH	数据寄存器：I/O、乘除法高位结果
`RSI`	ESI	SI	SIL	—	源变址寄存器：字符串/数组操作的源地址
`RDI`	EDI	DI	DIL	—	目的变址寄存器：字符串/数组操作的目标地址
`RBP`	EBP	BP	BPL	—	基帧指针：指向当前函数栈帧底部（用于调试/回溯）
`RSP`	ESP	SP	SPL	—	栈指针：指向栈顶（自动由 push/pop 修改）

在 x86-64 中新增了 8 个通用寄存器（无历史16/8位别名）：

R8 – R15（及其 32/16/8 位形式：R8D, R8W, R8B 等）
用于传递函数参数（System V ABI：第6个之后的参数）、临时存储等

CPU 与内存之间的数据交换是计算机体系结构中最核心的机制之一。它们通过 系统总线（System Bus） 和 内存控制器（Memory Controller） 协同工作，实现高效、有序的数据读写。

一、硬件基础：连接方式

1. 系统总线（System Bus）

早期 CPU 通过三类总线与内存通信：

地址总线（Address Bus）：CPU 输出要访问的内存地址（如 0x1000）。
数据总线（Data Bus）：双向传输实际数据（如 8/32/64 位宽）。
控制总线（Control Bus）：发送读/写信号（如 MEMR#、MEMW#）。

📌 现代 CPU 已不再使用“前端总线（FSB）”，而是集成 内存控制器（Memory Controller） 到 CPU 芯片内部（自 Intel Nehalem / AMD K8 起）。

2. 内存控制器（Integrated Memory Controller, IMC）

直接嵌入在 CPU 芯片中。
负责将 CPU 的逻辑地址请求转换为 DDR 内存的物理时序信号（行、列、Bank 地址等）。
支持多通道（如双通道 DDR4），提升带宽。

二、 “总线”一词的现代含义

术语	是否仍是“总线”？	说明
地址/数据/控制三总线	❌ 已淘汰	仅存在于教学模型或嵌入式微控制器中
FSB（前端总线）	❌ 淘汰	自 2010 年左右退出主流
PCIe	✅ 广义“总线”	实为高速串行点对点互联，支持多设备但非共享介质
DDR 内存接口	✅ 称为“内存总线”	是并行总线，但仅连接 CPU 与内存条，非系统级共享
片上互连（如 Mesh）	⚠️ 不叫总线	通常称为 NoC（Network-on-Chip）或互连矩阵

三、总结

问题	回答
现代 CPU 还用传统总线吗？	❌ 不再使用 FSB 等共享并行系统总线
如何实现数据传输？	✅ 通过集成内存控制器 + 片上互连网络 + 高速串行链路（UPI/Infinity Fabric/PCIe）
“总线”一词还适用吗？	⚠️ 仅在特定上下文（如 PCIe 总线、内存总线）作为习惯术语，实际已是专用通道

简单说：现代 CPU 内部像一个“小型网络”，而不是“一条马路”。每个关键组件都有自己的高速专线，不再挤在一条总线上。
这种架构是支撑多核、大内存、高速 I/O 的基础，也是现代高性能计算的关键。

位运算

一、基本位运算符

运算符	名称	描述	示例
`&`	与（AND）	两位都为1时结果为1	`1010 & 1100 = 1000`
`	`	或（OR）	有一位为1时结果为1
`^`	异或（XOR）	两位不同时结果为1	`1010 ^ 1100 = 0110`
`~`	取反（NOT）	0变1，1变0	`~1010 = 0101`（4位示例）
`<<`	左移	所有位左移，右侧补0	`1010 << 1 = 10100`
`>>`	右移	所有位右移，左侧补符号位（算术右移）或0（逻辑右移）	`1010 >> 1 = 0101`

位运算

一、基本位运算符

运算符	名称	描述	示例
`&`	与（AND）	两位都为1时结果为1	`1010 & 1100 = 1000`
`	`	或（OR）	有一位为1时结果为1
`^`	异或（XOR）	两位不同时结果为1	`1010 ^ 1100 = 0110`
`~`	取反（NOT）	0变1，1变0	`~1010 = 0101`（4位示例）
`<<`	左移	所有位左移，右侧补0	`1010 << 1 = 10100`
`>>`	右移	所有位右移，左侧补符号位（算术右移）或0（逻辑右移）	`1010 >> 1 = 0101`

二、XOR 的核心性质（牢记！）

性质	表达式	说明
自反性	`a ^ a = 0`	任何数与自己异或为 0
零元	`a ^ 0 = a`	与 0 异或不变
交换律	`a ^ b = b ^ a`	顺序无关
结合律	`(a ^ b) ^ c = a ^ (b ^ c)`	可任意加括号
可逆性	`a ^ b ^ b = a`	异或两次等于没变

1. 找出数组中唯一出现一次的数（其余都出现两次）

#include <vector> 
int findUnique(const std::vector<int>& nums) {     
int res = 0;     
for (int x : nums) res ^= x; // 成对的数异或后抵消，只剩唯一的     
return res; 
} // 示例: [2,3,4,2,4] → 3

2. 翻转特定位（Toggle Bit）

x ^= (1 << n); // 翻转第 n 位（0↔1）

指针部分

源代码

int main()
{
    const int b = 1;
    int *ptrb = const_cast<int *>(&b);
    *ptrb = 2;
    std::cout << *ptrb << std::endl;
    std::cout << b << std::endl;
    return 0;
}

MSVC 汇编代码

test_array.exe`main():     0x7ff6c61e6fd0 <+0>:   pushq  %rdi     0x7ff6c61e6fd2 <+2>:   subq   $0x50, %rsp     0x7ff6c61e6fd6 <+6>:   leaq   0x20(%rsp), %rdi     0x7ff6c61e6fdb <+11>:  movl   $0xc, %ecx     0x7ff6c61e6fe0 <+16>:  movl   $0xcccccccc, %eax         ; imm = 0xCCCCCCCC      0x7ff6c61e6fe5 <+21>:  rep    stosl%eax, %es:(%rdi) ->  0x7ff6c61e6fe7 <+23>:  movl   $0x1, 0x24(%rsp)     0x7ff6c61e6fef <+31>:  leaq   0x24(%rsp), %rax     0x7ff6c61e6ff4 <+36>:  movq   %rax, 0x38(%rsp)     0x7ff6c61e6ff9 <+41>:  movq   0x38(%rsp), %rax     0x7ff6c61e6ffe <+46>:  movl   $0x2, (%rax)     0x7ff6c61e7004 <+52>:  movq   0x38(%rsp), %rax     0x7ff6c61e7009 <+57>:  movl   (%rax), %edx     0x7ff6c61e700b <+59>:  movq   0x6a206(%rip), %rcx     0x7ff6c61e7012 <+66>:  callq  *0x6a2e8(%rip)     0x7ff6c61e7018 <+72>:  movq   %rax, 0x40(%rsp)     0x7ff6c61e701d <+77>:  leaq   -0x65f89(%rip), %rdx      ; std::endl<char,std::char_traits<char> >(std::basic_ostream<char,std::char_traits<char> > & __ptr64)     0x7ff6c61e7024 <+84>:  movq   0x40(%rsp), %rcx     0x7ff6c61e7029 <+89>:  callq  *0x6a199(%rip)     0x7ff6c61e702f <+95>:  movl   $0x1, %edx     0x7ff6c61e7034 <+100>: movq   0x6a1dd(%rip), %rcx     0x7ff6c61e703b <+107>: callq  *0x6a2bf(%rip)     0x7ff6c61e7041 <+113>: movq   %rax, 0x48(%rsp)     0x7ff6c61e7046 <+118>: leaq   -0x65fb2(%rip), %rdx      ; std::endl<char,std::char_traits<char> >(std::basic_ostream<char,std::char_traits<char> > & __ptr64)     0x7ff6c61e704d <+125>: movq   0x48(%rsp), %rcx     0x7ff6c61e7052 <+130>: callq  *0x6a170(%rip)     0x7ff6c61e7058 <+136>: xorl   %eax, %eax     0x7ff6c61e705a <+138>: movl   %eax, %edi     0x7ff6c61e705c <+140>: movq   %rsp, %rcx     0x7ff6c61e705f <+143>: leaq   0x88da(%rip), %rdx     0x7ff6c61e7066 <+150>: callq  0x7ff6c6182072            ; _RTC_CheckStackVars     0x7ff6c61e706b <+155>: movl   %edi, %eax     0x7ff6c61e706d <+157>: addq   $0x50, %rsp     0x7ff6c61e7071 <+161>: popq   %rdi     0x7ff6c61e7072 <+162>: retq

这段汇编代码是 MSVC（Microsoft Visual C++）在 Debug 模式下 为一个简单的 C++ main() 函数生成的 x86-64 汇编代码（Windows 调用约定）。
假设源代码大致如下（根据汇编行为反推）：

int main() {     
int arr[12];        // 12 * 4 = 48 字节             
 arr[1] = 1;        // 0x24(%rsp) 对应 arr[1]
int* p = &arr[1];     
*p = 2;     
std::cout << *p << std::endl;     
std::cout << 1 << std::endl;     
return 0; 
}

Linux 汇编

Dump of assembler code for function main():
   0x0000555555558cee <+0>:	endbr64
   0x0000555555558cf2 <+4>:	push   %rbp
   0x0000555555558cf3 <+5>:	mov    %rsp,%rbp
   0x0000555555558cf6 <+8>:	sub    $0x20,%rsp
   0x0000555555558cfa <+12>:	mov    %fs:0x28,%rax
   0x0000555555558d03 <+21>:	mov    %rax,-0x8(%rbp)
   0x0000555555558d07 <+25>:	xor    %eax,%eax
=> 0x0000555555558d09 <+27>:	movl   $0x1,-0x14(%rbp)
   0x0000555555558d10 <+34>:	lea    -0x14(%rbp),%rax
   0x0000555555558d14 <+38>:	mov    %rax,-0x10(%rbp)
   0x0000555555558d18 <+42>:	mov    -0x10(%rbp),%rax
   0x0000555555558d1c <+46>:	movl   $0x2,(%rax)
   0x0000555555558d22 <+52>:	mov    -0x10(%rbp),%rax
   0x0000555555558d26 <+56>:	mov    (%rax),%eax
   0x0000555555558d28 <+58>:	mov    %eax,%esi
   0x0000555555558d2a <+60>:	lea    0x1c30f(%rip),%rax        # 0x555555575040 <std::cout@GLIBCXX_3.4>
   0x0000555555558d31 <+67>:	mov    %rax,%rdi
   0x0000555555558d34 <+70>:	call   0x555555558800 <std::basic_ostream<char, std::char_traits<char> >::operator<<(int)@plt>
   0x0000555555558d39 <+75>:	mov    0x1c298(%rip),%rdx        # 0x555555574fd8
   0x0000555555558d40 <+82>:	mov    %rdx,%rsi
   0x0000555555558d43 <+85>:	mov    %rax,%rdi
   0x0000555555558d46 <+88>:	call   0x5555555586a0 <std::basic_ostream<char, std::char_traits<char> >::operator<<(std::basic_ostream<char, std::char_traits<char> >& (*)(std::basic_ostream<char, std::char_traits<char> >&))@plt>
   0x0000555555558d4b <+93>:	mov    $0x1,%esi
   0x0000555555558d50 <+98>:	lea    0x1c2e9(%rip),%rax        # 0x555555575040 <std::cout@GLIBCXX_3.4>
   0x0000555555558d57 <+105>:	mov    %rax,%rdi
   0x0000555555558d5a <+108>:	call   0x555555558800 <std::basic_ostream<char, std::char_traits<char> >::operator<<(int)@plt>
   0x0000555555558d5f <+113>:	mov    0x1c272(%rip),%rdx        # 0x555555574fd8
   0x0000555555558d66 <+120>:	mov    %rdx,%rsi
   0x0000555555558d69 <+123>:	mov    %rax,%rdi
   0x0000555555558d6c <+126>:	call   0x5555555586a0 <std::basic_ostream<char, std::char_traits<char> >::operator<<(std::basic_ostream<char, std::char_traits<char> >& (*)(std::basic_ostream<char, std::char_traits<char> >&))@plt>
   0x0000555555558d71 <+131>:	mov    $0x0,%eax

GCC 在 Linux 下（x86-64）为 C++ 的 main() 函数生成的典型 Debug 或未优化（-O0）代码，使用了 System V ABI 调用约定（Linux 标准）。
从行为反推，源代码大致如下：

#include <iostream> 
int main() {     
int x = 1;     
int* p = &x;     
*p = 2;     
std::cout << *p << std::endl;     
std::cout << 1 << std::endl;     
return 0; 
}

内存分配

c语言动态内存

malloc 和 calloc 都是 C 语言中用于动态分配堆内存的标准库函数（定义在 <stdlib.h> 中），但它们在初始化行为、参数形式和使用场景上有重要区别。

🔑 核心对比表

特性	`malloc`	`calloc`
全称	memory allocation	contiguous allocation（或 cleared allocation）
函数原型	`void* malloc(size_t size);`	`void* calloc(size_t num, size_t size);`
分配内存大小	`size` 字节	`num * size` 字节
是否初始化	❌ 不初始化（内容为垃圾值）	✅ 初始化为 0（按字节清零）
返回值	成功：指向内存块的指针失败：`NULL`	同左
典型用途	需要手动初始化，或后续会覆盖全部内容	需要“干净”的初始状态（如数组、结构体）

realloc 是 C 标准库（<stdlib.h>）中用于调整已分配内存块大小的函数。它既可以扩大也可以缩小一块动态分配的内存，甚至可以在原地或新位置移动数据，是管理动态内存（尤其是可变长度数组、缓冲区）的核心工具。

一、C++ 层面：`new` / `delete` 的语义

C++ 动态内存分配的底层实现是一个多层次的系统，涉及 语言特性（new/delete）、标准库（STL allocator）、运行时库（如 libstdc++/MSVCRT） 以及 操作系统接口（如 brk/sbrk 或 mmap）。下面从 C++ 标准、STL 实现（以 GCC libstdc++ 为例）、底层系统调用三个层面详细解析。

1. `new` 表达式做了两件事：

1	MyClass* p = new MyClass(42);

等价于：

// 1. 分配原始内存（调用 operator new）
void* mem = operator new(sizeof(MyClass));

// 2. 在该内存上调用构造函数（placement new）
MyClass* p = new(mem) MyClass(42);

2. `delete` 表达式也做两件事：

delete p;

等价于：

// 1. 调用析构函数
p->～MyClass();

// 2. 释放内存（调用 operator delete）
operator delete(p);

✅ 关键点：内存分配 和 对象构造 是分离的。

二、`operator new` / `operator delete` 的底层实现

默认的全局 `operator new` 实际上是对 C 库 `malloc` 的封装！

示例（简化版 libstdc++ 实现）：

// libstdc++ 中 operator new 的典型实现
void* operator new(std::size_t size) {
    if (size == 0) size = 1;
    void* p;
    while ((p = std::malloc(size)) == nullptr) {
        // 尝试调用 new_handler（C++ 特有机制）
        if (new_handler == nullptr) throw std::bad_alloc();
        new_handler();
    }
    return p;
}

void operator delete(void* ptr) noexcept {
    if (ptr) std::free(ptr);  // 调用 C 的 free
}

🔍 所以，C++ 的 new 最终依赖 C 的 malloc！

而 malloc 的底层又依赖操作系统（见下文）。

三、STL 容器（如 `std::vector`）如何分配内存？

STL 容器不直接使用 new，而是通过 allocator（分配器） 抽象层。

1. 默认分配器：`std::allocator<T>`

template<typename T>
class vector {
    std::allocator<T> alloc;  // 默认分配器
    T* data_;
    // ...
};

2. `std::allocator` 的底层行为（C++17 及以前）：

allocate(n) → 调用 ::operator new(n * sizeof(T))
deallocate(p, n) → 调用 ::operator delete(p)
不调用构造函数！构造由容器自己用 placement new 完成。

示例（`vector::push_back` 内部）：

// 分配原始内存
T* new_mem = alloc.allocate(new_capacity);

// 复制旧元素（调用拷贝构造）
for (int i = 0; i < size_; ++i)
    new(&new_mem[i]) T(old_mem[i]);  // placement new

// 销毁旧对象并释放内存
for (auto& x : old_mem) x.～T();
alloc.deallocate(old_mem, old_capacity);

✅ STL 的设计哲学：内存管理 与 对象生命周期管理 分离。

四、`malloc` 的底层：glibc 的 `ptmalloc`（Linux）

既然 C++ 最终调用 malloc，那 malloc 怎么工作？

glibc 使用 ptmalloc2（基于 dlmalloc），核心机制：

机制	说明
arena（内存池）	每个线程有私有 arena，减少锁竞争
bins（空闲链表）	按大小分类空闲块（small bins, large bins, unsorted bin）
chunk（内存块）	每块内存前后有 metadata（记录大小、是否空闲）
系统调用	- 小内存（<128KB）：用 `brk`/`sbrk` 扩展堆 - 大内存（≥128KB）：用 `mmap` 直接映射

内存分配流程（简化）：

请求大小 → 对齐到 chunk size（如 16/32/64… 字节）
查找对应 bin 中是否有合适空闲块- 有 → 切割并返回
- 无 → 向 OS 申请新内存（brk 或 mmap）
返回用户指针（实际地址 = chunk + metadata 头部）

📌 关键优化：避免频繁系统调用，通过内存池复用已释放内存。

五、Windows 下的实现（MSVC）

C++ operator new → 调用 MSVCRT 的 malloc
malloc → 基于 HeapAlloc（Windows 堆 API）
Windows 堆管理器类似 ptmalloc，也有空闲链表、内存池等机制

六、总结：C++ 动态内存分配的调用栈

C++ 用户代码
│
├─ new MyClass() 
│   └─ operator new(size)               ← C++ 运行时
│       └─ malloc(size)                 ← C 标准库 (glibc / MSVCRT)
│           ├─ 小内存 → brk/sbrk        ← Linux 系统调用
│           └─ 大内存 → mmap            ← Linux 系统调用
│
└─ std::vector<T>
    └─ std::allocator<T>::allocate()
        └─ operator new() → 同上

一、`memcpy` —— 内存复制

📌 函数原型

1	void memcpy(void dest, const void *src, size_t count);

dest：目标内存地址（必须可写）
src：源内存地址（必须可读）
count：要复制的字节数
返回值：返回 dest（便于链式调用）

⚠️ 重要限制：不能处理内存重叠！

如果 dest 和 src 区域有重叠（如 dest = src + 1），结果是未定义行为（可能数据损坏）。
✅ 正确做法：使用 memmove（它能处理重叠）。

二、`memset` —— 内存设置（填充）

📌 函数原型

1	void memset(void dest, int ch, size_t count);

dest：目标内存地址
ch：要设置的字节值（虽然是 int，但只取低 8 位）
count：要设置的字节数
返回值：返回 dest

✅ 关键特性：

按字节设置，不是按类型！
常用于将内存清零（ch = 0）

✅ 示例

#include <iostream>
#include <cstring>

int main() {
    int arr[5];
    
    // 将整个数组清零（20 字节全设为 0）
    std::memset(arr, 0, sizeof(arr));

    for (int x : arr) {
        std::cout << x << " "; // 输出: 0 0 0 0 0
    }

    // 注意：memset(…, 1, …) 不等于把 int 设为 1！
    std::memset(arr, 1, sizeof(int)); // 只设置第一个 int 的 4 字节为 0x01010101
    std::cout << "\nFirst element: " << arr[0]; // 输出: 16843009 (0x01010101)
}

❗ 常见误区：
memset(arr, 1, sizeof(arr)) 不会让每个 int 变成 1！
它会让每个字节变成 0x01，所以一个 int 变成 0x01010101 = 16843009。

智能指针

C++ 中的所有权（Ownership） 是现代 C++（C++11 起）内存安全和资源管理的核心概念。它回答了一个关键问题：

“谁负责释放这块资源（内存、文件句柄、锁等）？”

通过明确所有权，C++ 避免了内存泄漏、重复释放、悬空指针等经典问题。与垃圾回收语言不同，C++ 依靠编译时语义和RAII（Resource Acquisition Is Initialization） 实现零开销抽象。

一、什么是“所有权”？

在 C++ 中，拥有一个资源意味着：

你负责在其生命周期结束时释放它
你控制其生存期
你可以转移或共享所有权（通过特定机制）

📌 核心原则：每个资源在同一时刻有且仅有一个“所有者”（除非显式共享）

二、C++ 所有权的三种主要模型

模型	关键类型	语义	适用场景
独占所有权	`std::unique_ptr<T>`	资源只能有一个所有者，不可复制，可移动	大多数动态分配对象
共享所有权	`std::shared_ptr<T>`	多个所有者共享资源，引用计数为 0 时释放	多处需要访问同一对象
无所有权（观察者）	`T*`, `T&`, `std::weak_ptr<T>`	不负责释放，仅“借用”资源	函数参数、临时访问

三、详细解析 + 实际案例

✅ 1. 独占所有权：`std::unique_ptr`

特性：

唯一所有者：不能复制（delete 了拷贝构造/赋值）
可移动：所有权可转移（move semantics）
自动析构：离开作用域时自动调用 delete
零开销：不引入运行时成本（比裸指针还安全！）

案例：工厂函数返回独占对象

#include <memory>
#include <iostream>

class Widget {
public:
    Widget(int id) : id_(id) { std::cout << "Widget " << id_ << " created\n"; }
    ～Widget() { std::cout << "Widget " << id_ << " destroyed\n"; }
    void doWork() { std::cout << "Working...\n"; }

private:
    int id_;
};

// 工厂函数：返回独占所有权
std::unique_ptr<Widget> createWidget(int id) {
    return std::make_unique<Widget>(id); // 推荐用 make_unique
}

int main() {
    auto w = createWidget(42); // w 拥有 Widget
    w->doWork();

    // 所有权转移
    auto w2 = std::move(w); // w 变为空，w2 成为新所有者
    // w->doWork(); // ❌ 危险！w 已为空

    // 作用域结束 → w2 析构 → Widget 自动销毁
}

✅ 输出：
text编辑

1
2
3

Widget 42 created
Working...
Widget 42 destroyed

为什么比裸指针好？

// 裸指针版本（危险！）
Widget* createWidgetBad(int id) {
    return new Widget(id); // 谁 delete？容易忘记！
}

// unique_ptr 版本：所有权清晰，自动管理

✅ 2. 共享所有权：`std::shared_ptr`

特性：

引用计数：每增加一个 shared_ptr，计数 +1；减少则 -1
最后一个所有者析构时释放资源
可复制（共享所有权）
有轻微开销（计数原子操作、额外控制块）

案例：多对象共享同一资源

#include <memory>
#include <vector>
#include <iostream>

struct Data {
    Data(int v) : value(v) { std::cout << "Data(" << value << ") created\n"; }
    ～Data() { std::cout << "Data(" << value << ") destroyed\n"; }
    int value;
};

class Processor {
    std::shared_ptr<Data> data_;
public:
    Processor(std::shared_ptr<Data> d) : data_(d) {}
    void process() { std::cout << "Processing " << data_->value << "\n"; }
};

int main() {
    auto data = std::make_shared<Data>(100); // 引用计数 = 1

    std::vector<Processor> processors;
    processors.emplace_back(data); // 计数 = 2
    processors.emplace_back(data); // 计数 = 3

    for (auto& p : processors) {
        p.process();
    }

    // processors 析构 → 两个 Processor 销毁 → 计数 = 1
    // main 结束 → data 析构 → 计数 = 0 → Data 释放
}

⚠️ 注意循环引用问题（见下文）

✅ 3. 观察者（无所有权）：`std::weak_ptr` 和原始指针

问题：`shared_ptr` 的循环引用

struct Node {
    std::shared_ptr<Node> next;
    ～Node() { std::cout << "Node destroyed\n"; }
};

// 循环引用：A → B → A
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a; // 引用计数永远 ≥1 → 内存泄漏！

解决方案：`std::weak_ptr`

不增加引用计数
可从 shared_ptr 构造
使用前需 lock() 转为 shared_ptr

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev; // 弱引用，打破循环
    ～Node() { std::cout << "Node destroyed\n"; }
};

int main() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();

    a->next = b;
    b->prev = a; // weak_ptr，不增加 a 的引用计数

    // 使用 weak_ptr
    if (auto p = b->prev.lock()) {
        // p 是 shared_ptr<Node>，可安全使用
        std::cout << "Prev exists\n";
    }
    // 作用域结束 → a, b 析构 → Node 正常释放
}

原始指针作为观察者（函数参数）

void processData(const Data* data) { // 不拥有，仅观察
    if (data) {
        std::cout << "Value: " << data->value << "\n";
    }
}

int main() {
    auto d = std::make_unique<Data>(42);
    processData(d.get()); // 传递原始指针（观察者）
    // d 仍拥有资源
}

四、所有权规则总结（C++ Core Guidelines）

场景	推荐做法
函数接收对象	优先传值（移动语义）、`const T&`（只读）、`const T*`（可选观察者）
函数返回动态对象	返回 `unique_ptr`（独占）或 `shared_ptr`（共享）
成员变量持有资源	用 `unique_ptr`（默认），`shared_ptr`（需共享）
避免裸 `new`/`delete`	用 `make_unique` / `make_shared`
打破循环引用	用 `weak_ptr`

五、高级：自定义资源的所有权（RAII）

所有权不仅限于内存，还可用于文件、锁、网络连接等：

class FileHandle {
    FILE* file_;
public:
    FileHandle(const char* name) : file_(std::fopen(name, "r")) {
        if (!file_) throw std::runtime_error("Open failed");
    }
    ～FileHandle() { if (file_) std::fclose(file_); } // RAII：自动关闭

    // 禁止拷贝（独占文件句柄）
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;

    // 允许移动
    FileHandle(FileHandle&& other) noexcept : file_(other.file_) {
        other.file_ = nullptr;
    }

    FILE* get() const { return file_; }
};

// 使用
auto f = FileHandle("data.txt"); // 自动打开
// ... 使用 f.get()
// 作用域结束 → 自动 fclose

✅ 这就是 RAII + 独占所有权 的完美体现！

✅ 总结：C++ 所有权的核心思想

概念	关键点
明确性	谁拥有资源？代码一目了然
自动性	作用域结束 → 自动释放（RAII）
零开销	`unique_ptr` 比裸指针更安全，性能相同
组合性	`unique_ptr` → `shared_ptr` → `weak_ptr` 形成完整体系
泛化性	适用于内存、文件、锁、GPU 资源等一切需管理的资源

💡 现代 C++ 编程箴言：
“不要问‘我什么时候 delete？’，而要问‘谁拥有这个对象？’”

掌握所有权模型，是写出安全、高效、可维护 C++ 代码的关键一步。

Unicode 编码

UTF-8 的编码长度由 Unicode 码点决定，规则如下：

Unicode码点范围（十六进制）	UTF-8字节数	二进制格式模板
U+0000 ~ U+007F	1 字节	`0xxxxxxx`
U+0080 ~ U+07FF	2 字节	`110xxxxx 10xxxxxx`
U+0800 ~ U+FFFF	3 字节	`1110xxxx 10xxxxxx 10xxxxxx`
U+10000 ~ U+10FFFF	4 字节	`11110xxx 10xxxxxx 10xxxxxx 10xxxxxx`
所以：

2 字节的 UTF-8 字符 = Unicode 码点在 U+0080 到 U+07FF 之间的字符。
大部分常见的中文、日文、韩文字符都在 U+4E00 ~ U+9FFF（3 字节范围），因此不会是 2 字节。
英文、数字、基本标点（ASCII 字符）是 1 字节。

基于首字节的位模式判断（推荐）

/**
 * 检查UTF-8字符的字节数
 */
int getUtf8CharLen(unsigned char c)
{
    if ((c & 0x80) == 0) {
        return 1; // ASCII字符（0xxxxxxx）
    }
    else if ((c & 0xE0) == 0xC0) {
        return 2; // 2字节UTF-8字符（110xxxxx）
    }
    else if ((c & 0xF0) == 0xE0) {
        return 3; // 3字节UTF-8字符（1110xxxx）
    }
    else if ((c & 0xF8) == 0xF0) {
        return 4; // 4字节UTF-8字符（11110xxx）
    }
    return 1; // 默认情况
}

// 判断一个字节是否是 UTF-8 多字节序列的后续字节（10xxxxxx）
bool is_utf8_continuation(unsigned char c) {
    return (c & 0xC0) == 0x80;
}

字符串分割算法

设计一个通用、高效、安全的 字符串 split 算法 是 C++ 编程中的常见需求。下面提供 一种种实现方式。

namespace str {
bool is_whitespace_only(std::string_view token)
{
    return std::all_of(token.begin(), token.end(), [](unsigned char c) {
        return std::isspace(c);
    });
}
/**
 * 单字符分割
 */
std::vector<std::string> split(const std::string &text, char delimiter, bool skip_empty = true)
{
    std::vector<std::string> tokens;
    std::string token;
    for (auto c : text) {
        if (c == delimiter) {
            if (!skip_empty || !is_whitespace_only(token)) {
                tokens.push_back(token);
            }
            token.clear();
        } else {
            token += c;
        }
    }
    if (!skip_empty || !is_whitespace_only(token)) {
        tokens.push_back(token);
    }
    return tokens;
}

/**
 * 字符串分割
 * @param text
 * @param delimiter
 * @param skip_empty
 * @return
 */
std::vector<std::string> split(const std::string &text, const std::string &delimiter, bool skip_empty = true)
{
    std::vector<std::string> tokens;
    size_t start = 0;
    size_t end = text.find(delimiter);

    while (end != std::string::npos) {
        auto token = text.substr(start, end - start);
        if (!skip_empty || !is_whitespace_only(token)) {
            tokens.push_back(token);
        }
        start = end + delimiter.size();
        end = text.find(delimiter, start);
    }
    std::string token = text.substr(start);
    if (!skip_empty || !is_whitespace_only(token)) {
        tokens.push_back(token);
    }

    return tokens;
}

void test_split()
{
    std::string text{"apple, banana, cherry, , , "};
    auto result = split(text, ',');
    for (auto &item : result) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
    auto result1 = split(text, ",");
    for (auto &item : result1) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
    std::cout << result.size() << std::endl;
    std::cout << result1.size() << std::endl;
}

}

C/C++值的分类

深入理解 C++ 中的 左值（lvalue） 与 右值（rvalue） 是掌握现代 C++（尤其是移动语义、完美转发、资源管理）的核心基础。

一、最朴素的定义（C 语言时代）

左值（lvalue）：
能出现在赋值表达式左边的表达式 → 有名字、有地址、可取址。
1
2
3
int x = 10;
x = 20; // ✅ x 是左值
&x; // ✅ 可取地址

右值（rvalue）：
只能出现在赋值表达式右边的表达式 → 临时、无名、不可取址。

1 2	42 = x; // ❌ 编译错误！42 是右值 &(x + 1); // ❌ 不能对临时值取地址

✅ 记忆口诀：
L-value = Locator value（有位置）
R-value = Read-only value（只读临时值）

二、C++11 后的精细化分类（5 种值类别）

C++11 引入移动语义后，将“右值”进一步细分：
表格

类别	英文	特点	示例
左值	lvalue	有标识（identity），不可移动	`x`, `*p`, `str[0]`
将亡值	xvalue (eXpiring value)	有标识，可移动	`std::move(x)`, `static_cast<T&&>(x)`
纯右值	prvalue (pure rvalue)	无标识，可移动	`42`, `x + y`, `func()`（返回非引用）

🔑 关键概念：

有标识（has identity）：可通过地址或名字识别 → 左值 / xvalue
可移动（can be moved from）：内容可被“窃取” → xvalue / prvalue

📌 三者关系图：

     glvalue (generalized lvalue)
    /                             \
lvalue                          xvalue
                                 \
                               rvalue
                                 /
                            prvalue

glvalue = lvalue + xvalue（有标识的表达式）
rvalue = xvalue + prvalue（可移动的表达式）

三、如何判断一个表达式是左值还是右值？

✅ 判断法则（实用版）：

能对其使用 & 取地址？ → 是左值

1
2
3

int a = 10;
&a;        // ✅ OK → 左值
&(a + 1);  // ❌ error → 右值

是临时对象或字面量？ → 通常是右值

1 2	std::string("hello"); // 临时对象 → prvalue 3.14 // 字面量 → prvalue

用了 std::move 或 static_cast<T&&>？ → xvalue（右值）
1
std::move(a); // 将左值 a 转为 xvalue

四、为什么需要区分？—— 移动语义的核心

传统拷贝（低效）：

1 2	std::vector<int> createHugeVector(); std::vector<int> v = createHugeVector(); // C++98/03：深拷贝！

C++11 移动语义（高效）：

1
2
3

// 如果 createHugeVector() 返回的是右值（prvalue）
// 编译器会调用 vector 的 **移动构造函数**，而非拷贝构造函数
std::vector<int> v = createHugeVector(); // ✅ 内部指针“转移”，O(1)

💡 关键：只有右值才能安全地被“移动”（因为没人再用它了）。

五、左值引用 vs 右值引用

引用类型	声明	能绑定到	用途
左值引用	`T&`	左值	修改已有对象
const 左值引用	`const T&`	左值 + 右值	延长临时对象生命周期
右值引用	`T&&`	仅右值	实现移动语义

示例：

int x = 10;

int&  r1 = x;        // ✅ OK
int&  r2 = 42;       // ❌ error
const int& r3 = 42;  // ✅ OK（临时对象生命周期延长）
int&& r4 = 42;       // ✅ OK（绑定到右值）
int&& r5 = x;        // ❌ error（x 是左值）

// 但可通过 std::move 强制转换：
int&& r6 = std::move(x); // ✅ x 被“标记为可移动”

⚠️ 注意：T&& 在模板中可能是“万能引用”（见下文）

六、万能引用（Universal Reference）与引用折叠

在模板中，T&& 不一定是右值引用！

template<typename T>
void foo(T&& arg); // 这里的 T&& 是“万能引用”

foo(42);     // T = int, arg 是 int&&（右值引用）
int x = 10;
foo(x);      // T = int&, arg 是 int&（左值引用！）

引用折叠规则（C++11）：

原始类型	`T&&`	`T&&&`	`T&&&`	`T&&&&`
折叠后	`T&`	`T&`	`T&`	`T&&`

✅ 结论：

传左值 → T 推导为 Type& → T&& 折叠为 Type&
传右值 → T 推导为 Type → T&& 保持为 Type&&

这正是 std::forward 实现完美转发的基础。

七、常见表达式的值类别速查表

表达式	值类别
变量名（`x`）	lvalue
函数返回左值引用（`T& func()`）	lvalue
解引用（`*p`）	lvalue
下标（`arr[i]`）	lvalue
成员访问（`obj.member`）	lvalue
字面量（`42`, `"hello"`）	prvalue
函数返回非引用（`T func()`）	prvalue
`x + y`, `x > y`	prvalue
`std::move(x)`	xvalue
`static_cast<T&&>(x)`	xvalue
`std::forward<T>(x)`	若 T 是左值引用 → lvalue；否则 → xvalue

八、实践：如何正确使用？

1. 重载函数区分左/右值

class Buffer {
    std::vector<char> data;
public:
    // 拷贝版本（左值）
    void append(const std::string& s) {
        data.insert(data.end(), s.begin(), s.end());
    }
    
    // 移动版本（右值）
    void append(std::string&& s) {
        data.insert(data.end(), s.begin(), s.end()); // 或直接 swap
    }
};

Buffer b;
std::string msg = "Hello";
b.append(msg);           // 调用 const& 版本（拷贝）
b.append("World");       // 调用 && 版本（移动临时对象）

2. 转发时用 `std::forward`

template<typename T>
void wrapper(T&& arg) {
    foo(std::forward<T>(arg)); // 保持原始值类别
}

九、常见误区

❌ 误区 1：“右值就是临时变量”

不完全对：std::move(x) 产生的 xvalue 不是临时变量，但仍是右值。

❌ 误区 2：“右值引用变量本身是右值”

void foo(std::string&& s) {
    bar(s); // ❌ s 是左值！（有名字）
    bar(std::move(s)); // ✅ 正确：显式转为右值
}

📌 命名的右值引用是左值！

❌ 误区 3：“所有右值都能移动”

移动的前提是类型定义了移动构造/赋值函数，否则退化为拷贝。

十、总结：一张表掌握核心

概念	左值（lvalue）	将亡值（xvalue）	纯右值（prvalue）
是否有名字/地址	✅	✅	❌
是否可移动	❌	✅	✅
典型来源	变量、解引用	`std::move`、强制转换	字面量、函数返回值
绑定到 `T&&`	❌	✅	✅
生命周期	用户管理	即将结束	临时

✅ 终极心法：
左值 = 有身份的对象（不能随便动）
右值 = 无主临时物（可以“偷”它的资源）

掌握这一点，你就真正理解了 C++ 移动语义的哲学。

`static 和 inline 辨析`

在 C++ 中，static 和 inline 是两个非常重要的关键字，它们分别用于控制变量/函数的存储期、链接性（static）以及函数调用的优化方式（inline）。下面分别详细讲解它们的含义、用法和注意事项。

一、`static` 关键字

static 在 C++ 中有多种用途，具体行为取决于它修饰的对象类型（变量、函数、类成员等）以及作用域（全局、局部、类内）。

修饰局部变量（函数内部）

void func() {
    static int count = 0;  // 只初始化一次
    count++;
    std::cout << count << std::endl;
}

生命周期：整个程序运行期间都存在（静态存储期）。
初始化：只在第一次进入函数时初始化一次。
作用域：仍局限于函数内部（不能在函数外访问）。
默认初始化为 0（如果未显式初始化）。

✅ 用途：实现“函数内的持久状态”。

修饰全局变量或函数（文件作用域）

1
2
3

// file1.cpp
static int globalVar = 42;
static void helperFunc() { /* ... */ }

内部链接（internal linkage）：该变量/函数仅在当前编译单元（.cpp 文件）中可见，其他文件无法访问。
避免命名冲突，实现“文件私有”的全局变量或辅助函数。

⚠️ 注意：在 C++ 中，更推荐使用 匿名命名空间 替代 static 实现内部链接：

namespace {
    int globalVar = 42;
    void helperFunc() { /* ... */ }
}

修饰类的成员（静态成员）

静态成员变量：

class MyClass {
public:
    static int count;  // 声明
};

int MyClass::count = 0;  // 定义（C++17 前必须在类外定义）
// C++17 起可用 inline static int count = 0; 直接在类内定义

属于类本身，而非某个对象实例。
所有对象共享同一个 count。
可通过 MyClass::count 访问，无需创建对象。

静态成员函数：

class MyClass {
public:
    static void printCount() {
        std::cout << count << std::endl;  // 只能访问静态成员
    }
};

没有 this 指针。
不能访问非静态成员（因为没有对象上下文）。
可通过类名直接调用：MyClass::printCount()。

二、`inline` 关键字

inline 最初是为了建议编译器将函数体直接插入调用处，以避免函数调用开销（如压栈、跳转等）。但现代编译器通常会自行决定是否内联，inline 更多用于解决链接问题。

内联函数的基本用法

1
2
3

inline int add(int a, int b) {
    return a + b;
}

建议（非强制）编译器内联展开。
通常用于短小、频繁调用的函数。
函数定义放在头文件中是安全的（见下文）。

📌 注意：递归函数、虚函数、含复杂控制流的函数通常不会被内联。

inline 的关键作用：允许多次定义（ODR 合规）

C++ 遵循 One Definition Rule (ODR)：一个函数在程序中只能有一个定义。但如果函数被声明为 inline，则允许在多个编译单元中出现相同的定义（只要内容完全一致）。
因此，内联函数通常定义在头文件中：

// math_utils.h
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

inline int square(int x) {
    return x * x;
}

#endif

多个 .cpp 文件包含此头文件不会导致“重复定义”链接错误。

C++17 起：inline 变量

C++17 引入了 inline 变量，解决了头文件中定义全局变量或静态成员变量的重复定义问题。

// constants.h
inline constexpr double PI = 3.1415926535;

// 或类内静态成员
class MyClass {
public:
    inline static int count = 0;  // C++17 起合法，无需类外定义
};

inline 变量也遵循 ODR：可在多个编译单元定义，但必须相同。
常用于头文件中的常量、单例对象等。

三、`static` 与 `inline` 的对比总结

特性	`static`	`inline`
主要目的	控制链接性和存储期	允许安全地在头文件中定义函数/变量，并建议内联优化
作用于局部变量	延长生命周期至程序结束	❌ 不适用
作用于全局函数/变量	限制为内部链接（仅本文件可见）	允许多次定义（跨文件），外部链接
作用于类成员	表示属于类而非对象	C++17 起可用于静态成员变量（`inline static`）
是否影响 ODR	`static` 全局变量每个文件一份副本	`inline` 确保所有文件共享同一实体

四、常见误区

inline 不等于“一定会内联”
编译器有权忽略 inline 建议。性能关键代码应通过性能分析工具验证。
static 全局变量 ≠ 单例
每个编译单元有自己的副本，若在头文件中定义 static 全局变量，会导致多个副本！
不要滥用 inline
过度内联会增大代码体积，可能降低缓存效率，反而降低性能。

五、最佳实践建议

小函数（如 getter/setter）可标记为 inline 并放在头文件。
需要在头文件中定义的常量，使用 inline constexpr（C++17+）。
类的静态成员变量在 C++17+ 优先使用 inline static。
文件私有函数/变量优先使用匿名命名空间，而非 static。

`union` 详解

C++ 中的 union（联合体）是一种特殊的用户自定义类型，允许多个不同类型的成员共享同一块内存区域。它是 C 语言继承而来的重要特性，在 C++ 中被进一步扩展（如支持成员函数、构造/析构等），但使用时需格外谨慎。

🧱 一、基本语法与内存布局

union MyUnion {
    int i;
    float f;
    char c;
    double d;  // 占用最多空间的成员决定 union 大小
};

✅ 特点：

所有成员起始地址相同（共享内存）。
大小 = 最大成员的大小（考虑对齐）。
任意时刻只能有一个成员是“活跃”的（active member）。

#include <iostream>
int main() {
    MyUnion u;
    std::cout << sizeof(u) << std::endl; // 输出 8（double 的大小）
    
    u.i = 42;
    std::cout << u.i << std::endl; // 42
    u.f = 3.14f;
    std::cout << u.i << std::endl; // 垃圾值！因为 f 覆盖了 i 的内存
}

⚠️ 关键规则：读取非活跃成员是未定义行为（UB）！

🔒 二、C++ 对 union 的增强（vs C）

表格

特性	C语言	C++
成员函数	❌ 不支持	✅ 支持（但不能有虚函数）
构造函数/析构函数	❌	✅（但有限制，见下文）
静态成员	✅	✅
非静态成员函数	❌	✅
继承	❌	❌（union 不能继承，也不能被继承）
访问控制（public/private）	❌	✅

示例：带成员函数的 union

union Number {
    int i;
    float f;

    void setInt(int x) { i = x; }
    void setFloat(float x) { f = x; }
    int getInt() const { return i; }
};

⚠️ 三、重要限制（C++ 标准规定）

一个 non-trivial union（即包含以下任一特性的成员）：

有非平凡构造函数（non-trivial constructor）
有非平凡析构函数（如 std::string, std::vector）
有虚函数
有引用成员

👉 会导致整个 union 无法自动调用构造/析构函数！

❌ 错误示例：

union BadUnion {
    std::string s;  // non-trivial
    int n;
}; // 编译错误！C++11 起允许声明，但不能直接使用（无默认构造函数）

✅ 正确做法：手动管理生命周期（使用 placement new / explicit destructor）

#include <new>
#include <string>

union GoodUnion {
    std::string s;
    int n;

    // 构造函数：激活 int 成员
    GoodUnion() : n(0) {}

    // 析构函数：必须手动销毁活跃成员
    ～GoodUnion() {} // 注意：这里不能自动调用 s.～string()！

    // 激活 string 成员
    void setString(const char* str) {
        new(&s) std::string(str); // placement new
    }

    // 显式销毁 string
    void destroyString() {
        s.～string();
    }
};

// 使用示例
int main() {
    GoodUnion u;
    u.setString("Hello");
    std::cout << u.s << std::endl;
    u.destroyString(); // 必须手动调用！
} // 析构函数不自动清理 s！

💡 最佳实践：避免在 union 中使用 non-trivial 类型，或使用 std::variant（C++17）替代。

🛠 四、典型应用场景

1. 节省内存

当多个变量不会同时使用时，用 union 可减少内存占用。

struct Config {
    bool is_int;
    union {
        int i_val;
        double d_val;
    };
};

2. 类型双关（Type Punning）—— 谨慎使用！

通过 union 访问同一内存的不同解释（C++ 中属于未定义行为！）。

// ❌ 不推荐（UB）：
union FloatInt {
    float f;
    uint32_t i;
};
FloatInt u;
u.f = 3.14f;
uint32_t bits = u.i; // UB! 读取非活跃成员

// ✅ 推荐方式：使用 std::bit_cast (C++20)
#include <bit>
float f = 3.14f;
uint32_t bits = std::bit_cast<uint32_t>(f);

📌 C++ 标准明确禁止通过 union 进行类型双关（尽管某些编译器如 GCC/Clang 允许作为扩展）。

3. 实现 variant-like 类型（C++17 前）

在 std::variant 出现前，手写 tagged union 是常见做法：

class Variant {
    enum Type { INT, STRING } type;
    union {
        int i;
        std::string s;
    };

public:
    Variant(int x) : type(INT), i(x) {}
    Variant(const std::string& str) : type(STRING) {
        new(&s) std::string(str);
    }
    ～Variant() {
        if (type == STRING) s.～string();
    }
    // ... 其他方法
};

🆕 五、现代 C++ 替代方案

需求	推荐方案
安全的“多类型容器”	`std::variant<T1, T2, ...>` (C++17)
类型安全的类型双关	`std::bit_cast` (C++20)
内存优化（已知互斥）	仍可使用 union，但避免 non-trivial 类型

// C++17+
#include <variant>
std::variant<int, std::string> v = "hello";
if (auto* p = std::get_if<std::string>(&v)) {
    std::cout << *p << std::endl;
}

✅ 总结：使用 union 的黄金法则

只用于 trivial 类型（如 int, float, 指针，POD 结构）。
永远不要读取非活跃成员（否则 UB）。
若含 non-trivial 成员，必须手动管理构造/析构（placement new + explicit dtor）。
优先考虑 std::variant（更安全、类型安全、自动管理生命周期）。
避免用 union 做类型双关，改用 std::bit_cast（C++20）或 memcpy。

📚 引用标准：C++17 [class.union] 规定：“At most one of the non-static data members of a union can be active at any time.”

掌握这些原则，你就能安全高效地使用 C++ union！

std::variant详解

std::variant 是 C++17 引入的一个类型安全的“和类型”（sum type）容器，用于在同一内存位置安全地存储多种不同类型中的一个值。它是对传统 C 风格 union 的现代化、类型安全的替代。

🧩 一、基本概念

“和类型”（Sum Type）：表示“A 或 B 或 C”的关系（与“积类型”如 struct 的“A 且 B 且 C”相对）。
类型安全：编译器知道当前存储的是哪种类型，避免未定义行为。
自动管理生命周期：构造、析构、移动、拷贝均由 std::variant 自动处理。
无动态分配：所有数据存储在栈上（或对象内部），性能高。

✅ 核心优势：比手写 tagged union 更安全、更简洁、更符合现代 C++。

📦 二、基本用法

1. 声明与初始化

#include <variant>
#include <string>
#include <iostream>

// 定义一个可存储 int、double 或 std::string 的 variant
std::variant<int, double, std::string> v;

v = 42;                // 存储 int
v = 3.14;              // 存储 double（自动替换）
v = std::string("Hi"); // 存储 string
v = "Hello";           // 隐式转换为 string

2. 获取当前值（安全访问）

方法一：`std::get<T>(v)`（若类型不匹配抛异常）

try {
    int i = std::get<int>(v); // OK
    double d = std::get<double>(v); // throws std::bad_variant_access
} catch (const std::bad_variant_access& e) {
    std::cout << "Wrong type!\n";
}

方法二：`std::get_if<T>(&v)`（返回指针，失败返回 nullptr）

if (auto p = std::get_if<int>(&v)) {
    std::cout << "int: " << *p << "\n";
} else if (auto p = std::get_if<std::string>(&v)) {
    std::cout << "string: " << *p << "\n";
}

方法三：`std::visit`（推荐！类型安全的访问器）

auto print_visitor = [](const auto& val) {
    std::cout << val << "\n";
};
std::visit(print_visitor, v); // 自动调用正确重载

🔍 三、核心成员函数

函数	说明
`index()`	返回当前活跃类型的索引（0 起始）
`valueless_by_exception()`	是否因异常处于无效状态（见下文）
`emplace<Index>(args...)` / `emplace<Type>(args...)`	就地构造新值
`operator=`	赋值（会自动析构旧值，构造新值）

std::variant<int, std::string> v = "hello";
std::cout << v.index() << "\n"; // 输出 1（string 是第2个类型）

v.emplace<0>(100);      // 构造 int(100)
v.emplace<std::string>("world"); // 构造 string("world")

⚠️ 四、异常安全性与 `valueless_by_exception`

当 variant 正在持有类型 A，尝试赋值为类型 B 时：

先析构 A，
再构造 B。

如果构造 B 抛出异常 → variant 既没有 A 也没有 B！
此时：

v.valueless_by_exception() == true
v.index() == variant_npos
所有 get 操作均抛出 bad_variant_access

💡 设计哲学：宁可进入“空状态”，也不保留损坏/部分构造的对象。

🧠 五、`std::visit` —— 强大的多态访问

std::visit 是使用 variant 的最佳实践，支持：

1. Lambda + auto（通用 lambda）

std::variant<int, double, std::string> v = 3.14;

std::visit([](const auto& x) {
    using T = std::decay_t<decltype(x)>;
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "Integer: " << x << "\n";
    } else if constexpr (std::is_same_v<T, double>) {
        std::cout << "Double: " << x << "\n";
    } else {
        std::cout << "String: " << x << "\n";
    }
}, v);

2. 多 variant 联合访问（类似模式匹配）

std::variant<int, std::string> v1 = 10;
std::variant<int, double> v2 = 3.14;

std::visit([](const auto& a, const auto& b) {
    std::cout << a << " + " << b << " = " << (a + b) << "\n";
}, v1, v2); // 输出: 10 + 3.14 = 13.14

✅ 编译器会为每种组合生成特化代码，零运行时开销！

🛠 六、实用技巧与模式

1. 实现状态机

struct Idle {};
struct Loading { int progress; };
struct Ready { std::string data; };

using State = std::variant<Idle, Loading, Ready>;

State state = Idle{};

// 更新状态
state = Loading{50};
state = Ready{"Hello"};

2. 替代可空指针（比 `std::optional` 更强）

// 表示“成功返回 T” 或 “错误码”
template<typename T>
using Result = std::variant<T, std::error_code>;

Result<std::string> read_file() {
    if (/* ok */) return "content";
    else return std::make_error_code(std::errc::no_such_file_or_directory);
}

3. 递归 variant（需配合 `std::vector` 等间接实现）

// JSON 值示例
struct JsonValue;

using Json = std::variant<
    std::nullptr_t,
    bool,
    int64_t,
    double,
    std::string,
    std::vector<JsonValue>,
    std::map<std::string, JsonValue>
>;

struct JsonValue {
    Json value;
};

⚖️ 七、与 `union` / `std::any` 对比

特性	`union`	`std::variant`	`std::any`
类型安全	❌	✅	✅
支持 non-trivial 类型	❌（需手动管理）	✅	✅
运行时类型信息	❌	✅（通过 index）	✅（`type()`）
内存分配	栈上	栈上	可能堆上
类型数量	编译期固定	编译期固定	任意类型
性能	最高	高（零开销抽象）	中（可能有虚表/堆分配）

✅ 选择建议：

已知有限类型 → std::variant
任意类型 → std::any
极致性能 + trivial 类型 → 手写 union（谨慎！）

📏 八、内存布局

sizeof(std::variant<Ts...>) ≥ 最大成员大小 + 类型标签（通常 1～8 字节）
对齐按最严格成员对齐
无额外指针或虚表（不像 std::any）

1 2	std::variant<char, int> v1; // sizeof ≈ 4～8 std::variant<int, std::string> v2; // sizeof = sizeof(std::string)（通常 8～32）

✅ 总结：何时使用 `std::variant`？

✅ 需要在多个已知类型中存储一个值
✅ 要求类型安全和自动内存管理
✅ 实现状态机、AST 节点、配置选项等
✅ 替代手写的 tagged union
✅ 需要高性能（栈分配、无虚函数）

🚫 不要用于：

类型在运行时才确定 → 用 std::any
仅表示“有值/无值” → 用 std::optional<T>

std::variant 是 C17 带来的强大工具，结合 std::visit 和 if constexpr，能写出既安全又高效的现代 C 代码。掌握它，是迈向类型安全编程的重要一步！

Traits

C++ 中的 traits（特征类） 是泛型编程（Generic Programming）的核心设计思想之一，其本质是 “将类型相关的属性和行为从算法或容器中解耦出来”。它不是 C++ 语言的语法特性，而是一种基于模板的编译期元编程模式。

一、Traits 的设计思想：策略分离 + 编译期多态

核心理念：

“算法不关心具体类型，只关心该类型能做什么。”

例如，一个通用排序算法不需要知道 int 或 std::string 的内部结构，只需要知道：

如何比较两个元素（< 或自定义比较）
如何交换两个元素
元素是否可平凡复制（用于优化）

Traits 就是用来**描述这些“能力”或“属性”**的机制。

二、为什么需要各种 Traits？—— 解决什么问题？

1. 让泛型代码适配不同类型

不同类型的底层操作可能完全不同：
表格

类型	复制方式	比较方式	析构需求
`int`	`memcpy`	直接 `<`	无
`std::string`	调用拷贝构造	字典序比较	需析构
自定义类	用户定义	用户重载	可能有资源
如果没有 traits，泛型函数必须为每种类型写特化版本，丧失通用性。
✅ Traits 提供统一接口，隐藏差异。

2. 实现编译期优化（零成本抽象）

通过 traits，编译器可以在编译时选择最优路径：

template<typename T>
void copy(T* dest, const T* src, size_t n) {
    if constexpr (std::is_trivially_copyable_v<T>) {
        memcpy(dest, src, n * sizeof(T)); // 快速路径
    } else {
        for (size_t i = 0; i < n; ++i)
            dest[i] = src[i]; // 安全路径
    }
}

这里 std::is_trivially_copyable_v<T> 就是一个 type trait，它让编译器在编译期决定走哪条路径，运行时无开销。

3. 支持用户自定义类型的无缝集成

标准库无法预知用户会定义什么类型。Traits 允许用户为自己的类型提供“特征描述”：

struct MyString {
    char data[100];
};

// 用户特化 char_traits
namespace std {
template<>
struct char_traits<MyString> {
    static bool eq(const MyString& a, const MyString& b) {
        return memcmp(a.data, b.data, 100) == 0;
    }
    // ... 其他操作
};
}

这样，std::basic_string<MyString> 就能正常工作！

✅ Traits 是标准库与用户代码的“协议接口”。

三、常见 Traits 分类及作用

类别	示例	作用
类型属性查询	`std::is_integral<T>`, `std::is_pointer<T>`	判断类型性质
类型转换	`std::remove_cv<T>`, `std::decay<T>`	在模板推导中标准化类型
迭代器特征	`std::iterator_traits<Iter>::value_type`	从迭代器提取值类型
字符特征	`std::char_traits<char>`	定义字符操作（赋值、比较、复制等）
分配器特征	`std::allocator_traits<Alloc>`	统一分配器接口（即使用户没实现所有方法）
数值特征	`std::numeric_limits<int>`	查询数值范围、精度等

四、经典案例解析

案例 1：`std::char_traits` —— 解耦字符串操作

template<typename CharT>
class basic_string {
    // 不直接写 s1[i] == s2[i]，而是：
    Traits::eq(s1[i], s2[i]);
    Traits::copy(dest, src, n);
}

支持 char, wchar_t, char8_t 等
用户可自定义字符语义（如忽略大小写比较）

案例 2：`std::iterator_traits` —— 统一迭代器接口

早期迭代器可能是指针或类：

template<typename Iter>
void algo(Iter it) {
    using value_type = typename std::iterator_traits<Iter>::value_type;
    value_type tmp = *it; // 无论 Iter 是 int* 还是 list<int>::iterator 都能工作
}

对指针自动特化：iterator_traits<int*> → value_type = int
对类迭代器要求定义 value_type 成员

案例 3：`std::allocator_traits` —— 为分配器提供默认实现

用户只需实现 allocate/deallocate，其他如 construct, destroy 由 traits 提供默认版本。

五、为什么这么设计？—— 设计哲学

1. 最小依赖原则

算法只依赖它需要的操作，而不是整个类型。

2. 开闭原则（Open/Closed）

对扩展开放：用户可通过特化 traits 支持新类型
对修改关闭：标准库算法无需改动

3. 零成本抽象（Zero-overhead Abstraction）

所有 traits 查询在编译期完成，不产生运行时开销。

4. 正交性（Orthogonality）

类型属性、操作、算法三者正交组合，极大提升代码复用性。

六、现代 C++ 的演进

C++11/14：引入大量 type traits（<type_traits>）
C++20：用 concepts 进一步简化 traits 使用：cpp编辑
1
2
template<std::integral T>
void foo(T x); // 比 enable_if + is_integral 更清晰
但 concepts 底层仍依赖 traits 实现。

总结：Traits 的核心价值

问题	Traits的解决方案
泛型代码如何适配不同类型？	通过 traits 描述类型能力
如何实现编译期优化？	traits 提供编译期常量（true/false）
如何让用户类型融入标准库？	允许用户特化 traits
如何避免重复代码？	算法只写一次，靠 traits 适配

💡 Traits 是 C++ 泛型编程的“胶水”和“适配器”，它让静态类型系统具备了类似动态语言的灵活性，同时保持高性能。

正如 Alexander Stepanov（STL 之父）所说：

“Generic programming is about finding the right interfaces that capture the essence of algorithms.”
（泛型编程的本质是找到能刻画算法本质的正确接口。）

而 traits 就是这些接口的关键组成部分。

C++20 `Concpets`

C++20 引入的 Concepts（概念） 是泛型编程的一次革命性升级，它从根本上改变了模板的设计、使用和错误诊断方式。其核心目标是：让泛型代码更安全、更清晰、更易用。

一、什么是 Concepts？

Concepts 是对模板参数施加的编译期约束（constraints），用于显式声明“类型必须满足什么要求”。

在 C++20 之前，模板是“隐式接口”：

template<typename T>
void sort(T& container) {
    // 假设 T 有 begin(), end(), 支持随机访问...
    // 但如果不满足？编译器在 deep instantiation 时报错，信息极难读！
}

C++20 允许你显式声明契约：

1 2	template<std::random_access_range R> void sort(R& container); // 清晰表达：只接受随机访问范围

二、Concepts 的核心组成

1. 定义 Concept

使用 concept 关键字 + constexpr bool 表达式：

#include <concepts>

// 自定义 concept：支持 + 和 == 的类型
template<typename T>
concept AddableAndComparable = requires(T a, T b) {
    a + b;          // 表达式必须合法
    { a == b } -> std::convertible_to<bool>; // 结果可转为 bool
};

2. 使用 Concept 约束模板

// 方式1：模板参数列表
template<AddableAndComparable T>
T add_and_check(T a, T b) { return a + b; }

// 方式2：auto + constraint（简写）
void process(std::integral auto x); // 等价于 template<std::integral T> void process(T x);

// 方式3：requires 子句（更复杂条件）
template<typename T>
requires std::copyable<T> && AddableAndComparable<T>
T duplicate_add(T a) { return a + a; }

3. 标准库提供的 Concepts

C++20 在 <concepts> 和 <ranges> 中提供了大量预定义 concept：

类别	示例
基础类型	`std::integral`, `std::floating_point`, `std::same_as<T, U>`
关系与比较	`std::equality_comparable`, `std::totally_ordered`
对象语义	`std::copyable`, `std::movable`, `std::destructible`
迭代器/范围	`std::input_iterator`, `std::random_access_range`, `std::view`

三、Concepts 对泛型编程的影响 ✅

1. 错误信息从“天书”变“人话”

Before (C++17)：text编辑

1 2	error: no match for 'operator' in '__first__first' ... （数百行模板实例化栈）

After (C++20)：text编辑

1 2	error: cannot call 'process' with argument of type 'MyClass' note: 'MyClass' does not satisfy 'std::integral'

2. 接口契约显式化，提升可读性

1 2	// 谁都能看懂：这个函数只处理整数 void increment(std::integral auto& x) { ++x; }

3. 支持重载和特化基于 Concept

void print(std::integral auto x)      { std::cout << "int: " << x; }
void print(std::floating_point auto x) { std::cout << "float: " << x; }

print(42);    // 调用第一个
print(3.14);  // 调用第二个

这比 SFINAE 或 enable_if 清晰得多！

4. 促进“概念驱动设计”

先设计算法所需的最小接口（concept），再实现具体类型——回归 Stepanov 的泛型哲学。

四、Concepts 对模板元编程（TMP）的影响 🔄

1. 大幅减少对复杂 TMP 的需求

过去需用 std::enable_if + type traits 实现的约束，现在一行 concept 搞定：

// C++17
template<typename T>
std::enable_if_t<std::is_integral_v<T>> foo(T x);

// C++20
void foo(std::integral auto x);

2. TMP 从“技巧”回归“工具”

不再需要为约束写复杂的 trait 组合。
<type_traits> 仍用于查询属性，但控制模板使能交给 concepts。

3. 编译速度可能提升

编译器可在模板实例化前快速检查 concept 是否满足，避免深度展开无效模板。

五、如何应用 Concepts？—— 最佳实践

✅ 1. 优先使用标准 Concept

不要重复造轮子：

#include <concepts>
#include <ranges>

// 好：使用标准 range concept
void print_all(std::input_range auto&& r) {
    for (const auto& x : r) std::cout << x << ' ';
}

✅ 2. 自定义 Concept 遵循“最小完备”原则

只包含算法真正需要的操作：

// 好：仅要求必要操作
template<typename T>
concept Drawable = requires(T t) {
    t.draw();
};

// 坏：过度约束
template<typename T>
concept Drawable = requires(T t) {
    t.draw();
    t.setPosition(0, 0); // 如果算法不用 setPosition，就不该要求
};

✅ 3. 组合 Concept 而非继承

template<typename T>
concept Printable = requires(T t) {
    std::cout << t;
};

template<typename T>
concept DrawableAndPrintable = Drawable<T> && Printable<T>;

✅ 4. 用 Concept 代替文档注释

// 不要这样：
// "T must support operator< and be copyable"
template<typename T>
void my_sort(T& container);

// 要这样：
template<std::sortable auto& Container>
void my_sort(Container& c);

✅ 5. 谨慎使用 requires 子句

仅当约束无法用简单 concept 表达时使用：

1
2
3

template<typename T>
requires std::is_default_constructible_v<T> && std::has_virtual_destructor_v<T>
class MyClass;

六、经典应用场景

场景 1：泛型算法约束

1
2
3

template<std::forward_iterator Iter, typename Val>
requires std::equality_comparable_with<std::iter_value_t<Iter>, Val>
Iter find(Iter first, Iter last, const Val& value);

场景 2：容器适配

template<std::ranges::range R>
auto unique_values(R&& r) {
    std::set<std::ranges::range_value_t<R>> s;
    for (auto&& x : r) s.insert(x);
    return s;
}

场景 3：策略选择（替代 enable_if）

template<typename Policy>
concept LoggingPolicy = requires(Policy p, const char* msg) {
    p.log(msg);
};

template<LoggingPolicy L = DefaultLogger>
class Service {
    L logger;
public:
    void run() { logger.log("Running..."); }
};

七、注意事项 ⚠️

Concepts 不是运行时检查：违反约束在编译期报错，不会产生运行时开销。
不支持 concept 的虚函数：不能写 virtual void f(std::integral auto x)。
过度约束会降低通用性：确保 concept 真的是算法所需。
编译器支持：GCC 10+、Clang 10+、MSVC 19.30+ 已支持。

总结：Concepts 的哲学意义

Concepts 将泛型编程从“魔法”变为“工程”。

过去：模板是“黑盒”，靠 SFINAE 和 traits 技巧实现约束，错误信息晦涩。
现在：模板是“契约接口”，concept 显式声明要求，编译器成为你的协作者。

如何拥抱 Concepts？

学习标准 concept（<concepts>, <ranges>）
在新代码中优先使用 constrained templates
逐步重构旧模板，添加 concept 约束
设计算法时先思考“它需要什么概念？”

正如 Bjarne Stroustrup 所说：

“Concepts bring generic programming back to its roots: clear interfaces and efficient implementations.”

这正是 C++ 泛型编程的未来。

有了 `concept` 还需要 `traits` 吗

这是一个非常关键且深刻的问题。答案是：是的，即使有了 Concepts，Traits 仍然必不可少。
Concepts 和 Traits 不是替代关系，而是互补关系，它们在现代 C++ 泛型编程中扮演不同但协同的角色。

一、核心区别：职责不同

Concepts	Traits
目的	约束模板参数（“类型是否满足要求？”）
使用时机	编译期接口契约检查
输出	`true` / `false`（布尔判断）
类比	函数的前置条件（precondition）

✅ Concepts 回答 “Can I use this type here?”
✅ Traits 回答 “What is this type, and how do I work with it?”

二、为什么 Concepts 不能取代 Traits？

场景 1：需要从类型中提取信息

template<std::integral T>
void process(T value) {
    // 我需要知道 T 的“无符号版本”是什么？
    using unsigned_type = std::make_unsigned_t<T>; // ← 这是 type trait！

    unsigned_type u = static_cast<unsigned_type>(value);
    // ...
}

Concepts 只能告诉你 T 是整数，但无法告诉你对应的无符号类型。
这必须靠 std::make_unsigned 这样的 type transformation trait。

场景 2：算法内部需要适配类型行为

template<std::ranges::input_range R>
auto sum(R&& r) {
    using value_type = std::ranges::range_value_t<R>; // ← trait!
    
    // 初始化累加器：需要知道 value_type 的“零值”或默认构造方式
    value_type total{};
    
    for (auto&& x : r) total += x;
    return total;
}

std::ranges::range_value_t<R> 是一个 trait，用于从范围类型 R 中提取元素类型。
Concepts（如 input_range）只保证 R 有 begin/end，但不提供如何获取 value_type 的语法。

💡 没有 traits，泛型算法连“元素是什么类型”都不知道！

场景 3：实现 Concept 本身依赖 Traits

标准库中的许多 Concepts 内部就是用 Traits 实现的：

// 简化版 std::integral 的实现
template<typename T>
concept integral = std::is_integral_v<T>; // ← 直接调用 type trait!

// std::equality_comparable 的实现也依赖 operator== 是否存在，
// 而检测操作符是否存在通常通过 traits-like 技术（requires 表达式本质也是一种 trait 查询）

✅ Concepts 常常是 Traits 的“用户”而非“替代者”。

场景 4：类型转换和标准化

template<typename F>
void call_with_decay(F&& f) {
    using clean_type = std::decay_t<F>; // ← trait: 去掉引用、const、数组退化等
    
    // clean_type 可用于存储、特化、日志等
    invoke_function<clean_type>(std::forward<F>(f));
}

Concepts 无法完成 T& → T 或 int[5] → int* 这类类型变换。
这是 <type_traits> 的核心价值。

三、现代 C++ 中的协作模式

典型泛型函数结构：

#include <concepts>
#include <type_traits>

// 1. 用 Concept 约束接口（安全、清晰）
template<std::floating_point T>
T safe_sqrt(T x) {
    // 2. 用 Trait 获取相关信息（实现逻辑）
    if constexpr (std::is_same_v<T, float>) {
        return __builtin_sqrtf(x); // 特化优化
    } else if constexpr (std::is_same_v<T, double>) {
        return __builtin_sqrt(x);
    } else {
        return std::sqrt(x);
    }
}

// 另一个例子：分配内存
template<std::regular T>
class my_vector {
    using allocator_type = std::allocator<T>;
    // 使用 allocator_traits 来统一分配器接口
    using alloc_traits = std::allocator_traits<allocator_type>;
    
public:
    void push_back(const T& value) {
        // alloc_traits::construct(alloc, ptr, value); // trait 提供 construct 方法
    }
};

🔗 Concepts 守门，Traits 办事。

四、哪些 Traits 会被弱化？

确实，部分 Traits 的使用场景被 Concepts + requires 替代了：
表格

旧方式（C++17）	新方式（C++20）	说明
`std::enable_if_t<std::is_integral_v<T>>`	`template<std::integral T>`	✅ Concepts 更清晰
手写 SFINAE 检测成员函数	`requires { t.foo(); }`	✅ `requires` 表达式更直接
但这只是 “约束使能” 场景的替代，而 “类型查询/转换” 场景依然完全依赖 Traits。

五、总结：两者共存，各司其职

任务	推荐工具
限制模板能接受哪些类型	✅ Concepts
从类型中提取信息（如 value_type）	✅ Traits
转换类型（如 remove_cv, decay）	✅ Traits
查询类型属性（is_trivial, is_final）	✅ Traits
为分配器/迭代器提供统一接口	✅ Traits（如 `allocator_traits`）
实现 Concept 的底层判断	✅ Traits + requires 表达式

🌟 Concepts 让泛型接口更安全、更易用；Traits 让泛型实现更强大、更灵活。

正如 C++ 标准委员会成员所说：

“Concepts are the front door; traits are the tools in the workshop.”
（Concepts 是前门，Traits 是车间里的工具。）

因此，学习和使用 Traits 在 C++20+ 时代依然至关重要。

计算机基础

一、基本单位

以比特（bit）为单位：

以字节（Byte）为单位（常用于文件传输、存储等场景）：

通用寄存器（General-Purpose Registers, GPRs）

基本寄存器（共 16 个，在 x86-64 中扩展为 64 位）

一、硬件基础：连接方式

1. 系统总线（System Bus）

2. 内存控制器（Integrated Memory Controller, IMC）

二、 “总线”一词的现代含义

三、总结

位运算

一、基本位运算符

位运算

一、基本位运算符

二、XOR 的核心性质（牢记！）

1. 找出数组中唯一出现一次的数（其余都出现两次）

2. 翻转特定位（Toggle Bit）

指针部分

源代码

MSVC 汇编代码

Linux 汇编

内存分配

c语言动态内存

🔑 核心对比表

一、C++ 层面：new / delete 的语义

1. new 表达式做了两件事：

2. delete 表达式也做两件事：

二、operator new / operator delete 的底层实现

默认的全局 operator new 实际上是 对 C 库 malloc 的封装！

示例（简化版 libstdc++ 实现）：

三、STL 容器（如 std::vector）如何分配内存？

1. 默认分配器：std::allocator<T>

2. std::allocator 的底层行为（C++17 及以前）：

示例（vector::push_back 内部）：

四、malloc 的底层：glibc 的 ptmalloc（Linux）

glibc 使用 ptmalloc2（基于 dlmalloc），核心机制：

内存分配流程（简化）：

五、Windows 下的实现（MSVC）

六、总结：C++ 动态内存分配的调用栈

一、memcpy —— 内存复制

📌 函数原型

⚠️ 重要限制：不能处理内存重叠！

二、memset —— 内存设置（填充）

📌 函数原型

✅ 关键特性：

✅ 示例

智能指针

一、什么是“所有权”？

二、C++ 所有权的三种主要模型

三、详细解析 + 实际案例

✅ 1. 独占所有权：std::unique_ptr

特性：

案例：工厂函数返回独占对象

为什么比裸指针好？

✅ 2. 共享所有权：std::shared_ptr

特性：

案例：多对象共享同一资源

✅ 3. 观察者（无所有权）：std::weak_ptr 和原始指针

问题：shared_ptr 的循环引用

解决方案：std::weak_ptr

原始指针作为观察者（函数参数）

四、所有权规则总结（C++ Core Guidelines）

五、高级：自定义资源的所有权（RAII）

✅ 总结：C++ 所有权的核心思想

Unicode 编码

基于首字节的位模式判断（推荐）

字符串分割算法

C/C++值的分类

一、最朴素的定义（C 语言时代）

二、C++11 后的精细化分类（5 种值类别）

📌 三者关系图：

三、如何判断一个表达式是左值还是右值？

✅ 判断法则（实用版）：

四、为什么需要区分？—— 移动语义的核心

传统拷贝（低效）：

C++11 移动语义（高效）：

五、左值引用 vs 右值引用

示例：

六、万能引用（Universal Reference）与引用折叠

一、C++ 层面：`new` / `delete` 的语义

1. `new` 表达式做了两件事：

2. `delete` 表达式也做两件事：

二、`operator new` / `operator delete` 的底层实现

默认的全局 `operator new` 实际上是对 C 库 `malloc` 的封装！

三、STL 容器（如 `std::vector`）如何分配内存？

1. 默认分配器：`std::allocator<T>`

2. `std::allocator` 的底层行为（C++17 及以前）：

示例（`vector::push_back` 内部）：

四、`malloc` 的底层：glibc 的 `ptmalloc`（Linux）

一、`memcpy` —— 内存复制

二、`memset` —— 内存设置（填充）

✅ 1. 独占所有权：`std::unique_ptr`

✅ 2. 共享所有权：`std::shared_ptr`

✅ 3. 观察者（无所有权）：`std::weak_ptr` 和原始指针

问题：`shared_ptr` 的循环引用

解决方案：`std::weak_ptr`

2. 转发时用 `std::forward`

`static 和 inline 辨析`

一、`static` 关键字

二、`inline` 关键字

三、`static` 与 `inline` 的对比总结

`union` 详解

方法一：`std::get<T>(v)`（若类型不匹配抛异常）

方法二：`std::get_if<T>(&v)`（返回指针，失败返回 nullptr）

方法三：`std::visit`（推荐！类型安全的访问器）

⚠️ 四、异常安全性与 `valueless_by_exception`

🧠 五、`std::visit` —— 强大的多态访问

2. 替代可空指针（比 `std::optional` 更强）

3. 递归 variant（需配合 `std::vector` 等间接实现）

⚖️ 七、与 `union` / `std::any` 对比

✅ 总结：何时使用 `std::variant`？

案例 1：`std::char_traits` —— 解耦字符串操作

案例 2：`std::iterator_traits` —— 统一迭代器接口

案例 3：`std::allocator_traits` —— 为分配器提供默认实现