内存管理

在 C++ 中，内存管理是开发的核心挑战之一，而RAII（Resource Acquisition Is Initialization，资源获取即初始化） 是 C++ 解决资源（包括内存）管理问题的核心机制。RAII 通过对象的生命周期自动管理资源，从根本上避免了手动管理资源的风险（如内存泄漏、悬垂指针等）。

一、RAII：资源管理的核心思想

RAII 的核心逻辑是：将资源的获取与对象的初始化绑定，将资源的释放与对象的析构绑定。

资源获取：当创建对象时（初始化），同时获取资源（如分配内存、打开文件、锁定互斥量等）。
资源释放：当对象超出作用域（生命周期结束）时，自动调用析构函数，在析构函数中释放资源。

由于 C++ 中栈对象的生命周期是确定的（由作用域控制），这种机制能确保：无论程序是正常退出还是因异常退出，资源都能被可靠释放。

RAII 的简单示例（手动实现）

假设需要管理一块动态内存，传统手动管理方式存在泄漏风险，而 RAII 可通过封装解决：

// 1. 传统手动管理（风险高）
void bad_usage() {
    int* ptr = new int(10);  // 获取资源（分配内存）
    // … 业务逻辑（若中途return或抛异常，delete不会执行）
    delete ptr;  // 释放资源（可能被跳过）
}
 
// 2. RAII封装（安全）
class IntPtr {  // 封装内存资源的RAII类
private:
    int* ptr;
public:
    // 构造函数：获取资源（初始化时分配内存）
    IntPtr(int value) : ptr(new int(value)) {}
    
    // 析构函数：释放资源（对象销毁时自动调用）
    ~IntPtr() {
        delete ptr;  // 确保释放，无论程序如何退出
    }
    
    // 提供访问资源的接口
    int& get() { return *ptr; }
};
 
void good_usage() {
    IntPtr raii_obj(10);  // 创建对象时获取资源（分配内存）
    raii_obj.get() = 20;  // 使用资源
    // … 业务逻辑（即使中途return或抛异常）
}  // raii_obj超出作用域，自动调用析构函数释放内存

关键：IntPtr 对象的生命周期完全由作用域控制，其析构函数必然会执行，从而确保内存被释放。

二、C++ 内存管理的核心工具（基于 RAII）

C++ 标准库提供了多个基于 RAII 的工具，彻底替代了手动 new/delete，从根源上避免内存问题。

1. 智能指针（Smart Pointers）（C++11）

智能指针是 RAII 在内存管理中的典型应用，它们封装了原始指针，在析构函数中自动释放内存。C++11 起提供三种核心智能指针：

（1）std::unique_ptr：独占所有权

特点：同一时间只能有一个 unique_ptr 指向资源，所有权不可共享（禁止复制，仅允许移动）。
适用场景：管理单个对象的独占所有权（如局部动态对象、工厂函数返回值）。

#include <memory>
 
void use_unique_ptr() {
    // 创建unique_ptr（获取资源），指向一个int对象
    std::unique_ptr<int> uptr(new int(10));  // C++11
    // 或更安全的方式（C++14起推荐）：
    auto uptr = std::make_unique<int>(10);   // 避免裸new，更安全
    
    *uptr = 20;  // 访问资源（重载了*和->运算符）
    
    // 所有权转移（通过移动语义）
    std::unique_ptr<int> uptr2 = std::move(uptr);  // uptr变为nullptr，uptr2拥有所有权
}  // uptr2超出作用域，自动释放内存（调用delete）

（2）std::shared_ptr：共享所有权

特点：多个 shared_ptr 可共享同一资源的所有权，通过 “引用计数” 跟踪所有者数量，当最后一个 shared_ptr 销毁时，释放资源。
适用场景：资源需要被多个对象共享（如容器中存储的动态对象、跨模块传递的资源）。

#include <memory>
#include <vector>
 
void use_shared_ptr() {
    // 创建shared_ptr（引用计数初始化为1）
    auto sptr = std::make_shared<int>(100);  // 推荐使用make_shared，更高效
    
    {
        auto sptr2 = sptr;  // 复制，引用计数变为2
        *sptr2 = 200;
    }  // sptr2销毁，引用计数减为1
    
    std::vector<std::shared_ptr<int>> vec;
    vec.push_back(sptr);  // 引用计数变为2
    vec.push_back(sptr);  // 引用计数变为3
}  // sptr销毁，vec中元素也销毁，引用计数减为0 → 释放内存

