在进行 STM32 嵌入式开发时，理解存储架构（Flash、SRAM、CCM RAM）及其访问特性是性能优化的基础。本文以 STM32F407 为例，总结其存储特性。

#地址空间映射

STM32F407 拥有 4GB 的线性地址空间，其内部存储器的分配如下表所示：

#Flash 等待周期与 ART 加速器

STM32F407 的主频最高可达 168MHz，而内部 Flash 的访问频率通常较低（约 30MHz）。为了匹配 CPU 的高速处理能力，意法半导体引入了 ART 加速器 (Adaptive Real-Time Accelerator)。

#1. 等待周期 (Wait States)

在不同的工作频率下，必须配置正确的等待周期（Latency）：

#2. ART 加速器原理

ART 加速器包含：

• 128位预取队列：每次从 Flash 读取 128 位数据（4 条指令）。
• 指令缓存 (I-Cache)：64 行 128 位缓存。
• 数据缓存 (D-Cache)：8 行 128 位缓存。

启用建议：在初始化系统时，务必开启加速器。

FLASH->ACR |= FLASH_ACR_ICEN | FLASH_ACR_DCEN | FLASH_ACR_PRFTEN | FLASH_ACR_LATENCY_5WS;

#CCM RAM：被忽视的性能利器

CCM (Core Coupled Memory) 直接连接到 CPU 的 D-Bus，访问延迟极低，非常适合存放：

• 任务栈 (Stack)
• 频繁调用的全局变量
• 关键算法代码 (需从 Flash 拷贝至此运行)

注意陷阱：CCM RAM 不经过总线矩阵，因此 DMA 控制器无法直接访问 CCM RAM。如果你将 DMA 缓冲区设置在 CCM 中，DMA 传输会直接失败。

#Flash 读写注意事项

#1. 扇区结构 (Sector Layout)

STM32F407 的 Flash 扇区大小不均匀（非对齐）：

• Sector 0-3: 16 KB
• Sector 4: 64 KB
• Sector 5-11: 128 KB

这种设计导致在将 Flash 当作 EEPROM 使用时，如果需要擦除 Sector 11，必须一次性擦除 128KB 数据，极其耗时且影响寿命。

#2. 写入规则

• 先擦后写：Flash 只能将位从 1 变为 0。写入前必须执行扇区擦除。
• 对齐要求：F4 系列通常支持 byte (8-bit), half-word (16-bit), word (32-bit), double word (64-bit) 写入，取决于供电电压。

#参考

1. STM32F4xx Reference Manual (RM0090)
2. Cortex-M4 Memory Map Guide

1. 修改监听IP

wsl2环境下，ollama安装后默认监听127.0.0.1，在docker运行的容器通过http://host.docker.internal:11434也无法访问，修改成监听0.0.0.0便可以访问了。

通过在服务配置中的增加环境变量OLLAMA_HOST进行修改（修改后需要重启服务）:

