Rust 教程（保姆级教程）

为什么你应该学习 Rust 教程？

在当今的编程世界里，语言的选择越来越像一场“安全与效率”的博弈。C 语言性能极强，但内存管理全靠程序员自己把控，稍不注意就会出现缓冲区溢出、空指针等致命错误。而像 Python、JavaScript 这类语言虽然开发效率高，却常常在性能上捉襟见肘。

Rust 正是在这样的背景下诞生的。它既拥有 C/C++ 的执行效率，又通过一套独特的所有权系统，从根本上杜绝了空指针、数据竞争等常见 bug。如果你正在寻找一门既能让你写出高性能程序，又不会频繁被“段错误”折磨的语言，那么 Rust 教程绝对值得你投入时间。

Rust 不是“另一个 Python”，也不是“Java 的替代品”。它是一门为现代系统编程而生的语言，适合开发操作系统、游戏引擎、WebAssembly 模块、网络服务等对性能和安全性要求极高的场景。更重要的是，它的语法简洁，学习曲线平缓，只要你愿意一步步来，完全能从零开始掌握。

接下来，我们不讲大道理，直接上手实践。通过几个核心概念的拆解，带你真正理解 Rust 是如何做到“零成本抽象”与“内存安全”的。

安装与第一个程序：Hello, Rust！

在开始之前，你需要安装 Rust 工具链。推荐使用官方工具 rustup，它能帮你管理多个版本的 Rust。

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

安装完成后，运行以下命令验证环境：

rustc --version
cargo --version

如果看到类似 rustc 1.75.0 和 cargo 1.75.0 的输出，说明安装成功。

现在，我们创建一个最简单的 Rust 程序。

// main.rs
fn main() {
    // 打印一条欢迎信息到控制台
    println!("Hello, Rust 教程世界！");
}

保存为 main.rs，然后在终端运行：

cargo run

你会看到输出：

Hello, Rust 教程世界！

这个例子虽然简单，但包含了 Rust 的几个关键特征：

• fn main() 是程序入口，类似于 C 语言的 main() 函数；
• println! 是一个宏（macro），用于打印内容，感叹号 ! 表示这是一个宏调用；
• 所有语句以分号 ; 结尾，这是 Rust 的语法强制要求。

💡 小贴士：Rust 的设计哲学是“编译时就发现问题”，所以很多错误在写代码时就能被发现，而不是等到运行时崩溃。

变量与数据类型：Rust 的类型系统有多聪明？

在 Rust 中，变量默认是不可变的，这是为了鼓励你思考数据的生命周期和安全性。

fn main() {
    // 声明一个不可变变量，值为 42
    let x = 42;

    // 尝试修改 x，会报错！
    // x = 43;  // ❌ 编译错误：cannot assign to immutable variable

    // 如果需要可变变量，加上 mut 关键字
    let mut y = 100;
    y = 200;  // ✅ 正确：可变变量可以重新赋值

    // 声明不同类型
    let name: &str = "Alice";           // 字符串字面量，不可变
    let age: u8 = 25;                   // 无符号 8 位整数，范围 0~255
    let price: f64 = 9.99;              // 双精度浮点数
    let is_active: bool = true;         // 布尔值

    println!("姓名：{}，年龄：{}，价格：{}，活跃：{}", name, age, price, is_active);
}

📌 注意：Rust 的类型推断非常强大。如果你不写类型，编译器会根据上下文自动推断。例如 let x = 42;，编译器会自动判断为 i32。

函数与控制流：Rust 的逻辑表达更清晰

函数在 Rust 中是核心构建单元。你可以定义带参数和返回值的函数。

fn main() {
    let num = 10;

    // 调用函数并打印结果
    let result = add_one(num);
    println!("10 加 1 是：{}", result);
}

// 定义一个函数：接收一个 i32 参数，返回 i32
fn add_one(x: i32) -> i32 {
    // 函数体中的最后一行表达式会自动返回（不需要 return 关键字）
    x + 1
}

✅ 重点：Rust 函数的返回值不需要写 return，只要最后一行是表达式，它就会被当作返回值。

条件语句：if-else 与模式匹配