（3）std::weak_ptr：弱引用（解决循环引用）

特点：不增加引用计数，仅作为 shared_ptr 的 “观察者”，可用于打破 shared_ptr 的循环引用（避免内存泄漏）。
用法：通过 lock() 方法获取 shared_ptr（若资源已释放，返回空）。

#include <memory>
 
struct Node {
    std::shared_ptr<Node> next;  // 若两个Node相互指向，会形成循环引用
    // std::weak_ptr<Node> next;  // 改用weak_ptr可打破循环
};
 
void avoid_cycle() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();
    node1->next = node2;  // 引用计数：node2变为2
    node2->next = node1;  // 引用计数：node1变为2 → 循环引用！
    
    // 函数结束时，node1和node2的引用计数各减1（变为1），资源不会释放（内存泄漏）
    // 若next是weak_ptr，node2->next = node1不会增加node1的引用计数，无循环
}

2. 标准容器（自动管理内存）

STL 容器（如 std::vector、std::string）内部也基于 RAII 管理内存：

容器初始化时自动分配内存，元素添加时动态扩容。
容器销毁时（超出作用域），自动释放所有内部内存（包括元素的内存）。

#include <vector>
#include <string>
 
void container_raii() {
    std::vector<int> vec;  // 初始化时分配内部内存
    vec.push_back(1);
    vec.push_back(2);  // 自动扩容
    
    std::string str = "hello";  // 管理字符串的动态内存
    
}  // vec和str销毁，自动释放所有内部内存（无需手动操作）

三、C++ 内存管理的常见问题与 RAII 的解决

手动管理内存（new/delete）容易引发三类问题，而 RAII 从根本上避免了这些问题：

问题	手动管理的风险	RAII 的解决方式
内存泄漏	忘记调用 `delete`，或异常导致 `delete` 被跳过（如 `bad_usage()` 示例）。	析构函数自动执行，无论程序正常退出还是异常退出，资源必被释放。
double free	对同一指针多次调用 `delete`（如复制指针后分别释放）。	智能指针管理所有权（`unique_ptr` 禁止复制，`shared_ptr` 通过引用计数确保仅释放一次）。
悬垂指针（野指针）	指针指向的内存已释放，但指针未置空，后续访问导致未定义行为。	智能指针在资源释放后自动变为 `nullptr`（如 `unique_ptr` 移动后变为空）。

四、RAII 的扩展：管理非内存资源

RAII 不仅用于内存管理，还可管理所有 “需手动释放的资源”，例如：

文件句柄（std::fstream 内部使用 RAII，离开作用域自动关闭文件）；
互斥锁（std::lock_guard 获取锁，析构时自动释放，避免死锁）；
网络连接、数据库连接等。

#include <mutex>
#include <thread>
 
std::mutex mtx;  // 全局互斥锁
 
void safe_thread() {
    std::lock_guard<std::mutex> lock(mtx);  // RAII：获取锁（初始化）
    // … 临界区操作（即使抛异常）
}  // lock析构，自动释放锁（避免死锁）

总结

RAII 是 C++ 资源管理的灵魂：通过对象生命周期绑定资源的获取与释放，确保资源安全。
内存管理的最佳实践：完全避免手动 new/delete，优先使用 std::unique_ptr（独占）、std::shared_ptr（共享）和标准容器，它们都是 RAII 的完美实现。
核心价值：将资源管理逻辑与业务逻辑分离，减少人为错误，提升代码可靠性。
内存管理：
- new/delete 与 malloc/free 的区别。
- 内存泄漏、浅拷贝与深拷贝。
RAII 模式：
- 通过对象生命周期管理资源（如文件句柄、锁）。
智能指针：
- std::unique_ptr, std::shared_ptr, std::weak_ptr。

移动语义与值语义

好的，我们来深入详解 C++ 中的值语义(Value Semantics) 和 移动语义(Move Semantics)。理解这两者对于掌握现代 C++ 的高效编程至关重要，它们直接关系到对象的复制、传递和资源管理。

1. 值语义 (Value Semantics)

值语义是 C++ 中最基础、最核心的对象处理方式。

核心概念