...
[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/local/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="OLLAMA_HOST=0.0.0.0:11434"

...

2. 日志查看

通过journalctl -u ollama -f可查看日志信息，环境变量中增加OLLAMA_DEBUG=1会输出更详细的日志信息，

#参考

1. https://docs.ollama.com/

C++11 是 C++ 程序设计语言标准的一个重要版本，于 2011 年由 ISO 正式发布，取代了原有的 C++98/03 标准。C++11 在核心语法、STL 标准模板库等方面增加了众多新功能，例如新增 nullptr、auto、decltype 关键字，引入 Lambda 表达式、std::array、std::forward_list、std::tuple 等容器，以及右值引用与移动语义等。下面将对这些新特性逐一总结。

#nullptr

nullptr 出现的目的是为了替代 NULL。

在某种意义上来说，传统 C++ 会把 NULL、0 视为同一种东西，这取决于编译器如何定义 NULL，有些编译器会将 NULL 定义为 ((void\*)0)，有些则会直接将其定义为 0。

C++ 不允许直接将 void * 隐式转换到其他类型，但如果 NULL 被定义为 ((void*)0)，那么当编译 char *ch = NULL; 时，NULL 只好被定义为 0。

而这依然会产生问题，将导致了 C++ 中重载特性会发生混乱，考虑：

void foo(char *);
void foo(int);

对于这两个函数来说，如果 NULL 被定义为了 0，那么 foo(NULL); 这个语句将会去调用 foo(int)，从而导致行为违反直觉。

为了解决这个问题，C++11 引入了 nullptr 关键字，专门用来区分空指针、0。

nullptr 的类型为 nullptr_t，能够隐式的转换为任何指针或成员指针的类型，也能和他们进行相等或者不等的比较。

当需要使用 NULL 时候，养成直接使用 nullptr的习惯。

#类型推导

C++11 引入了 auto 和 decltype 这两个关键字实现了类型推导，让编译器来操心变量的类型。

#auto关键字

auto 在很早以前就已经进入了 C++，但是他始终作为一个存储类型的指示符存在，与 register 并存。在传统 C++ 中，如果一个变量没有声明为 register 变量，将自动被视为一个 auto 变量。而随着 register 被弃用，对 auto 的语义变更也就非常自然了：可以让编译器自动分析初始值来判断变量所属的类型。当然，使用 auto 必须确定初始值。

使用 auto 进行类型推导的一个最为常见而且显著的例子就是迭代器。在以前我们需要这样来书写一个迭代器：

for(vector<int>::const_iterator itr = vec.cbegin(); itr != vec.cend(); ++itr)

而有了 auto 之后可以：

// 由于 cbegin() 将返回 vector<int>::const_iterator
// 所以 itr 也应该是 vector<int>::const_iterator 类型
for(auto itr = vec.cbegin(); itr != vec.cend(); ++itr) { /* ... */ }

一些其他的常见用法：

auto i = 5;             // i 被推导为 int
auto arr = new auto(10) // arr 被推导为 int *
auto a = make_shared<string>("hello world"); // a 被推导为 shared_ptr<string>

int add(auto x, auto y); // 错误：auto 不能用于函数参数

#include <iostream>

int main() {
    auto i = 5;

    int arr[10] = {0};
    auto auto_arr = arr;      // 合法，auto_arr 被推导为 int*
    auto auto_arr2[10] = arr; // 错误：auto 不能用于数组声明

    return 0;
}

#decltype关键字

decltype 关键字用于在编译时推导表达式的类型，而不会实际计算表达式的值。它的用法和 sizeof 很相似：

decltype(表达式)

例如：

auto x = 1;
auto y = 2;
decltype(x + y) z; // z 的类型被推导为 int

变量 x 和 y 的类型都为 int，让编译器通过推断括号里的表达式来判断 z 的类型。我们很容易得出 z 的类型也为 int。

#拖尾返回类型、auto 与 decltype 配合

你可能会思考，auto 能不能用于推导函数的返回类型。考虑这样一个例子加法函数的例子，在传统 C++ 中我们必须这么写（T 和 U 可能是不同类型）：

template<typename R, typename T, typename U>
R add(T x, U y) {
    return x + y;
}

这样的代码其实变得很丑陋，因为程序员在使用这个模板函数的时候，必须明确指出返回类型。但事实上我们并不知道 add() 这个函数会做什么样的操作，获得一个什么样的返回类型。

在 C++11 中这个问题得到解决。虽然你可能马上回反应出来使用 decltype 推导 x+y 的类型，写出这样的代码：

decltype(x + y) add(T x, U y); // 错误：x 和 y 尚未定义

但事实上这样的写法并不能通过编译。这是因为在编译器读到 decltype(x+y) 时，x 和 y 尚未被定义。为了解决这个问题，C++11 还引入了一个叫做拖尾返回类型（trailing return type），利用 auto 关键字将返回类型后置：

template<typename T, typename U>
auto add(T x, U y) -> decltype(x + y) {
    return x + y;
}

从 C++14 开始是可以直接让普通函数具备返回值推导，因此下面的写法变得合法：

template<typename T, typename U>
auto add(T x, U y) {
    return x + y;
}

#区间迭代 - 基于范围的 for 循环

C++11 引入了基于范围的迭代写法，我们拥有了能够写出像 Python 一样简洁的循环语句。 最常用的 std::vector 遍历将从原来的样子：

std::vector<int> arr(5, 100);
for(std::vector<int>::iterator i = arr.begin(); i != arr.end(); ++i) {
    std::cout << *i << std::endl;
}

变得非常的简单：

for(auto i : arr) {
    std::cout << i << std::endl;
}

#初始化列表

在传统 C++ 中，不同的对象有着不同的初始化方法，例如普通数组、POD （plain old data，没有构造、析构和虚函数的类或结构体）类型都可以使用 {} 进行初始化，也就是我们所说的初始化列表。而对于类对象的初始化，要么需要通过拷贝构造函数、要么就需要使用 () 进行。这些不同方法都针对各自对象。在传统C++中可以使用初始化列表如下：

// 普通数组
int i_arr[3] = { 1, 2, 3 };

// POD类型：结构体
struct A
{
    int x;
    struct B
    {
        int i;
        int j;
    } b;
} a = { 1, { 2, 3 } };

// 拷贝初始化（copy-initialization）
int i = 0;
class Foo
{
    public:
    Foo(int) {}
    Foo(const Foo &);
} foo = 123;  // 需要拷贝构造函数

// 直接初始化：使用 () 进行
int j(0);
Foo bar(123);

为了统一初始化方式，并且让初始化行为具有确定的效果，C++11 中提出了列表初始化（List-initialization）的概念。

C++11 首先把初始化列表的概念绑定到了类型上，并将其称之为 initializer_list，允许构造函数或其他函数像参数一样使用初始化列表，这就为类对象的初始化与普通数组和 POD 的初始化方法提供了统一的桥梁。可以拿个类模板 initializer_list 作为构造函数的参数，则初始化列表就智能用于构造该函数。值得注意的是列表中的元素必须是同一种类型或者可以转化为同一种类型。

【实例】通过初始化列表初始化对象。

class Foo
{
public:
    Foo(int) {}
private:
    Foo(const Foo &);
};

int main(void)
{
    // 调用Foo(int)构造函数初始化（c++98编译通过 c++11编译通过）
    Foo a1(123);
    // 报错：Foo的拷贝构造函数声明为私有的，该语句属于拷贝初始化，语义上需要拷贝构造函数参与，因此私有拷贝构造会导致编译错误（即使实际可能被优化掉）
    Foo a2 = 123;

    // 列表初始化（c++98编译失败 c++11编译通过）
    Foo a3 = { 123 };
    // 列表初始化（c++98编译失败 c++11编译通过）
    Foo a4 { 123 };

    // 列表初始化（C++98 编译通过，C++11 编译通过）
    int a5 = { 3 };
    // 列表初始化（C++98 编译失败，C++11 编译通过）
    int a6 { 3 };

    return 0;
}

在上例中，a3、a4 使用了新的初始化方式来初始化对象，效果如同 a1 的直接初始化。a5、a6 则是基本数据类型的列表初始化方式。可以看到，它们的形式都是统一的。

这里需要注意的是，a3 虽然使用了等于号，但它仍然是列表初始化，语义上需要拷贝构造函数。但在实际编译器（如 g++）中，由于 copy elision 优化，可能不会报错。

a4 和 a6 的写法，是 C++98/03 所不具备的。在 C++11 中，可以直接在变量名后面跟上初始化列表，来进行对象的初始化。

同时列表初始化方法也适用于用new操作等圆括号进行初始化的地方，如下：

int* a = new int { 123 };
double b = double { 12.12 };
int* arr = new int[3] { 1, 2, 3 };

让人惊奇的是在 C++11 中可以使用列表初始化方法对堆中分配的内存的数组进行初始化，而在 C++98/03 中是不能这样做的。

#模板增强

#外部模板

传统 C++ 中，模板只有在使用时才会被编译器实例化。只要在每个编译单元（文件）中编译的代码中遇到了被完整定义的模板，都会实例化。这就产生了重复实例化而导致的编译时间的增加。并且，我们没有办法通知编译器不要触发模板实例化。

C++11 引入了外部模板，扩充了原来的强制编译器在特定位置实例化模板的语法，使得能够显式的告诉编译器何时进行模板的实例化：

template class std::vector<bool>;            // 强行实例化
extern template class std::vector<double>;  // 不在该编译文件中实例化模板

#尖括号 “>”

在传统 C++ 的编译器中，>> 一律被当做右移运算符来进行处理。但实际上我们很容易就写出了嵌套模板的代码：

std::vector<std::vector<int>> wow;

这在传统C++编译器下是不能够被编译的，而 C++11 开始，连续的右尖括号将变得合法，并且能够顺利通过编译。

#类型别名模板

在传统 C++ 中，typedef 可以为类型定义一个新的名称，但是却没有办法为模板定义一个新的名称。因为，模板不是类型。例如：

template<typename T, typename U, int value>

class SuckType
{
public:
    T a;
    U b;
    SuckType()
        : a(value)
        , b(value) {}
};

template<typename U> typedef SuckType<std::vector<int>, U, 1> NewType;   // 不合法

C++11 使用 using 引入了下面这种形式的写法，并且同时支持对传统 typedef 相同的功效：

template <typename T>
using NewType = SuckType<int, T, 1>;    // 合法

#默认模板参数

我们可能定义了一个加法函数：

template<typename T, typename U>
auto add(T x, U y) -> decltype(x+y) {
    return x+y
}

但在使用时发现，要使用 add，就必须每次都指定其模板参数的类型。 在 C++11 中提供了一种便利，可以指定模板的默认参数：

template<typename T = int, typename U = int>
auto add(T x, U y) -> decltype(x + y) {
    return x + y;
}

#构造函数

#委托构造

C++11 引入了委托构造的概念，这使得构造函数可以在同一个类中一个构造函数调用另一个构造函数，从而达到简化代码的目的：

class Base {
public:
    int value1;
    int value2;
    Base() {
        value1 = 1;
    }
    Base(int value) : Base() {  // 委托 Base() 构造函数
        value2 = 2;
    }
};

#继承构造

在继承体系中，如果派生类想要使用基类的构造函数，需要在构造函数中显式声明。 假若基类拥有为数众多的不同版本的构造函数，这样，在派生类中得写很多对应的“透传”构造函数。如下：

struct A
{
  A(int i) {}
  A(double d,int i) {}
  A(float f,int i,const char* c) {}
  // ...等等系列的构造函数版本
};

struct B:A
{
  B(int i):A(i) {}
  B(double d,int i):A(d,i) {}
  B(float f,int i,const char* c):A(f,i,c) {}
  // ......等等好多个和基类构造函数对应的构造函数
};

C++11的继承构造：

struct A
{
  A(int i) {}
  A(double d,int i){}
  A(float f,int i,const char* c){}
  // ...等等系列的构造函数版本
};

struct B:A
{
  using A::A;
  // 关于基类各构造函数的继承一句话搞定
  // ......
};

如果一个继承构造函数不被相关的代码使用，编译器不会为之产生真正的函数代码，这样比透传基类各种构造函数更加节省目标代码空间。

#Lambda表达式

C++11 新标准新增的一项重要功能就是 lambda 表达式，所谓 Lambda 表达式实际上就是提供了一个类似匿名函数的特性，而匿名函数则是在需要一个函数，但是又不想费力去命名一个函数的情况下去使用的。

Lambda 的组成结构与函数很相似，它拥有一个返回类型，一个形参列表，一个函数体。Lambda 也可以定义在函数内部。它的组成结构如下：

[capture list] (parameter list) option -> return type { function body}

• capture list 表示捕获列表，也就是 lambda 所在函数中的局部变量的列表，如果没有，则这个列表为空。

  • [] 不捕获任何变量。

  • [&] 捕获外部作用域中所有变量，并作为引用在函数体中使用（按引用捕获）。

  • [=] 捕获外部作用域中所有变量，并作为副本在函数体中使用(按值捕获)。注意值捕获的前提是变量可以拷贝，且被捕获的变量在 lambda 表达式被创建时拷贝，而非调用时才拷贝。如果希望 lambda 表达式在调用时能即时访问外部变量，我们应当使用引用方式捕获。

    int a = 0;
    auto f = [=] { return a; };
    a += 1;
    cout << f() << endl; // 输出0
    
    int a = 0;
    auto f = [&a] { return a; };
    a += 1;
    cout << f() <<endl; // 输出1

  • [=,&foo] 按值捕获外部作用域中所有变量，并按引用捕获 foo 变量。

  • [bar] 按值捕获 bar 变量，同时不捕获其他变量。

  • [this] 捕获当前类中的 this 指针，让 lambda 表达式拥有和当前类成员函数同样的访问权限。如果已经使用了 & 或者 =，就默认添加此选项。捕获 this 的目的是可以在 lamda 中使用当前类的成员函数和成员变量。

class A
{
 public:
     int i_ = 0;

     void func(int x,int y){
         auto x1 = [] { return i_; };                   // error,没有捕获外部变量
         auto x2 = [=] { return i_ + x + y; };          // OK
         auto x3 = [&] { return i_ + x + y; };        // OK
         auto x4 = [this] { return i_; };               // OK
         auto x5 = [this] { return i_ + x + y; };       // error,没有捕获x,y
         auto x6 = [this, x, y] { return i_ + x + y; };     // OK
         auto x7 = [this] { return i_++; };             // OK
	}
};

int a=0 , b=1;
auto f1 = [] { return a; };                         // error,没有捕获外部变量
auto f2 = [&] { return a++ };                      // OK
auto f3 = [=] { return a; };                        // OK
auto f4 = [=] {return a++; };                       // error,a是以复制方式捕获的，无法修改
auto f5 = [a] { return a+b; };                      // error,没有捕获变量b
auto f6 = [a, &b] { return a + (b++); };                // OK
auto f7 = [=, &b] { return a + (b++); };                // OK

• Parameter list 为形参列表。（选填）
• option 是函数选项；可以填 mutable,exception,attribute。（选填）
  • mutable说明lambda表达式体内的代码可以修改被捕获的变量，并且可以访问被捕获的对象的non-const方法。
  • exception说明lambda表达式是否抛出异常以及何种异常。
  • attribute用来声明属性。
  • return type 表示该 lambda 的返回类型。（选填）
• Function body 是函数体，这些和函数表示是一样的。

需要注意的是，如果有返回类型，lambda 必须使用尾置返回来确定类型。另外，lambda 必须包括捕获列表和函数体。另外的几个可以省略。例如：

auto fun = [] {return 1;};
cout << fun() << endl; // 输出：1

int a = 0;
auto f = [=] { return a; };
a += 1;
cout << f() << endl; // 输出0

int a = 0;
auto f = [&a] { return a; };
a += 1;
cout << f() <<endl; // 输出1

我们定义了一个名为 fun 的 lambda 表达式。它只有捕获列表和函数体。这个 lambda 表达式返回值为 1 之后。我们调用这个 lambda，会输出 1。

虽然按值捕获的变量值均复制一份存储在lambda表达式变量中，修改他们也并不会真正影响到外部，但我们却仍然无法修改它们。如果希望去修改按值捕获的外部变量，需要显示指明 lambda 表达式为 mutable。被 mutable 修饰的 lambda 表达式就算没有参数也要写明参数列表。

原因：lambda 表达式可以说是就地定义仿函数闭包的“语法糖”。它的捕获列表捕获住的任何外部变量，最终会变为闭包类型的成员变量。按照 C++ 标准，lambda 表达式的operator() 默认是 const 的，一个 const 成员函数是无法修改成员变量的值的。而 mutable 的作用，就在于取消 operator() 的 const。

int a = 0;
auto f1 = [=] { return a++; };                // error
auto f2 = [=] () mutable { return a++; };       // OK

lambda表达式的大致原理：每当你定义一个 lambda 表达式后，编译器会自动生成一个匿名类（这个类重载了()运算符），我们称为闭包类型（closure type）。那么在运行时，这个 lambda 表达式就会返回一个匿名的闭包实例，是一个右值。所以，我们上面的 lambda 表达式的结果就是一个个闭包。对于复制传值捕捉方式，类中会相应添加对应类型的非静态数据成员。在运行时，会用复制的值初始化这些成员变量，从而生成闭包。对于引用捕获方式，无论是否标记 mutable，都可以在 lambda 表达式中修改捕获的值。至于闭包类中是否有对应成员，C++ 标准中给出的答案是：不清楚的，与具体实现有关。

lambda 表达式是不能被赋值的：

auto a = [] { cout << "A" << endl; };
auto b = [] { cout << "B" << endl; };

a = b;   // 非法，lambda无法赋值
auto c = a;   // 合法，生成一个副本

闭包类型禁用了赋值操作符，但是没有禁用复制构造函数，所以你仍然可以用一个 lambda 表达式去初始化另外一个 lambda 表达式而产生副本。

在多种捕获方式中，最好不要使用 [=] 和 [&] 默认捕获所有变量。

默认引用捕获所有变量，你有很大可能会出现悬挂引用（Dangling references），因为引用捕获不会延长引用的变量的生命周期：

std::function<int(int)> add_x(int x)
{
    return [&](int a) { return x + a; };
}

上面函数返回了一个 lambda 表达式，参数 x 仅是一个临时变量，函数 add_x 调用后就被销毁了，但是返回的 lambda 表达式却引用了该变量，当调用这个表达式时，引用的是一个垃圾值，会产生没有意义的结果。上面这种情况，使用默认传值方式可以避免悬挂引用问题。

lambda 表达式可以赋值给对应类型的函数指针。但是使用函数指针并不是那么方便。所以 STL 定义在 < functional > 头文件提供了一个多态的函数对象封装 std::function，其类似于函数指针。它可以绑定任何类函数对象，只要参数与返回类型相同。如下面的返回一个 bool 且接收两个 int 的函数包装器：

std::function<bool(int, int)> wrapper = [](int x, int y) { return x < y; };

lambda 表达式一个更重要的应用是其可以用于函数的参数，通过这种方式可以实现回调函数。

最常用的是在 STL 算法中，比如你要统计一个数组中满足特定条件的元素数量，通过 lambda 表达式给出条件，传递给 count_if 函数：

int value = 3;
vector<int> v {1, 3, 5, 2, 6, 10};
int count = std::count_if(v.begin(), v.end(), [value](int x) { return x > value; });

就可以返回 vector 中值大于 3 的元素数量。

当需要遍历容器并对每个元素进行操作时：

std::vector<int> v = { 1, 2, 3, 4, 5, 6 };
int even_count = 0;
for_each(v.begin(), v.end(), [&even_count](int val){
    if(!(val & 1)){
        ++ even_count;
    }
});
std::cout << "The number of even is " << even_count << std::endl;

大部分 STL 算法，可以非常灵活地搭配 lambda 表达式来实现想要的效果。

#新增容器

#std::array

std::array 保存在栈内存中，相比堆内存中的 std::vector，我们能够灵活的访问这里面的元素，从而获得更高的性能。

std::array 会在编译时创建一个固定大小的数组，std::array 不能够被隐式的转换成指针，使用 std::array只需指定其类型和大小即可：

std::array<int, 4> arr= {1,2,3,4};

int len = 4;
std::array<int, len> arr = {1,2,3,4}; // 非法, 数组大小参数必须是常量表达式1234

当我们开始用上了 std::array 时，难免会遇到要将其兼容 C 风格的接口，这里有三种做法：

void foo(int *p, int len) {
    return;
}

std::array<int, 4> arr = {1,2,3,4};

// C 风格接口传参
// foo(arr, arr.size());           // 非法, 无法隐式转换
foo(&arr[0], arr.size());
foo(arr.data(), arr.size());

// 使用 `std::sort`
std::sort(arr.begin(), arr.end());

#std::forward_list

std::forward_list 是一个列表容器，使用方法和 std::list 基本类似。 和 std::list 的双向链表的实现不同，std::forward_list 使用单向链表进行实现，提供了 O(1) 复杂度的元素插入，不支持快速随机访问（这也是链表的特点），也是标准库容器中唯一一个不提供 size() 方法的容器。当不需要双向迭代时，具有比 std::list更高的空间利用率。

#无序容器

C++11 引入了两组无序容器： std::unordered_set/std::unordered_multiset 和 std::unordered_map/std::unordered_multimap。 无序容器中的元素是不进行排序的，内部通过 Hash 表实现，插入和搜索元素的平均复杂度为 O(1)。

#元组 std::tuple

元组的使用有三个核心的函数：

• std::make_tuple: 构造元组
• std::get: 获得元组某个位置的值
• std::tie: 元组拆包

#include <tuple>
#include <iostream>

auto get_student(int id)
{
    // 返回类型被推断为 std::tuple<double, char, std::string>
    if (id == 0)
        return std::make_tuple(3.8, 'A', "张三");
    if (id == 1)
        return std::make_tuple(2.9, 'C', "李四");
    if (id == 2)
        return std::make_tuple(1.7, 'D', "王五");
    return std::make_tuple(0.0, 'D', "null");
    // 如果只写 0 会出现推断错误, 编译失败
}

int main()
{
    auto student = get_student(0);
    std::cout << "ID: 0, "
    << "GPA: " << std::get<0>(student) << ", "
    << "成绩: " << std::get<1>(student) << ", "
    << "姓名: " << std::get<2>(student) << '\n';

    double gpa;
    char grade;
    std::string name;

    // 元组进行拆包
    std::tie(gpa, grade, name) = get_student(1);
    std::cout << "ID: 1, "
    << "GPA: " << gpa << ", "
    << "成绩: " << grade << ", "
    << "姓名: " << name << '\n';
}

合并两个元组，可以通过 std::tuple_cat 来实现。

auto new_tuple = std::tuple_cat(get_student(1), std::move(t));

#正则表达式

C++11 提供了正则表达式库，用于操作 std::string 对象，对模式 std::regex (本质是 std::basic_regex)进行初始化，通过 std::regex_match 进行匹配，从而产生 std::smatch （本质是 std::match_results 对象）。

我们通过一个简单的例子来简单介绍这个库的使用。考虑下面的正则表达式：

[a-z]+.txt: 在这个正则表达式中, [a-z] 表示匹配一个小写字母, + 可以使前面的表达式匹配多次，因此 [a-z]+ 能够匹配一个及以上小写字母组成的字符串。在正则表达式中一个 . 表示匹配任意字符，而 . 转义后则表示匹配字符 . ，最后的 txt 表示严格匹配 txt 这三个字母。因此这个正则表达式的所要匹配的内容就是文件名为纯小写字母的文本文件。

std::regex_match用于匹配字符串和正则表达式，有很多不同的重载形式。最简单的一个形式就是传入std::string以及一个std::regex进行匹配，当匹配成功时，会返回 true，否则返回 false。例如：

#include <iostream>
#include <string>
#include <regex>

int main() {
    std::string fnames[] = {"foo.txt", "bar.txt", "test", "a0.txt", "AAA.txt"};
    // 在 C++ 中 `\` 会被作为字符串内的转义符，为使 `\.` 作为正则表达式传递进去生效，需要对 `\` 进行二次转义，从而有 `\\.`
    std::regex txt_regex("[a-z]+\\.txt");
    for (const auto &fname: fnames)
        std::cout << fname << ": " << std::regex_match(fname, txt_regex) << std::endl;
}

另一种常用的形式就是依次传入std::string/std::smatch/std::regex三个参数，其中 std::smatch 的本质其实是 std::match_results，在标准库中， std::smatch 被定义为了 std::match_results，也就是一个子串迭代器类型的 match_results。使用 std::smatch 可以方便的对匹配的结果进行获取，例如：

std::regex base_regex("([a-z]+)\\.txt");
std::smatch base_match;
for(const auto &fname: fnames) {
    if (std::regex_match(fname, base_match, base_regex)) {
        // sub_match 的第一个元素匹配整个字符串
        // sub_match 的第二个元素匹配了第一个括号表达式
        if (base_match.size() == 2) {
            std::string base = base_match[1].str();
            std::cout << "sub-match[0]: " << base_match[0].str() << std::endl;
            std::cout << fname << " sub-match[1]: " << base << std::endl;
        }
    }
}

以上两个代码段的输出结果为：

foo.txt: 1
bar.txt: 1
test: 0
a0.txt: 0
AAA.txt: 0

sub-match[0]: foo.txt
foo.txt sub-match[1]: foo
sub-match[0]: bar.txt
bar.txt sub-match[1]: bar

#语言级线程支持

std::thread
std::mutex/std::unique_lock
std::future/std::packaged_task
std::condition_variable

代码编译需要使用 -pthread 选项。

#右值引用和move语义

c++11 引入了右值引用和移动语义，为了避免无谓的复制，提高程序性能。

#左值、右值

C++ 中所有的值都必然属于左值、右值二者之一。左值是指表达式结束后依然存在的持久化对象，右值是指表达式结束时就不再存在的临时对象。所有的具名变量或者对象都是左值，而右值不具名。很难得到左值和右值的真正定义，但是有一个可以区分左值和右值的便捷方法：看能不能对表达式取地址，如果能，则为左值，否则为右值。

int a = 5; // a是左值， 5是右值
a = b; // a、b 都是左值，只不过将 b 可以当做右值使用

#左值引用、右值引用

C++98 的引用很常见了，就是给变量取了个别名，在 C++11 中，因为增加了右值引用(rvalue reference)的概念，所以 C++98 中的引用都称为了左值引用(lvalue reference)。

// C++98
int a = 10;
int& refA = a; // refA 是 a 的别名，修改 refA 就是修改 a
               // a 是左值，&refA 是左值引用

int& b = 1; // 编译错误！1 是右值，不能使用左值引用

C++11 中的右值引用使用 && 表示：

int&& a = 1;       // 合法，将不具名(匿名)变量取了个别名
int b = 1;
int&& c = b;       // 编译错误！不能将一个左值绑定到一个右值引用

class A {
  public:
    int a;
};
A getTemp()
{
    return A();
}

A && a = getTemp();   //getTemp()的返回值是右值（临时变量）

getTemp()返回的右值本来在表达式语句结束后，其生命也就该终结了（因为是临时变量），而通过右值引用，该右值又重获新生，其生命期将与右值引用类型变量a的生命期一样，只要a还活着，该右值临时变量将会一直存活下去。实际上就是给那个临时变量取了个名字。

所以，左值引用只能绑定左值，右值引用只能绑定右值，如果绑定的不对，编译就会失败。但是，常量左值引用却是个奇葩，它可以算是一个“万能”的引用类型，它可以绑定非常量左值、常量左值、右值，而且在绑定右值的时候，常量左值引用还可以像右值引用一样将右值的生命期延长，缺点是，只能读不能改。

const int & a = 1; // 常量左值引用绑定 右值， 不会报错

class A {
  public:
    int a;
};
A getTemp()
{
    return A();
}

const A & a = getTemp();   // 不会报错 而 A& a 会报错

#加入右值引用的目的

个人认为右值引用的目的主要是为了是减少内存拷贝，优化性能。比如下面的代码：

String Fun()
{
    String str = "hello world";
    return str;
}

str 为临时对象，然后调用 String 的拷贝构造函数，将临时对象的值赋值给 String，这种拷贝是完全没有必要的，如果堆内存很大，那么这个拷贝构造的代价会很大，带来了额外的性能损耗。

为了避免临时对象的拷贝构造，我们可以使用移动语义来实现：

MyString& operator=(MyString&& other)
{
    cout << "MyString& operator=(const MyString&& other)" << endl;
    if (this != &other)
    {
        m_nLen = other.m_nLen;
        m_pData = other.m_pData;
        other.m_pData = NULL;
    }

    return *this;
}

我们没有深度拷贝堆内存中的数据，而是仅仅复制了指针，并把源对象 other 的指针置空。事实上，我们“偷取”了属于源对象 other 的内存数据。由于源对象 other 是一个右值，不会再被使用，因此客户并不会觉察到源对象被改变了。在这里，我们并没有真正的复制，所以我们把这个构造函数叫做“转移构造函数”（move constructor），他的工作就是把资源从一个对象转移到另一个对象，而不是复制他们，这样就能避免内存拷贝带来的额外性能消耗。

#std::bind 函数

C++11 引入了新的标准库函数 bind，std::bind 函数定义在头文件 functional 中，是一个函数模板，它就像一个函数适配器，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。

std::bind 将可调用对象与其参数一起进行绑定，绑定后的结果可以使用 std::function 保存。std::bind 主要有以下两个作用：

将可调用对象和其参数绑定成一个仿函数； 只绑定部分参数，减少可调用对象传入的参数。 std::bind 函数有两种函数原型，定义如下：

template <class F, class... Args>
/* unspecified */ bind (Fn&& f, Args&&... args);

template <class Ret, class F, class... Args>
/* unspecified */ bind (Fn&& f, Args&&... args);

参数说明：

• f：一个可调用对象（可以是函数对象、函数指针、函数引用、成员函数指针、数据成员指针），它的参数将被绑定到 args 上。
• args：绑定参数列表，参数会被值或占位符（std::placeholders）替换，其长度必须与 f 接收的参数个数一致。

#std::bind绑定普通函数

double my_divide (double x, double y) {return x/y;}
auto fn_half = std::bind (my_divide,_1,2);
std::cout << fn_half(10) << '\n';                        // 5

• bind 的第一个参数是函数名，普通函数做实参时，会隐式转换成函数指针。因此std::bind (my_divide,_1,2)等价于std::bind (&my_divide,_1,2)；
• _1表示占位符，位于 <functional> 中：std::placeholders::_1;

#std::bind绑定一个成员函数

struct Foo {
    void print_sum(int n1, int n2)
    {
        std::cout << n1+n2 << '\n';
    }
    int data = 10;
};

int main()
{
    Foo foo;
    auto f = std::bind(&Foo::print_sum, &foo, 95, std::placeholders::_1);
    f(5); // 100
}

bind 绑定类成员函数时，第一个参数表示对象的成员函数的指针，第二个参数表示对象的地址。 必须显示的指定 &Foo::print_sum，因为编译器不会将对象的成员函数隐式转换成函数指针，所以必须在 Foo::print_sum 前添加 &； 使用对象成员函数的指针时，必须要知道该指针属于哪个对象，因此第二个参数为对象的地址 &foo；

#std :: function 类模板

类模板 std :: function 是一个通用的多态函数包装器。 std :: function 的实例可以存储，复制和调用任何可调用的目标 ：包括函数，lambda 表达式，绑定表达式或其他函数对象，以及指向成员函数和指向数据成员的指针。当 std::function 对象未包裹任何实际的可调用元素，调用该 std::function 对象将抛出 std::bad_function_call 异常。

原型如下：

template< class R, class... Args >
class function<R(Args...)>;

例如：std::function<int(int,int)> func;则 function 类的实例 func 可以指向返回值为 int 型，有两个形参都为 int 型的函数。

#include <functional>
#include <iostream>

int f(int a, int b)
{
    return a + b;
}

int main()
{
    std::function<int(int, int)> func = f;
    std::cout << func(1, 2) << std::endl; // 3
    return 0;
}

我们再来先来看看以前 C 和 C++98 的用法：

#include <iostream>

// C 风格函数
int c_func(int a, int b)
{
    return a + b;
}

// 函数对象
struct functor
{
public:
    int operator() (int a, int b)
    {
        return a + b;
    }
};

int main()
{
    typedef int (*Func)(int, int);
    Func func = c_func;
    std::cout << func(1, 2) << std::endl; // 3

    functor ft;
    std::cout << ft(1, 2) << std::endl; // 3
    return 0;
}

从上面我们可以看出，使用 C++11 的 function 类调用函数方便多了。

#Linux自动挂载硬盘并共享

记录linux下自动挂载硬盘，并通过smb共享到网络中。

#自动挂载

1. blkid查看 UUID

   korbin@pi:~ $ blkid
   /dev/mmcblk0p1: LABEL_FATBOOT="bootfs" LABEL="bootfs" UUID="F587-071F" BLOCK_SIZE="512" TYPE="vfat" PARTUUID="7d559f21-01"
   /dev/mmcblk0p2: LABEL="rootfs" UUID="d6944274-f2f7-4644-96a4-213c3b367f5c" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="7d559f21-02"
   /dev/loop0: TYPE="swap"
   /dev/sda1: UUID="5a9e8d37-1d53-45d1-b724-2695d70477f0" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="075b7ae2-de80-4a87-8c01-f028b9ad8cf0"
   /dev/zram0: LABEL="zram0" UUID="a7f80131-092f-412c-ae98-dec1724993ed" TYPE="swap"

2. 修改 /etc/fstab实现启动自动挂载

   sudo mkdir /mnt/disk1
   sudo echo "UUID=5a9e8d37-1d53-45d1-b724-2695d70477f0  /mnt/disk1  ext4  defaults  0  0" >> /etc/fstab

#smb共享

1. 安装 samba

   sudo apt install samba
2. 配置 smb共享

   [disk1]
      comment = Public Shared Data
      available = yes
      valid users = frey
      path = /mnt/disk1
      browseable = yes
      writeable = yes
      guest ok = no
      create mask = 0664
      directory mask = 0755
      force user = frey
3. 重启 smb服务

   sudo systemctl restart smb.service

va_list是 C 语言专门用来解决可变参数问题的工具，于 C99 标准引入， va_list 类型允许函数接受可变数量的参数，这在编写需要处理不定数量参数的函数时非常有用。va_list 类型是在 stdarg.h 头文件中定义的，它允许函数处理可变数量的参数。下面我们将详细介绍 va_list 的用法以及实际应用示例。

#va_list的用法

va_list 是一个指向参数列表的指针，它允许函数处理不定数量的参数。va_list 类型通常与 va_start、va_arg 和 va_end一起使用。

• va_list：初始化 va_list类型的变量，使其指向参数列表的起始位置。
• va_arg：获取参数列表中的下一个参数，并将指针移动到下一个参数。
• va_end：清理 va_list 类型的变量。

#应用举例

#计算总和

#include <stdarg.h>
#include <stdio.h>

int sum(int count, ...)
{
    int     sum = 0;
    va_list ap;
    va_start(ap, count);
    while (count--) sum += va_arg(ap, int);
    va_end(ap);
    return sum;
}

int main()
{
    printf("sum(5,1,2,3,4,5):%d\n", sum(5, 1, 2, 3, 4, 5));
    printf("sum(3,10,20,30):%d\n", sum(3, 10, 20, 30));
}

在上面的例子中， sum 函数通过固定参数 count 指定后续可变参数的数量，使用 va_start 初始化参数列表，在循环中用 va_arg 依次按 int 类型取出每个参数并累加计算结果。类似可以用于计算最大值、最小值、平均数等。编译输出结果如下：

❯ gcc main.c && ./a.out
sum(5,1,2,3,4,5):15
sum(3,10,20,30):60

#日志格式化

void log_debug(char *format, ...)
{
    char    buf[100];
    va_list ap;
    va_start(ap, format);
    vsprintf(buf, format, ap);
    va_end(ap);

    extern void uart_write(char *buf, int len);
    uart_write(buf, strlen(buf));
}

int main()
{
    int number = 10;
    log_debug("%s %c %d %02X\n", "test", 'C', number, number);
}

上面的例子，配合 vsprintf，在单片机开发中，可以方便的进行日志输出打印。

#参考

1. 标准库头文件 stdarg.h - cppreference.cn - C++参考手册
2. 有关 va_list 的一些笔记 | bachzart's Blog

记录如何通过命令行对Nginx日志进行简单分析，日志格式为：

log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

1. 统计所有请求的总数（PV）

   awk '{print $1}' /var/log/nginx/access.log | wc -l

2. 统计独立IP的访问数量（UV）

   awk '{print $1}' /var/log/nginx/access.log | sort | uniq | wc -l

3. 按IP访问次数排序，显示前100个

   awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -n 100

4. 查看访问最频繁的页面（前50名）

   awk '{print $7}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -n 50

5. 排除静态资源（如JS、CSS）后，查看最频繁页面

   grep -vE '.js|.css|.ico' /var/log/nginx/access.log | awk '{print $7}' | sort | uniq -c | sort -rn | head -n 50

6. 统计每秒请求数，显示Top 100时间点

   awk '{print $4}' /var/log/nginx/access.log | cut -c 14-21 | sort | uniq -c | sort -rn | head -n 100

7. 列出传输时间超过3秒的页面（前20条）

   awk '($NF > 3){print $7}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -20

FreeRTOS 将内存管理与内核分离，通过统一的 pvPortMalloc() 和 vPortFree() 接口实现多种可选的堆管理算法（heap_1 ~ heap_5），以适配不同嵌入式场景。

核心原则：

• 动态分配：运行时按需申请/释放内存，灵活但需控制碎片化与实时性。
• 静态分配：编译期固定内存，可靠但利用率低。
• 线程安全：FreeRTOS 内存 API 会在分配/释放时挂起调度器，避免并发冲突。

五种内存管理实现（位于 Source/Portable/MemMang，工程中只能选择一个）：

1. heap_1 仅支持分配，不支持释放，执行时间固定，无碎片。 适合启动时一次性创建对象且不删除的系统。
2. heap_2 支持释放，但不合并相邻空闲块，易产生碎片。 适合分配/释放大小固定的对象。
3. heap_3 封装 malloc/free，保证线程安全。 依赖编译器堆设置，非确定性，可能增大代码体积。
4. heap_4 最常用，支持释放并合并相邻空闲块，减少碎片。 适合随机大小分配/释放的应用。
5. heap_5 基于 heap_4，支持多个不连续内存区域（如片内 RAM + 外部 SDRAM）。 需先调用 vPortDefineHeapRegions() 初始化区域。

典型使用示例（heap_4）：

#include "FreeRTOS.h"
#include "task.h"
#include <stdio.h>
void *ptr = NULL;
void mem_test(void) {
   size_t free_before = xPortGetFreeHeapSize();
   printf("申请前剩余内存: %u 字节\n", free_before);
   ptr = pvPortMalloc(1024);
   if (ptr) {
       printf("申请成功, 地址: %p\n", ptr);
       sprintf((char*)ptr, "Tick=%u", xTaskGetTickCount());
   }
   size_t free_after = xPortGetFreeHeapSize();
   printf("申请后剩余内存: %u 字节\n", free_after);
   vPortFree(ptr);
   printf("释放后剩余内存: %u 字节\n", xPortGetFreeHeapSize());
}

要点：

• 使用 xPortGetFreeHeapSize() 监控剩余堆空间。
• 对 heap_5，需先定义内存区域数组并调用 vPortDefineHeapRegions()。
• 对实时性要求高的系统，建议选用 heap_1 或静态分配，避免碎片化和不确定延迟。

总结一下在Linux终端中进行命令输入、编辑的一些技巧

#参考

1. Linux命令大全搜索工具 (jaywcjlove.github.io)
2. Linux命令大全(手册) (linuxcool.com)
3. MAN手册 - 中文 (debian.org)
4. Linux 命令行速查表 (cheat-sheet.cn)

当 WSL 报错 createinstance/createvm/configurenetworking/0x8007054f 并提示无法配置网络时，通常是由于网络服务或系统配置问题导致的。以下是解决此问题的步骤。

wsl: 出现了内部错误。
错误代码: createinstance/createvm/configurenetworking/0x8007054f
wsl: 无法配置网络 (networkingmode mirrored)，回退到 networkingmode none。

#解决方法

#重启 HNS 服务

在管理员模式下运行 PowerShell，重启 Host Network Service (HNS) 服务。

wsl --shutdown
net stop hns
net start hns

#重置 WSL 网络配置

如果问题仍然存在，可以尝试重置网络堆栈。

netsh winsock reset
netsh int ip reset

执行后需要重启电脑。

#完全关闭并重启 WSL

关闭所有 WSL 实例并重新启动服务。

wsl --shutdown
wsl -d <你的发行版名称>

#检查 Hyper-V 和相关功能

确保 Windows 功能中的 Hyper-V 和 Virtual Machine Platform 已启用。如果未启用，可以通过以下步骤操作：

1. 打开“控制面板” > “程序” > “启用或关闭 Windows 功能”。
2. 勾选 Hyper-V 和 虚拟机平台，然后重启系统。

MPU（Memory Protection Unit，内存保护单元）和 MMU（Memory Management Unit，内存管理单元）是现代计算机系统中用于内存管理的两种硬件设备。尽管它们在基本功能上有相似之处，但在复杂性和功能上存在显著差异。

#MMU 的功能和特点

MMU 是一种更为先进的内存管理设备，主要用于虚拟内存和内存保护操作。它能够将虚拟地址转换为物理地址，并提供缓存控制、总线仲裁和银行切换等高级功能。这些特性使得 MMU 适用于运行高端操作系统（如 Windows、Linux 和 Android）的处理器，这些处理器通常被称为应用处理器。

MMU 的主要功能包括：

• 虚拟内存管理：将虚拟地址映射到物理地址。
• 内存保护：防止未经授权的内存访问。
• 缓存控制：管理缓存的使用。
• 总线仲裁：协调多个设备对总线的访问。
• Bank切换：在不同的内存银行之间切换。

#MPU 的功能和特点

MPU 通常是 CPU 的一部分，主要用于内存保护。与 MMU 不同，MPU 不支持虚拟内存管理和其他高级功能，因此它的复杂性和成本较低。MPU 适用于简单的系统，特别是在低功耗处理器中。

MPU 的主要功能包括：

• 内存保护：防止未经授权的内存访问。
• 低复杂性和低成本：适用于不需要虚拟内存管理的简单系统。

#对比

#ssh连接时出现警告

升级最新版本的ssh(10.0)后，连接服务器时会出现警告：

❯ ssh test
** WARNING: connection is not using a post-quantum key exchange algorithm.
** This session may be vulnerable to "store now, decrypt later" attacks.
** The server may need to be upgraded. See https://openssh.com/pq.html

主要原因是，ssh最新版本新增并修改了默认的加密密钥协商算法，以应对量子计算机的共计。

OpenSSH 支持多种加密密钥协商算法 被认为对量子计算机的攻击是安全的。 我们建议所有SSH连接都使用这些算法。

OpenSSH 提供了后量子密钥协议（KexAlgorithms） 自 9.0 版本（2022 年 4 月）起默认使用，最初通过 sntrup761x25519-sha512 算法实现。最近，在OpenSSH 9.9中， 我们新增了第二个后量子密钥协议 mlkem768x25519-sha256，并在 OpenSSH 10.0（2025 年 4 月）中将其定为新的默认方案。

#背景

量子计算机（QC）是一种能够执行计算的设备 信息编码为量子态。这样的装置可以很快解决 这些问题对现有“经典”计算机来说是难以解决的。

支撑多种密码算法的数学原理 这些都是量子计算机被认为能够解决的问题之一 有效解决。这意味着，足够强大的量子计算机 （即“密码学相关”量子计算机）能够破解 他们。受影响最大的是用于密钥协商和数字化的密码学 签名，这两者在SSH中都起着重要作用。

幸运的是，有足够强大的量子计算机能够破解密码学 还没有被发明出来。关于密码学相关时的估计 量子计算机将会到来，基于该领域的进展速度， 时间范围在5到20年之间，许多观察者预计他们会到来 2030年代中期。

SSH连接的全部隐私都依赖于加密密钥协议。 如果攻击者能够破坏密钥协议，那么他们就能解密 和 查看整个会话。攻击者不必在现实中进行此攻击 时间;它们可能先收集加密的SSH会话，之后再解密 一旦他们获得了量子计算机的访问权限。 这被称为“先存储，后解密”攻击（也称为 “先收获，后解密”）。

幸运的是，改进的“后量子”密码算法已被开发出来 这些问题依赖于不同的底层数学问题，这些问题被理解为 不能被量子计算机攻击。

OpenSSH 支持后量子密钥协议，以防止“立即存储， “解密后”攻击已经持续多年，从那时起它就成为默认设置 OpenSSH-9.0，于2022年发布。

#处理方式

1. 升级服务器ssh版本
2. 或在本机的ssh_config中禁用警告

Match host unsafe.example.com
    WarnWeakCrypto no

C++ 标准库的 <numeric> 头文件是进行数值计算的宝库。它不仅仅包含几个简单的函数，而是提供了一整套强大、高效且灵活的算法，用于处理序列数据。这些算法能够帮助我们写出更简洁、更具表现力且性能更高的代码，尤其是在现代 C++ (C++17 及以后) 中，它们中的许多都支持并行执行。

本文将全面介绍 <numeric> 头文件中的核心算法，分为三大类：

1. 累积与归约 (Reduction)：将一个序列合并成单个值。
2. 扫描与前缀和 (Scan)：计算序列的中间累积结果。
3. 数值生成与数学工具：用于初始化序列和基础数学计算。

#累积与归约 (Reduction)

这类算法的目标是将一个序列中的所有元素通过某个二元操作（如加法、乘法）合并成一个单一的值。

#std::accumulate (C++98)

这是最经典、最基础的累积算法。它严格按照从左到右的顺序进行计算。

• 功能：计算一个序列 [first, last) 中所有元素的总和，从一个初始值 init 开始。
• 特点：保证严格的顺序执行，可以通过自定义操作实现求积、字符串拼接等。

#include <vector>
#include <numeric>
#include <string>
#include <iostream>

std::vector<int> nums = {1, 2, 3, 4, 5};

// 计算总和
int sum = std::accumulate(nums.begin(), nums.end(), 0); // 15

// 计算乘积
int product = std::accumulate(nums.begin(), nums.end(), 1, std::multiplies<int>()); // 120

// 拼接字符串
std::vector<std::string> words = {"Hello", " ", "World"};
std::string sentence = std::accumulate(words.begin(), words.end(), std::string("")); // "Hello World"

#std::reduce (C++17)

std::reduce 是 std::accumulate 的现代化、可并行化版本。

• 功能：与 accumulate 类似，但不保证计算顺序。
• 核心区别：
  1. 并行性：允许乱序执行，因此可以利用 std::execution::par 等执行策略进行并行计算，从而大幅提升性能。
  2. 操作要求：由于乱序执行，提供的二元操作必须满足结合律和交换律（如加法、乘法），否则结果未定义。
  3. 默认初始值：有一个不需要 init 参数的版本，它会使用元素类型的默认构造函数（例如 int{} 即 0）作为初始值。

#include <vector>
#include <numeric>
#include <execution>

std::vector<long> big_vec(1'000'000, 1);

// 使用并行策略计算总和
long parallel_sum = std::reduce(std::execution::par, big_vec.begin(), big_vec.end(), 0L);

何时选择？

• 需要保证顺序（如减法），或在 C++17 之前的代码中，使用 std::accumulate。
• 追求性能，且操作允许乱序（如加法），现代 C++ 代码首选 std::reduce。

#std::inner_product (C++98)

• 功能：计算两个序列的内积（点积）。它将两个序列的对应元素相乘，然后将所有乘积累加起来。
• 灵活性：可以自定义累积操作和元素配对操作。

std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = {4, 5, 6};

// 计算内积: (1*4 + 2*5 + 3*6)
int dot_product = std::inner_product(v1.begin(), v1.end(), v2.begin(), 0); // 32

#std::transform_reduce (C++17)

这是最强大的归约算法，完美体现了 "map-reduce" 思想。

• 功能：
  1. 单序列：先对每个元素应用一个转换操作（map），然后再对结果进行归约（reduce）。
  2. 双序列：先对两个序列的对应元素应用一个二元操作（transform），然后再对结果进行归约（reduce）。
• 特点：可并行化，且将转换和归约合二为一，避免了创建中间容器。

std::vector<int> nums = {1, 2, 3, 4};

// 计算平方和 (1*1 + 2*2 + 3*3 + 4*4)
int sum_of_squares = std::transform_reduce(
    nums.begin(), nums.end(),
    0,                                 // 初始值
    std::plus<>(),                     // Reduce 操作: 相加
    [](int x) { return x * x; }        // Transform 操作: 平方
); // 30

#扫描与前缀和 (Scan)

扫描算法不会将序列归约为单个值，而是生成一个包含所有中间累积结果的新序列。

#std::partial_sum (C++98)

• 功能：计算序列的“部分和”，即 inclusive_scan 的早期版本。结果中的第 i 个元素是原序列前 i+1 个元素的和。

std::vector<int> data = {1, 2, 3, 4, 5};
std::vector<int> result(5);

std::partial_sum(data.begin(), data.end(), result.begin());
// result: {1, 3, 6, 10, 15}

#std::inclusive_scan & std::exclusive_scan (C++17)

这两个是现代化的、可并行的扫描算法。

• inclusive_scan：包含当前元素的扫描，行为与 partial_sum 相同。
• exclusive_scan：不包含当前元素的扫描，结果中的第 i 个元素是原序列前 i 个元素的和。

std::vector<int> data = {1, 2, 3, 4, 5};
std::vector<int> incl_res(5), excl_res(5);

// 包含当前项的前缀和
std::inclusive_scan(data.begin(), data.end(), incl_res.begin());
// incl_res: {1, 3, 6, 10, 15}

// 不包含当前项的前缀和
std::exclusive_scan(data.begin(), data.end(), excl_res.begin(), 0);
// excl_res: {0, 1, 3, 6, 10}

#std::adjacent_difference (C++98)

• 功能：可以看作是 partial_sum 的逆运算，计算序列中每两个相邻元素之间的差。

std::vector<int> data = {1, 3, 6, 10, 15};
std::vector<int> result(5);

std::adjacent_difference(data.begin(), data.end(), result.begin());
// result: {1, 2, 3, 4, 5} (恢复了原始序列)

#数值生成与数学工具

#std::iota (C++11)

• 功能：用一个从指定值开始连续递增的序列来填充一个范围。非常适合快速初始化。

std::vector<int> nums(5);
std::iota(nums.begin(), nums.end(), 10); // 填充 10, 11, 12, 13, 14

#std::gcd & std::lcm (C++17)

• 功能：计算两个整数的最大公约数（Greatest Common Divisor）和最小公倍数（Least Common Multiple）。

int a = 12, b = 18;
int common_divisor = std::gcd(a, b);   // 6
int common_multiple = std::lcm(a, b); // 36

#总结

<numeric> 头文件为 C++ 开发者提供了一套声明式、高效且功能强大的工具。通过使用这些算法，我们可以：

• 提高代码可读性：算法的名称（如 accumulate, transform_reduce）清晰地表达了代码的意图。
• 提升代码性能：C++17 引入的并行版本算法可以充分利用现代多核 CPU 的计算能力。
• 减少错误：标准库算法经过了充分的测试和优化，比手写的循环更可靠。

下次当你需要对一个序列进行数值计算时，不妨先查阅一下 <numeric> 头文件，很可能已经有一个完美的算法在等着你了。

#参考

1. https://cppreference.cn/w/cpp/numeric
2. https://cplusplus.com/reference/numeric/

C++ 标准模板库（STL）是 C++ 语言的基石之一，它提供了一套性能卓越、经过严格测试的通用算法和数据结构。其中，容器是 STL 最核心的部分，它们是用于管理和存储对象集合的类模板。正确地选择容器，不仅能让代码更简洁、更安全，还能显著提升程序的性能。

本文将全面介绍 C++ 中常见的各类容器，分析它们的内部实现、优缺点以及最佳适用场景，帮助你今后在项目开发中做出明智的选择。

C++ 容器主要可以分为三类：顺序容器、关联容器和无序关联容器。

#顺序容器 (Sequence Containers)

顺序容器中的元素按照严格的线性顺序排列。你可以精确地控制每个元素的位置。

#std::vector

• 特点：动态数组。所有元素在内存中连续存储。
• 优点：
  • 访问最快：通过索引 [] 或 .at() 进行随机访问的时间复杂度为 O(1)，并且由于内存连续，能很好地利用 CPU 缓存。
  • 尾部操作高效：在尾部添加/删除元素（.push_back(), .pop_back()）的平均时间复杂度为 O(1)。
• 缺点：
  • 中间插入/删除慢：在容器开头或中间插入/删除元素的时间复杂度为 O(n)，因为它需要移动之后的所有元素。
  • 可能触发重分配：当 vector 容量不足时，它会重新分配一块更大的内存，并将所有旧元素拷贝过去，这可能是一个耗时的操作。
• 适用场景：需要快速随机访问，且主要在尾部进行添加/删除操作的场景。这是最常用、最应该被首选的容器。

#std::deque (Double-Ended Queue)

• 特点：双端队列。其内部实现并非一整块连续内存，而是由多个连续的内存块（chunks）链接而成。
• 优点：
  • 两端操作高效：支持在头部和尾部快速添加/删除元素，时间复杂度均为 O(1)。
  • 支持随机访问：虽然其随机访问性能略逊于 vector（需要两次指针解引用），但时间复杂度仍为 O(1)。
• 缺点：
  • 中间插入/删除慢：与 vector 类似，中间操作的时间复杂度为 O(n)。
  • 内存不连续：缓存命中率低于 vector，遍历速度可能稍慢。
• 适用场景：需要频繁地在容器的两端进行插入和删除操作的场景，例如实现一个既能先进先出又能后进先出的队列。

#std::list

• 特点：双向链表。每个元素都存储着指向前一个和后一个元素的指针。
• 优点：在任何位置插入/删除元素都非常快（O(1)），前提是你已经拥有指向该位置的迭代器。
• 缺点：
  • 不支持随机访问：无法通过索引（如 list[i]）访问元素。要访问第 n 个元素，必须从头或尾开始遍历 n 次，时间复杂度为 O(n)。
  • 内存开销大：每个元素都需要额外的空间来存储前后指针。
• 适用场景：需要对集合进行大量、不规律的插入和删除操作，而对随机访问没有要求的场景。

#std::array (C++11)

• 特点：固定大小的数组，是对 C 风格数组的现代封装。大小在编译时确定，不可改变。
• 优点：性能与 C 风格数组完全相同，但提供了更安全、更方便的接口（如获取大小、迭代器支持、边界检查等）。
• 缺点：大小固定，缺乏灵活性。
• 适用场景：当你明确知道需要一个在编译期就确定大小的数组时。

#关联容器 (Associative Containers)

关联容器根据键 (key) 来高效地排序和存储元素。它们非常适合用于快速查找。

#std::map

• 特点：存储键-值对 (key-value pairs)，其中键是唯一的。内部通常由红黑树实现，元素自动按键的升序排序。
• 优点：可以根据键快速查找、插入和删除元素，平均时间复杂度为 O(log n)。
• 适用场景：需要存储键值对，并且要求元素能自动排序的场景。

#std::set

• 特点：只存储唯一的键。和 map 一样，内部也是由红黑树实现，元素自动排序。
• 优点：快速查找、插入和删除（O(log n)）。常用于检查一个元素是否存在于一个集合中。
• 适用场景：需要存储不重复的元素，并要求它们保持有序。

std::multimap 和 std::multiset 分别是 map 和 set 的多键版本，它们允许存储重复的键。

#无序关联容器 (Unordered Associative Containers)

这类容器在 C++11 中引入，它们也存储键或键值对，但基于哈希表 (Hash Table) 实现，不保证元素有序，换来的是更快的平均性能。

#std::unordered_map

• 特点：存储键-值对，键是唯一的。通过哈希函数将键映射到桶 (bucket) 中以实现快速访问。
• 优点：提供了最快的平均查找、插入和删除速度，平均时间复杂度为 O(1)。
• 缺点：
  • 元素是无序的。
  • 在最坏情况下（所有元素哈希到同一个桶中），性能会退化到 O(n)。
  • 需要为哈希表本身和键的哈希值消耗额外内存。
• 适用场景：追求极致查找性能，且不关心元素顺序的场景。这是 std::map 的常用高性能替代品。

#std::unordered_set

• 特点：只存储唯一的键，基于哈希表实现。
• 优点：最快的平均查找、插入和删除速度（O(1)）。
• 适用场景：需要以最高性能判断一个元素是否存在于集合中，且不关心顺序。

#总结与选择建议

为了方便选择，下表总结了各类容器的特点：

通用建议：

1. 如果不确定用什么，std::vector 通常是最好的第一选择。它的性能优秀且用途广泛。
2. 如果需要按键查找，并且不要求排序，std::unordered_map 是 std::map 的高性能替代品。
3. 只有在需要频繁在容器中间进行插入/删除时，才考虑使用 std::list。

FreeRTOS 作为一个轻量级的实时操作系统（RTOS），其核心功能之一就是任务调度。它允许多个任务“同时”运行，为嵌入式系统提供了并发处理能力。要真正理解 FreeRTOS 是如何工作的，就必须深入其任务调度和上下文切换的底层细节。

本文将详细解析 FreeRTOS 的任务调度过程，特别是任务切换时堆栈（Stack）和关键寄存器（SP, PC 等）的变化情况。

#任务状态

在任何时刻，一个任务都必然处于以下几种状态之一：

• 运行态 (Running): 任务当前正在 CPU 上执行。在单核处理器上，永远只有一个任务处于运行态。
• 就绪态 (Ready): 任务已经准备好，可以运行，但因为有更高优先级的任务正在运行，所以它在等待 CPU。
• 阻塞态 (Blocked): 任务正在等待某个外部事件（例如 vTaskDelay 延时、等待信号量、队列数据等），在此期间它不会被调度。
• 挂起态 (Suspended): 任务被显式地“暂停”，除非被显式地恢复，否则调度器会完全忽略它。

调度器的核心职责，就是在所有处于“就绪态”的任务中，选择优先级最高的那个，让它进入“运行态”。

#FreeRTOS 调度器原理

FreeRTOS 采用的是基于优先级的抢占式调度算法。

• 基于优先级: 每个任务都被赋予一个优先级。调度器总是确保当前运行的是所有就绪态任务中优先级最高的那个。
• 抢占式: 如果一个高优先级的任务变为就绪态（例如，一个中断服务程序唤醒了它），而当前正在运行的是一个低优先级的任务，调度器会立即暂停（抢占）低优先级任务，让高优先级任务运行。

这种机制的切换点被称为上下文切换 (Context Switch)。

#上下文切换 (Context Switch) 详解

上下文切换是 FreeRTOS 实现多任务并发的魔法核心。它指的是保存当前运行任务的 CPU 状态（上下文），然后加载即将运行任务的 CPU 状态的过程。

任务的上下文主要包括：

1. CPU 寄存器: 通用寄存器（在 ARM Cortex-M 中如 R0-R12）、程序计数器 (PC)、链接寄存器 (LR)、程序状态寄存器 (PSR) 等。
2. 任务堆栈指针 (SP): 指向该任务私有堆栈的栈顶。

每个任务都有一个独立的任务控制块 (Task Control Block, TCB)，它是一个数据结构，用于存储任务的所有信息，其中最重要的就是任务的堆栈指针 pxTopOfStack。

#切换过程拆解

假设当前正在运行 Task_Low (低优先级)，此时一个中断发生，使得 Task_High (高优先级) 从阻塞态变为了就绪态。当中断服务程序（ISR）完成时，调度器将被触发，执行一次上下文切换。

上下文切换流程图

#第 1 步：保存 Task_Low 的上下文

当中断发生时，CPU 硬件会自动将一部分核心寄存器（如 PC, PSR, LR 等）压入 Task_Low 的堆栈。在 FreeRTOS 的切换机制（通常在 PendSV_Handler 中实现）里，会继续执行以下操作：

1. 软件压栈: 将 CPU 中剩余的通用寄存器（R4-R11 等，具体取决于架构）也压入 Task_Low 的堆栈。
2. 保存 SP: 将当前堆栈指针 SP 的值，保存到 Task_Low 的 TCB 中的 pxTopOfStack 成员里。

至此，Task_Low 的所有“记忆”（即它运行到哪里，各个寄存器的值是什么）都被完整地保存在了它自己的堆栈中。

#第 2 步：选择下一个要运行的任务

调度器会查看就绪任务列表，发现 Task_High 是当前优先级最高的就绪任务，因此决定下一个运行它。

#第 3 步：恢复 Task_High 的上下文

1. 加载 SP: 从 Task_High 的 TCB 中，读取 pxTopOfStack 的值，并将其加载到 CPU 的 SP 寄存器中。现在，SP 指向了 Task_High 的堆栈顶。
2. 软件弹栈: 从 Task_High 的堆栈中，将之前保存的 R4-R11 等通用寄存器依次弹出，恢复到 CPU 的相应寄存器中。
3. 硬件弹栈与返回: 当 PendSV_Handler 退出时，CPU 硬件会自动从 Task_High 的堆栈中弹出之前保存的 PC, PSR, LR 等寄存器。

当 PC 寄存器被恢复后，CPU 的下一条指令就会从 Task_High 上次被中断的地方继续执行。至此，一次完整的上下文切换完成。

#堆栈与寄存器变化图解

让我们更直观地看看这个过程。

1. 切换前:

• CPU 的 SP 寄存器指向 Task_Low 的堆栈。
• CPU 的 PC 寄存器指向 Task_Low 正在执行的代码。

2. 切换中 (保存 Task_Low):

• Task_Low 的所有寄存器被压入其堆栈。
• Task_Low 的 TCB 更新：tcb_low.pxTopOfStack = SP。

3. 切换中 (恢复 Task_High):

• SP 更新：SP = tcb_high.pxTopOfStack。
• Task_High 的寄存器从其堆栈中弹出到 CPU。

4. 切换后:

• CPU 的 SP 寄存器指向 Task_High 的堆栈。
• CPU 的 PC 寄存器指向 Task_High 的代码。Task_High 开始运行。

#关键寄存器的作用

• SP (Stack Pointer): 任务切换的“定位器”。它的值在 TCB 和 CPU 之间来回传递，确保了每个任务都能找到自己独立的堆栈空间。
• PC (Program Counter): 任务执行的“指令指针”。保存和恢复 PC 是实现任务断点续传的关键，使得任务看起来像是连续执行的。
• LR (Link Register): 函数调用的“返回地址”。每个任务都有自己的调用栈，LR 必须作为上下文的一部分被保存，否则函数调用关系会错乱。
• PSR (Program Status Register): 任务的“状态标志”。包含了条件码（零、负、进位等），控制着条件分支的执行，必须被精确恢复。

#总结

FreeRTOS 的任务调度是一个高效且精巧的机制。它通过为每个任务维护一个独立的堆栈和 TCB，在上下文切换时，利用 PendSV 这个特殊设计的低优先级中断，快速地保存和恢复 CPU 寄存器，从而实现了任务之间的无缝切换。

理解这一底层过程，不仅能帮助我们更好地使用 FreeRTOS，还能在遇到多任务相关的疑难- 杂症时，提供更深入的调试思路。

位操作是程序员的“超能力”之一。它允许我们深入到数据的最底层，直接操控二进制位，从而实现高效的算法、紧凑的数据存储和底层的硬件交互。C++ 语言提供了一套丰富且不断进化的工具集来支持位操作，从经典的位运算符到 C++20 引入的高性能函数，应有尽有。

本文将系统性地介绍 C++ 中所有与位操作相关的函数和工具，分为四个类别，并提供清晰的示例，帮助你彻底掌握它们。

#基础核心：位运算符

这是所有位操作的基石。它们是 C++ 内置的运算符，直接对整数类型进行操作。

示例

#include <iostream>
#include <bitset> // 用于二进制可视化
#include <iomanip>

int main() {
    unsigned char a = 0b01010101; // 85
    unsigned char b = 0b11110000; // 240

    std::cout << "a = " << std::bitset<8>(a) << std::endl; // 输出: a = 01010101
    std::cout << "b = " << std::bitset<8>(b) << std::endl; // 输出: b = 11110000
    std::cout << "-------------------------" << std::endl;
    std::cout << "a & b = " << std::bitset<8>(a & b) << std::endl; // 输出: a & b = 01010000
    std::cout << "a | b = " << std::bitset<8>(a | b) << std::endl; // 输出: a | b = 11110101
    std::cout << "a ^ b = " << std::bitset<8>(a ^ b) << std::endl; // 输出: a ^ b = 10100101
    std::cout << "~a    = " << std::bitset<8>(~a) << std::endl;    // 输出: ~a    = 10101010
    std::cout << "a << 2= " << std::bitset<8>(a << 2) << std::endl; // 输出: a << 2= 01010100
    std::cout << "b >> 2= " << std::bitset<8>(b >> 2) << std::endl; // 输出: b >> 2= 00111100
}

#函数式编程的优雅：<functional> (C++14)

为了让位运算能与 STL 算法（如 std::accumulate）无缝协作，C++14 在 <functional> 头文件中引入了一组函数对象。

• std::bit_and<T>: 执行按位与 (&)。
• std::bit_or<T>: 执行按位或 (|)。
• std::bit_xor<T>: 执行按位异或 (^)。
• std::bit_not<T>: 执行按位取反 (~)。

它们的主要优势在于作为“可调用对象”传递，使代码更具表现力。

示例：计算向量中所有元素的异或和

#include <iostream>
#include <vector>
#include <numeric>    // For std::accumulate
#include <functional> // For std::bit_xor

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5}; // 01, 10, 11, 100, 101

    // 计算 ((((0^1)^2)^3)^4)^5
    int xor_sum = std::accumulate(
        nums.begin(),
        nums.end(),
        0,                  // 初始值
        std::bit_xor<int>() // 操作函数
    );

    std::cout << "XOR sum of the vector is: " << xor_sum << std::endl; // 输出: XOR sum of the vector is: 1
}

