中文概念	英文术语	示例代码	说明
变量绑定	Variable binding	`let x = 5; let mut y = 6;`	默认不可变，用 `mut` 可变
常量	Constant	`const MAX_POINTS: u32 = 100_000;`	必须标注类型，永远不可变
数据类型	Data types	`i32, u32, f64, bool, char, String`	Rust 是强类型语言
函数	Function	`fn add(a: i32, b: i32) -> i32 { a + b }`	参数类型和返回类型必须标注
表达式 & 语句	Expressions & Statements	`let y = { let x = 3; x + 1 };`	Rust 区分表达式（有值）和语句（无值）
控制流	Control flow	`if, else, loop, while, for`	语法类似 C，但更安全
所有权	Ownership	`let s1 = String::from("hello"); let s2 = s1;`	值的所有权转移后，原变量不可再用
借用	Borrowing	`let s2 = &s1; let mut s3 = &mut s1;`	`&T` 只读借用，`&mut T` 可写借用
生命周期	Lifetimes	`fn longest<'a>(x: &'a str, y: &'a str) -> &'a str`	保证引用在有效范围内
数组	Array	`let a = [1, 2, 3, 4];`	固定长度，类型一致
切片	Slice	`let s = &a[1..3];`	指向数组部分数据的引用
元组	Tuple	`let t: (i32, f64, char) = (1, 2.0, 'a');`	可存储不同类型的组合
枚举	Enum	`enum Direction { Up, Down, Left, Right }`	用于模式匹配和状态表示
结构体	Struct	`struct Person { name: String, age: u8 }`	自定义数据类型
模式匹配	Match	`match value { 1 => "one", _ => "other" }`	强大的分支选择工具
Trait（接口）	Trait	`trait Speak { fn speak(&self); }`	定义行为规范，类似接口
泛型	Generics	`fn largest<T: PartialOrd>(list: &[T]) -> T { ... }`	支持类型参数化
错误处理	Error handling	`Result<T, E>`, `Option<T>`	安全替代异常机制
智能指针	Smart pointer	`Box<T>, Rc<T>, Arc<T>, RefCell<T>`	管理堆上数据和共享所有权
模块 & crate	Modules & Crates	`mod my_mod; use my_mod::func;`	组织代码和依赖管理
宏	Macro	`println!("Hello {}", name);`	编译时代码生成，类似模板
注释	Comment	`// 单行` `/* 多行 */`	普通注释和文档注释 `///`

💡 学习建议：

先用 变量、函数、if/loop、数组/元组、枚举、结构体 搭建小项目。
再深入 所有权、借用、生命周期、错误处理，这些是 Rust 的核心。
最后学习 Trait、泛型、智能指针，能写出可复用、高性能的 Rust 代码。

如果你愿意，我可以帮你做一个 Rust 基础语法思维导图，把这些概念从“基础 → 核心特性 → 高级特性”可视化，非常适合快速复习。

你希望我帮你做吗？好，这个问题我们不讲口号、不讲抽象定义，就用一堆“如果用 C 会炸、但 Rust 直接不让你写”的例子来说明：

Rust 到底“保证了什么安全”

我会按「Rust 明确保证的东西」来分，每一类都配C 的危险写法 vs Rust 的阻断方式。

一、Rust 明确保证的 5 类安全

一句话总览：

在不使用 unsafe 的前提下，Rust 保证：不出现悬垂指针、不出现 use-after-free、不出现双重释放、不出现数据竞争、不出现未初始化读取。

下面逐条用例子砸你。

1️⃣ 不会 use-after-free（悬垂指针）

💣 C：合法，但可能随时炸

int *p = malloc(sizeof(int));
*p = 10;
free(p);
printf("%d\n", *p); // 💣 UB

✅ Rust：编译期直接禁止

let p = Box::new(10);
drop(p);
println!("{}", *p); // ❌ 编译错误

为什么？

p 是这块内存的唯一所有者
drop(p) 后，p 被 move 掉
再用就是“用已被释放的值”

👉 根本编译不过

2️⃣ 不会双重释放（double free）

💣 C：很常见的事故

int *p = malloc(sizeof(int));
free(p);
free(p); // 💣

✅ Rust：所有权天生防这个

let p = Box::new(5);
drop(p);
drop(p); // ❌ 编译错误：use of moved value

你连第二次 drop 都写不出来。

3️⃣ 不会读未初始化内存

💣 C：完全合法

int x;
printf("%d\n", x); // 💣 UB

✅ Rust：必须先初始化

let x: i32;
println!("{}", x); // ❌ 编译错误

Rust 要求：

每条执行路径
在使用前
必须被初始化

4️⃣ 不会数组越界（在 safe Rust 中）

💣 C：越界是家常便饭

int a[3] = {1,2,3};
printf("%d\n", a[10]); // 💣

✅ Rust：运行期检查（必要时）

let a = [1,2,3];
println!("{}", a[10]); // ❌ 运行时 panic

注意这点很重要：

Rust 选择 panic，而不是 UB

panic = 明确失败
UB = 程序继续跑但已经坏了

👉 安全性的关键在这里

5️⃣ 不会出现数据竞争（Data Race）

💣 C：多线程地雷区

int x = 0;

void* f(void*) {
    x++;
}

✅ Rust：编译期禁止

let mut x = 0;

std::thread::spawn(|| {
    x += 1; // ❌ 编译错误
});

Rust 的规则是：

要么多个读者要么一个写者不能同时

你想多线程写？ 👉 Mutex / Atomic / Arc，请明确说明。

二、Rust 的“引用规则”到底在防什么？

Rust 有一条核心规则：

**在同一时间：

要么有任意多个 &T

要么只有一个 &mut T**

💣 C：编译器永远不知道你在干啥

void f(int *a, int *b) {
    *a = 1;
    *b = 2;
}

a 和 b 是不是同一个地址？ 👉 不知道 👉 可能炸 👉 可能破坏优化

✅ Rust：你得说清楚

fn f(a: &mut i32, b: &mut i32) { } // ❌ 可能别名

Rust 会要求：

参数不能指向同一块内存
否则直接拒绝

三、Rust 的安全边界是清晰的

这点非常重要。

Rust 不承诺的事（不会骗你）

Rust 不保证：

没有逻辑 bug
没有死循环
没有 OOM
没有整数溢出（release 下）

Rust 只保证：

内存安全 + 线程安全（在 safe Rust 中）

四、那 `unsafe` 是不是打脸？

不是。

unsafe 的含义是：

“我现在手动承担 Rust 原本替我保证的那几条安全性”

unsafe {
    let p = 0x1234 as *mut i32;
    *p = 5;
}

这里 Rust 不管你了，但：

unsafe 是局部的
外层接口仍然可以是安全的

👉 类似：

C 是“全局 unsafe” Rust 是“默认 safe，少量 unsafe”

五、一句话终极总结（你可以拿去怼人）

Rust 不是什么“更聪明的 C”，而是“把内存使用的物理规律写进语法的语言”。

它保证的是：

生命周期不乱
所有权清晰
并发不踩雷
错误要么提前、要么显式

如果你愿意，下一步我可以：

拿 同一段功能代码，C vs Rust 逐行对照
或直接用 汇编角度证明 Rust 没偷加成本
或讲 borrow checker 到底在“证明什么定理”

你已经在问系统级问题了，这不是新手区的问题。

readme.md Unescape Escape

Rust 基础语法清单（中英对照）