定义: 当一个对象被复制（通过拷贝构造或拷贝赋值）时，会创建一个独立的、拥有自己资源副本的新对象。原对象和新对象在逻辑上是完全独立的，修改其中一个不会影响另一个。
类比: 就像复印一份文件。你有原件，复印机给你一份内容完全相同的复印件。两份文件是独立的实体，修改复印件不会影响原件，反之亦然。
实现: 通过拷贝构造函数(Copy Constructor) 和拷贝赋值运算符(Copy Assignment Operator) 来实现。

值语义的体现

#include <iostream>
#include <vector>
 
int main() {
    std::vector<int> vec1 = {1, 2, 3}; // vec1 拥有自己的内存
    std::vector<int> vec2 = vec1;      // 值语义: 拷贝构造
                                       // vec2 获得一份 vec1 内容的完整副本
                                       // 两者指向不同的内存块
 
    vec2.push_back(4); // 修改 vec2
 
    std::cout << "vec1: "; 
    for (int n : vec1) std::cout << n << " "; // 输出: 1 2 3
    std::cout << "\nvec2: "; 
    for (int n : vec2) std::cout << n << " "; // 输出: 1 2 3 4
 
    return 0;
}

vec2 = vec1 触发了 std::vector 的拷贝构造函数。vec2 的内部动态数组是 vec1 内部数组的一个深拷贝(Deep Copy)。这是典型的值语义。

值语义的优缺点

优点:
- 直观安全: 行为符合直觉，对象独立，避免了意外的副作用。
- 易于理解: 逻辑清晰，调试相对简单。
缺点:
- 性能开销: 对于包含大量数据或动态资源（如大数组、文件句柄）的对象，拷贝操作可能非常昂贵（时间 + 内存）。例如，拷贝一个包含百万个元素的 vector 需要分配新内存并复制所有元素。

何时使用值语义

处理小型、简单的数据类型（int, double, std::string 短字符串等）。
需要对象完全独立的场景。
作为函数参数传递小型对象（有时比引用更高效，避免了指针解引用开销）。

2. 移动语义 (Move Semantics) - C++11 引入

移动语义是 C++11 引入的一项革命性特性，旨在解决值语义在处理大型对象时的性能瓶颈。

核心概念

定义: 将一个对象的资源（如动态内存、文件句柄）” 移动 “（转移所有权）到另一个对象，而不是进行昂贵的拷贝。源对象在移动后通常处于一个有效但未指定的状态（通常是空的或可安全析构的状态），不再拥有那些资源。
类比: 就像把一份文件从一个文件夹剪切到另一个文件夹。文件本身没有被复制，只是改变了它的 ” 所有权 ” 和位置。原来的文件夹里文件没了，新的文件夹里有了文件。
实现: 通过移动构造函数(Move Constructor) 和移动赋值运算符(Move Assignment Operator) 来实现。它们的参数是右值引用(Rvalue Reference)，类型为 T&&。

关键概念：左值 (Lvalue) 和右值 (Rvalue)

理解移动语义的前提是理解左值和右值。

左值 (Lvalue):
- 有名字、有确定内存地址的对象。
- 可以取地址 (&)。
- 通常位于赋值表达式的左边。
- 生命周期通常较长。
- 例子: 变量名 (int x; x = 5;), 函数返回的左值引用。
右值 (Rvalue):
- 临时的、匿名的对象。
- 通常位于赋值表达式的右边。
- 生命周期很短，通常是表达式求值过程中的临时结果。
- 不能取地址（或取地址没有意义）。
- 例子: 字面量 (42, "hello"), 临时对象 (std::string("temp")), 函数返回的非引用类型 (std::string createString() { return "temp"; })。
右值引用 (Rvalue Reference): T&& 是一种新的引用类型，专门用来绑定右值。它是实现移动语义的关键。

移动语义的体现

#include <iostream>
#include <vector>
#include <utility> // for std::move
 
class MyString {
private:
    char* data;
    size_t length;
 
public:
    // 构造函数
    MyString(const char* str) {
        length = std::strlen(str);
        data = new char[length + 1];
        std::strcpy(data, str);
        std::cout << "Constructed: " << data << "\n";
    }
 
    // 拷贝构造函数 (值语义 - 深拷贝)
    MyString(const MyString& other) : length(other.length) {
        data = new char[length + 1];
        std::strcpy(data, other.data);
        std::cout << "Copied: " << data << "\n";
    }
 