#现代 C++的高性能工具箱：<bit> (C++20)

C++20 带来了革命性的 <bit> 头文件，提供了一组高效的底层位操作函数，它们通常能直接映射到现代 CPU 的硬件指令，性能极高。

• std::popcount(n): 计算 n 中值为 1 的位的数量（"population count"）。
• std::has_single_bit(n): 检查 n 是否是 2 的幂（即是否只有一个位是 1）。
• std::countl_zero(n) / std::countr_zero(n): 分别计算从左（高位）或从右（低位）开始的连续 0 的数量。
• std::bit_ceil(n) / std::bit_floor(n): 分别计算大于等于 n の最小的 2 的幂和小于等于 n 的最大的 2 的幂。
• std::rotl(n, s) / std::rotr(n, s): 将 n 循环左移或右移 s 位。

示例

#include <iostream>
#include <bit> // 需要 C++20
#include <bitset>

int main() {
    unsigned int num = 42; // 二进制: ...00101010

    std::cout << "Number: " << num << std::endl; // 输出: Number: 42
    std::cout << "Popcount (number of set bits): " << std::popcount(num) << std::endl; // 输出: Popcount (number of set bits): 3
    std::cout << "Is power of two? " << std::boolalpha << std::has_single_bit(num) << std::endl; // 输出: Is power of two? false
    std::cout << "Ceiling to power of two: " << std::bit_ceil(num) << std::endl; // 输出: Ceiling to power of two: 64
    std::cout << "Floor to power of two: " << std::bit_floor(num) << std::endl; // 输出: Floor to power of two: 32

    // 对于一个 8 位数
    unsigned char byte = 0b00110100; // 52
    std::cout << "\nByte: " << std::bitset<8>(byte) << std::endl; // 输出: Byte: 00110100
    std::cout << "Count leading zeros: " << std::countl_zero(byte) << std::endl; // 输出: Count leading zeros: 2
    std::cout << "Count trailing zeros: " << std::countr_zero(byte) << std::endl; // 输出: Count trailing zeros: 2
    std::cout << "Rotate left by 2: " << std::bitset<8>(std::rotl(byte, 2)) << std::endl; // 输出: Rotate left by 2: 11010000
}