fn main() {
    let age = 18;

    if age >= 18 {
        println!("你已成年，可以投票。");
    } else if age >= 16 {
        println!("你已接近成年，可以申请驾照。");
    } else {
        println!("你还未成年，继续努力。");
    }
}

Rust 的 if 表达式可以作为表达式使用，甚至可以赋值给变量：

let can_drive = if age >= 16 { true } else { false };

这在其他语言中需要写成三元表达式 age >= 16 ? true : false，而 Rust 用更清晰的语法实现相同逻辑。

创建数组与初始化：Rust 的集合管理很安全

Rust 提供了多种集合类型，其中最基础的是数组（array）和向量（vector）。

数组：固定长度，栈上分配

fn main() {
    // 声明一个包含 5 个整数的数组，类型推断为 [i32; 5]
    let numbers = [1, 2, 3, 4, 5];

    // 访问元素，索引从 0 开始
    println!("第一个数字是：{}", numbers[0]);
    println!("最后一个数字是：{}", numbers[4]);

    // 遍历数组
    for num in numbers {
        println!("数字：{}", num);
    }
}

⚠️ 重要：数组索引越界会触发 panic（运行时错误），这是 Rust 的“安全优先”设计。虽然会崩溃，但至少能让你及时发现错误。

向量：动态长度，堆上分配

fn main() {
    // 创建一个空的向量
    let mut vec = Vec::new();

    // 添加元素
    vec.push(10);
    vec.push(20);
    vec.push(30);

    // 遍历并打印
    for item in &vec {
        println!("向量元素：{}", item);
    }

    // 查看长度
    println!("向量长度：{}", vec.len());
}

向量是 Rust 中最常用的集合类型。它支持动态增长，适合处理不确定数量的数据。

拥有权与借用：Rust 的核心机制

这是 Rust 最独特、也最值得深入理解的部分。它被称为“所有权系统”（Ownership System），是 Rust 实现内存安全的关键。

什么是所有权？

每个值在 Rust 中都有一个“所有者”。当所有者离开作用域时，该值会被自动释放。

fn main() {
    let s1 = String::from("Hello");  // s1 拥有 "Hello" 的所有权

    let s2 = s1;  // s1 的所有权被转移给 s2！s1 不再有效

    // println!("{}", s1);  // ❌ 编译错误：使用了已移动的值
    println!("{}", s2);  // ✅ 正确：s2 拥有所有权
}

🧠 比喻：就像你把手机借给朋友，朋友拿走了，你不能再用。Rust 通过所有权机制避免了“双重释放”或“悬空指针”。

借用：临时访问，不转移所有权

当你不想转移所有权，只想读取数据时，可以使用借用。

fn main() {
    let s = String::from("Rust 教程");

    // 借用 s 的引用，只读
    print_string(&s);
    println!("原字符串：{}", s);  // ✅ 仍然可以使用 s
}

fn print_string(s: &String) {
    println!("字符串内容：{}", s);
}

&s 表示对 s 的不可变引用。你只能读取，不能修改。

如果要修改，需要使用可变引用：

fn main() {
    let mut s = String::from("Hello");

    change_string(&mut s);  // 传入可变引用
    println!("修改后：{}", s);
}

fn change_string(s: &mut String) {
    s.push_str(", Rust!");
}

⚠️ 注意：一个变量只能有一个可变引用，或多个不可变引用，但不能同时有。这是为了防止数据竞争。

总结：Rust 教程，从入门到实践

通过这一系列内容，我们从安装、变量、函数、集合，到最关键的所有权机制，一步步揭开了 Rust 的神秘面纱。它不是为了“炫技”而设计的，而是为了解决真实世界中程序崩溃、内存泄漏等顽疾。

如果你希望写出既高效又安全的代码，Rust 教程不仅是一次学习，更是一次编程思维的升级。它要求你思考“谁拥有数据”、“数据何时被释放”，这些看似繁琐的规则，恰恰是构建可靠系统的基石。

现在，你已经掌握了 Rust 的基本语法与核心思想。下一步，不妨尝试用它写一个简单的命令行工具，比如一个待办事项管理器（Todo List），把今天学到的内容真正用起来。

记住：编程不是记住语法，而是理解逻辑。Rust 教程的价值，正在于它逼你用更严谨的方式思考问题。