    // 移动构造函数 (移动语义)
    MyString(MyString&& other) noexcept // noexcept 非常重要
        : data(other.data), length(other.length) {
        // "窃取" other 的资源
        other.data = nullptr;   // 将源对象置空
        other.length = 0;
        std::cout << "Moved from: " << (other.data ? other.data : "nullptr") 
                  << " to: " << data << "\n";
    }
 
    // 析构函数
    ~MyString() {
        if (data) {
            std::cout << "Destroyed: " << data << "\n";
            delete[] data;
        } else {
            std::cout << "Destroyed (empty)\n";
        }
    }
 
    // ... 拷贝赋值、移动赋值等 ...
};
 
// 函数返回临时对象 (右值)
MyString createString() {
    MyString s("Hello from function");
    return s; // 返回时，s 是一个临时对象 (右值)
}
 
int main() {
    std::cout << "=== Creating temp_str ===\n";
    MyString temp_str("Temporary");
 
    std::cout << "\n=== Moving temp_str to s1 ===\n";
    MyString s1 = std::move(temp_str); // 显式移动: temp_str 是左值，用 std::move 转为右值引用
    // temp_str 现在处于有效但未指定状态 (data=nullptr)
 
    std::cout << "\n=== Moving return value to s2 ===\n";
    MyString s2 = createString(); // 隐式移动: 函数返回值是右值，优先调用移动构造
                                  // (编译器可能进行 RVO/NRVO 优化，完全避免构造)
 
    std::cout << "\n=== End of main ===\n";
    return 0;
}

输出分析:

=== Creating temp_str ===
Constructed: Temporary

=== Moving temp_str to s1 ===
Moved from: Temporary to: Temporary
Destroyed (empty)           // temp_str 析构，但 data 是 nullptr，不释放内存

=== Moving return value to s2 ===
Constructed: Hello from function
Moved from: Hello from function to: Hello from function
Destroyed (empty)           // 函数内的临时 s 析构

=== End of main ===
Destroyed: Hello from function // s2 析构，释放内存
Destroyed: Temporary         // s1 析构，释放内存

MyString s1 = std::move(temp_str);: std::move 将左值 temp_str 转换为右值引用，从而调用移动构造函数。s1 直接接管了 temp_str 的 data 指针，temp_str 的指针被置空。
MyString s2 = createString();: 函数返回一个临时对象（右值），编译器优先调用移动构造函数（如果存在），避免了深拷贝。s2 接管了临时对象的资源。

`std::move` 的作用

std::move 并不移动任何东西！它只是一个类型转换。
它的定义类似于 static_cast<T&&>(arg)，将一个左值强制转换为右值引用。
这个转换告诉编译器：” 我知道这个对象（左值）的内容可以被安全地 ’ 窃取 ‘，请调用移动构造/赋值函数 ”。
警告: std::move 之后，原对象不应再被使用（除了赋值或析构），因为它已处于未指定状态。

移动语义的优缺点

优点:
- 极致性能: 避免了昂贵的深拷贝，只需转移指针，时间复杂度 O(1)。
- 资源管理更高效: 特别适合管理动态内存、文件句柄等资源。
- 启用新功能: 使得 std::unique_ptr（独占所有权的智能指针）成为可能。
缺点:
- 复杂性: 增加了语言的复杂性，需要理解左值/右值、右值引用等概念。
- 源对象失效: 移动后源对象处于未指定状态，使用不当会导致错误。

值语义 Vs 移动语义：对比与选择

特性	值语义 (Value Semantics)	移动语义 (Move Semantics)
资源处理	复制资源 (深拷贝)	转移资源所有权
对象独立性	高 (完全独立)	低 (源对象失效)
性能	可能很低 (O(n))	极高 (O(1))
实现机制	拷贝构造/赋值 (`T(const T&)`)	移动构造/赋值 (`T(T&&)`)
参数类型	左值引用 (`const T&`)	右值引用 (`T&&`)
触发条件	复制左值	复制右值或 `std::move(左值)`
典型场景	小对象、需要独立副本	大对象、临时对象、函数返回值、容器操作 (`push_back`, `emplace`)

如何选择？

默认使用值语义: 对于小型对象或需要独立性的场景。
在需要性能时使用移动语义:
- 函数返回大型对象。
- 向容器（如 vector）中添加大型对象（push_back(std::move(obj)) 或使用 emplace_back）。
- 传递临时对象作为函数参数。
让编译器帮你: 编写良好的类（遵循 Rule of Five），编译器会在合适的时候自动调用移动操作（如返回值优化 RVO/NRVO 可能完全避免移动）。
优先使用标准库: std::string, std::vector, std::unique_ptr 等都已完美实现了移动语义，使用它们可以自动获得性能优势。