#面向对象的位容器：<bitset>

std::bitset 是一个类模板，用于管理一个固定大小的位序列。它像一个 bool 数组，但为位操作进行了空间和性能优化，并提供了丰富的成员函数。

• 构造: 可以从整数、字符串等创建。
• 访问与修改: [], set(), reset(), flip()。
• 查询: count(), size(), any(), none(), all()。
• 转换: to_string(), to_ulong(), to_ullong()。

示例

#include <iostream>
#include <bitset>
#include <string>

int main() {
    // 创建一个 8 位的 bitset
    std::bitset<8> flags("01010011");

    std::cout << "Initial flags: " << flags << std::endl; // 输出: Initial flags: 01010011
    std::cout << "Number of active flags: " << flags.count() << std::endl; // 输出: Number of active flags: 4

    // 检查特定标志位
    if (flags[2]) { // 第 2 位 (从右到左)
        std::cout << "Flag 2 is active." << std::endl; // 输出: Flag 2 is active.
    }

    // 修改标志位
    flags.flip(7); // 翻转最高位
    flags.set(0);  // 激活最低位
    std::cout << "Modified flags: " << flags << std::endl; // 输出: Modified flags: 11010011

    // 转换为整数
    std::cout << "Integer value: " << flags.to_ulong() << std::endl; // 输出: Integer value: 211
}

#总结

如何选择？

• 日常简单操作: 直接使用位运算符 (&, |, ^ 等)。
• 需要与 STL 算法集成: 使用 <functional> 中的函数对象。
• 追求极致性能或需要高级位操作 (如 popcount, 循环移位): 优先使用 C++20 的 <bit> 库。
• 需要管理一组状态标志或构建位掩码: std::bitset 是最清晰、最安全的选择。

通过掌握这些工具，你可以在 C++ 中编写出更高效、更优雅、更底层的代码。希望这篇指南能成为你探索位操作世界的得力助手!

在 C++ 的世界里，“引用”是一个既基础又强大的概念。然而，随着 C++11 的到来，引用的家族迎来了新成员——右值引用，这让许多开发者感到困惑。正确理解左值引用和右值引用，以及它们在函数参数传递中的应用，是编写高效、现代 C++ 代码的关键。

本文将系统地梳理 C++ 中的引用，帮助你彻底搞懂它们之间的区别与联系。

#核心概念：什么是引用？

在 C++ 中，引用（Reference） 可以看作是一个变量的 别名（Alias）。它不是一个新变量，也不占用新的内存空间（在底层实现上，它通常是一个指针常量，但我们从语言层面理解它就是个别名）。一旦引用被初始化为一个变量，它就终生绑定到这个变量上，不能再改为其他变量的引用。