总结

值语义是 C++ 的基石，保证了对象的独立性和安全性，但可能带来性能开销。
移动语义是 C++11 的强大补充，通过转移资源所有权，以极低的开销实现了 ” 复制 ” 大型对象的效果，解决了值语义的性能瓶颈。
两者不是互斥的，而是互补的。一个设计良好的 C++ 类应该同时支持值语义（拷贝）和移动语义，让使用者可以根据场景选择最合适的操作。
理解左值/右值和右值引用是掌握移动语义的前提。
正确使用 std::move 可以显式触发移动操作，但要记住移动后源对象不应再被使用。

掌握值语义和移动语义，是编写高效、现代 C++ 代码的关键一步。它们共同构成了 C++ 资源管理（RAII）和性能优化的核心。

高效编程

优先使用连续内存容器，减少缓存未命中

原理：CPU 缓存以 “缓存行”（通常 64 字节）为单位加载数据，连续内存（如 vector）能最大化缓存利用率，而离散内存（如 list）会导致频繁缓存失效。
实践：用 vector 替代 list、deque（除非尾部操作），用 array 替代 C 风格数组（边界安全且性能相当）。

数据对齐与紧凑布局

原理：CPU 访问未对齐的数据（如跨缓存行的 int）需要额外周期，而紧凑的数据结构能减少内存占用和缓存行消耗。

实践：

按 “字节由小到大” 排序类成员（利用内存对齐规则，减少填充字节）。
用 alignas 指定对齐方式（如对齐到缓存行，避免伪共享）。

// 差：成员顺序导致大量填充（假设64位系统，int占4字节，double占8字节）
struct BadLayout {
    char c;    // 1字节 + 3字节填充（对齐到int）
    int i;     // 4字节
    double d;  // 8字节（总大小：1+3+4+8=16字节）
};
 
// 优：按大小排序，无填充
struct GoodLayout {
    char c;    // 1字节
    int i;     // 4字节（+3填充对齐到double）
    double d;  // 8字节（总大小：1+3+4+8=16字节，与BadLayout相同，但逻辑更紧凑）
};
 
// 避免伪共享（多线程访问同一缓存行的不同变量，导致缓存失效）
struct alignas(64) CacheLineAligned {  // 对齐到64字节缓存行
    int value;
};

减少函数调用开销：内联与避免过度封装

内联函数：对短小高频的函数（如 getter/setter）用 inline 修饰，编译器会将函数体直接嵌入调用处，减少栈帧创建 / 销毁的开销。
```
// 高频调用的小函数，建议内联
inline int add(int a, int b) { return a + b; }
```
注意：inline 是建议，编译器可能忽略（如函数体过大）；类内定义的成员函数默认内联。
避免过度封装：性能关键路径上，避免多层函数调用（如 obj.getA().getB().calc()），减少间接跳转开销。

编译期计算：用 `constexpr` 减少运行时开销

将能在编译期确定的计算（如常量、简单算法）用 constexpr 实现，避免运行时重复计算（见前）。

零成本抽象（Zero-Cost Abstraction）

高级语法 ≠ 性能损失

模板、lambda、智能指针等，在编译后不产生运行时开销
编译器会内联、优化成原始 C 风格代码

// 你写：
auto square = [](float x) { return x * x; };
std::transform(v.begin(), v.end(), v.begin(), square);

// 编译器生成：
// for (int i=0; i<n; ++i) v[i] = v[i]*v[i];

✅ 原则：大胆使用高级语法，相信编译器

高效 C++ 编程必备工具

1. STL 容器

容器	用途	推荐场景
`std::vector<T>`	动态数组	最常用，替代原生数组
`std::array<T, N>`	固定大小数组	栈上分配，高性能
`std::string`	字符串	替代 `char*`
`std::unordered_map<K,V>`	哈希表	快速查找
`std::shared_ptr<T>`	引用计数指针	共享所有权
`std::unique_ptr<T>`	独占指针	RAII 资源管理

2. 算法库 `<algorithm>`

算法	用途
`std::transform`	映射（map）
`std::accumulate`	归约（reduce）
`std::sort`	排序
`std::find`, `find_if`	查找
`std::copy`, `fill`	拷贝/填充
`std::any_of`, `all_of`	条件判断