对引用的任何操作，都等同于对它所绑定的原始变量进行操作。

#左值（Lvalue）与右值（Rvalue）

在深入了解两种引用之前，我们必须先掌握左值和右值的概念。

• 左值 (Lvalue - Locator Value): 指的是那些在内存中有固定地址、可以被“定位”到的表达式。简单来说，可以出现在赋值符号 = 左边的就是左值。

  • 例如：变量名 (int x = 10; 这里的 x 就是左值)、数组元素、函数返回的引用等。
  • 特点：有持久的内存地址，不是临时的。

• 右值 (Rvalue - Read Value): 指的是那些只能被“读取”的值，通常是临时的、没有固定内存地址的表达式。简单来说，只能出现在赋值符号 = 右边的就是右值。

  • 例如：字面量 (10, 'a')、临时对象（x + y 的计算结果）、函数返回的值（非引用）等。
  • 特点：是临时的，表达式结束后就会被销毁。

int x = 10; // x 是左值, 10 是右值
int y = 20; // y 是左值, 20 是右值
int z = x + y; // z 是左值, (x + y) 的计算结果是右值

#左值引用 (Lvalue Reference, &)

这是我们传统意义上最常说的“引用”，使用 & 符号声明。

特点与规则:

1. 只能绑定到左值。
2. 它的主要作用是作为别名，避免大对象的拷贝。

示例:

int a = 100;
int& ref_a = a; // 正确：左值引用 ref_a 绑定到左值 a

ref_a = 200; // 修改 ref_a 就是修改 a，此刻 a 的值也变成了 200

int& ref_b = 10; // 编译错误！不能将左值引用绑定到右值 (字面量 10)

#特例：const 左值引用

一个 const 的左值引用既可以绑定到左值，也可以绑定到右值。当它绑定到右值时，C++ 会创建一个临时的、无名的左值对象，并将该引用绑定到这个临时对象上。

const int& ref_c = a;    // 正确：const 左值引用绑定到左值 a
const int& ref_d = 10;   // 正确：const 左值引用绑定到右值 10
const int& ref_e = a + 5;// 正确：const 左值引用绑定到右值 (a+5 的结果)

这个特性使得 const T& 成为函数参数传递中非常重要的类型，因为它既能接收左值也能接收右值，同时保证了安全性。

#右值引用 (Rvalue Reference, &&)

这是 C++11 引入的新特性，使用 && 符号声明。它的出现主要是为了解决两个问题：移动语义 (Move Semantics) 和 完美转发 (Perfect Forwarding)。

特点与规则:

1. 只能绑定到右值。
2. 它的核心作用是“窃取”或“移动”右值（临时对象）的资源，从而避免不必要的深拷贝，大幅提升性能。