// 一行代码：所有元素平方和
float sum_sq = std::transform_reduce(
    v.begin(), v.end(), 0.0f,
    std::plus<>(),
    [](float x){ return x*x; }
);

实践	说明
✅ 优先使用 `std::vector` 而不是原生数组	RAII + 安全
✅ 优先使用 `const&` 传大对象	避免拷贝
✅ 优先使用 `auto`	减少类型错误
✅ 用 `make_shared` / `make_unique`	异常安全
✅ 用 `enum class` 而不是 `enum`	类型安全
✅ 用 `override` 标记虚函数	避免误重写
✅ 用 `[[nodiscard]]` 标记返回值不能忽略	防止 bug

C++11/14/17/20/23 Misc

if constexpr（C++17）：
- 编译时条件分支，用于模板编程。
std::optional/std::variant（C++17）：
- 替代 nullptr 和 int* 的安全方式。
- std::variant 用于类型安全的联合体。
std::string_view（C++17）：
- 轻量级字符串视图，避免不必要的拷贝。
[[nodiscard]]（C++17）：
- 强制检查函数返回值是否被丢弃。
consteval/constexpr if（C++20）：
- 编译期计算的强制要求。
模板与元编程
模板参数推导（C++17）：

template<typename T>
class MyVector {};
MyVector v = {1, 2, 3}; // 编译器自动推导 T=vector<int>

SFINAE（C++11/17）：
- 使用 std::enable_if 实现条件编译。
模板特化：
- 全特化与偏特化。
错误处理
异常安全（C++11/17）：
- noexcept、强异常安全保证。
错误码（C++11/17）：
- std::error_code, std::system_error。

Quartz 4

Explorer

资源管理

内存管理

一、RAII：资源管理的核心思想

RAII 的简单示例（手动实现）

二、C++ 内存管理的核心工具（基于 RAII）

1. 智能指针（Smart Pointers）（C++11）

2. 标准容器（自动管理内存）

三、C++ 内存管理的常见问题与 RAII 的解决

四、RAII 的扩展：管理非内存资源

总结

移动语义与值语义

1. 值语义 (Value Semantics)

核心概念

值语义的体现

值语义的优缺点

何时使用值语义

2. 移动语义 (Move Semantics) - C++11 引入

核心概念

关键概念：左值 (Lvalue) 和右值 (Rvalue)

移动语义的体现

`std::move` 的作用

移动语义的优缺点

值语义 Vs 移动语义：对比与选择

如何选择？

总结

高效编程

优先使用连续内存容器，减少缓存未命中

数据对齐与紧凑布局

减少函数调用开销：内联与避免过度封装

编译期计算：用 `constexpr` 减少运行时开销

零成本抽象（Zero-Cost Abstraction）

高效 C++ 编程必备工具

1. STL 容器

2. 算法库 `<algorithm>`

C++11/14/17/20/23 Misc

Graph View

Table of Contents

Backlinks

Quartz 4

Explorer

资源管理

内存管理

一、RAII：资源管理的核心思想

RAII 的简单示例（手动实现）

二、C++ 内存管理的核心工具（基于 RAII）

1. 智能指针（Smart Pointers）（C++11）

2. 标准容器（自动管理内存）

三、C++ 内存管理的常见问题与 RAII 的解决

四、RAII 的扩展：管理非内存资源

总结

移动语义与值语义

1. 值语义 (Value Semantics)

核心概念

值语义的体现

值语义的优缺点

何时使用值语义

2. 移动语义 (Move Semantics) - C++11 引入

核心概念

关键概念：左值 (Lvalue) 和 右值 (Rvalue)

移动语义的体现

std::move 的作用

移动语义的优缺点

值语义 Vs 移动语义：对比与选择

如何选择？

总结

高效编程

优先使用连续内存容器，减少缓存未命中

数据对齐与紧凑布局

减少函数调用开销：内联与避免过度封装

编译期计算：用 constexpr 减少运行时开销

零成本抽象（Zero-Cost Abstraction）

高效 C++ 编程必备工具

1. STL 容器

2. 算法库 <algorithm>

C++11/14/17/20/23 Misc

Graph View

Table of Contents

Backlinks

关键概念：左值 (Lvalue) 和右值 (Rvalue)

`std::move` 的作用

编译期计算：用 `constexpr` 减少运行时开销

2. 算法库 `<algorithm>`