示例:

int&& rref_a = 10; // 正确：右值引用 rref_a 绑定到右值 10
int&& rref_b = a + 5; // 正确：右值引用 rref_b 绑定到右值 (a+5 的结果)

int a = 100;
int&& rref_c = a; // 错误！不能将右值引用绑定到左值 a

#std::move 的作用

std::move 是一个非常有用的函数，它可以无条件地将一个左值强制转换为右值引用。这并不意味着它“移动”了任何东西，它只是做了一个类型转换，告诉编译器：“你可以把这个对象当成一个临时对象来处理了”。

#include <utility> // 需要包含 <utility> 头文件

int a = 100;
int&& rref_d = std::move(a); // 正确：通过 std::move 将左值 a 转换为右值引用

rref_d = 300; // 修改 rref_d 仍然是修改 a，因为它们指向同一块内存
// 此刻 a 的值也变成了 300

注意：被 std::move 之后，原来的变量 a 就进入了一个“未指定但有效”的状态。你不应该再对它的值做任何假设，它的资源可能已经被“窃取”了。

#作为函数参数

这是理解引用最有价值的场景之一。

#值传递 (Pass by Value)

• 工作方式: 函数会创建参数的一个完整副本。函数内部对参数的任何修改都不会影响到函数外部的原始变量。
• 优点: 安全，函数不会意外修改外部状态。
• 缺点: 对于大对象（如 std::vector），创建副本的开销非常大，严重影响性能。

void process_by_value(int val) {
    val = 99; // 只修改了副本 val，不影响外部
}

#左值引用传递 (Pass by Lvalue Reference)

• 工作方式: 函数接收的是原始变量的别名，没有创建任何副本。函数内部对参数的修改会直接影响到外部的原始变量。
• 优点: 效率高，避免了拷贝开销；能修改外部变量。
• 缺点: 可能会意外修改原始数据。如果不想修改，应该使用 const。

// 允许修改
void process_by_ref(int& ref) {
    ref = 99; // 直接修改了外部变量
}

// 推荐：不允许修改，但同样高效
void process_by_const_ref(const std::string& s) {
    // s = "new value"; // 编译错误！
    std::cout << s << std::endl; // 只是读取，非常高效
}