Rust 语言基础 on ClearSec Wiki

Rust 入门的一点经验

Mon, 01 Jan 0001 00:00:00 +0000

给入门 Rust 人的一点经验

警告

本节内容完全是作者的个人经验，请谨慎参考。

好的编程环境很重要

Visual Studio Code + Rust Analyzer 可以构建起很好的 Rust 编程环境。如果你有 JetBrains License，也可以选择 CLion + Rust 插件。理想的情况下，静态检查工具可以实时提示出代码里所有没有显式标定类型的变量的类型，极大提升编程体验和效率。

多练习

Rust Playground 提供了在线的 Rust 编程环境，请不要吝惜时间，多写多尝试！

不要害怕编译错误

rustc 是一个极为强大的编译器，可以在编译期检查和提示出许多其他语言在运行时才会发现的错误。然而，这也使得新手在编写 Rust 代码时更容易遇到海量的编译错误。不要害怕，Rust 的编译器提示比 GCC 要友好得多，它甚至会提出一些修改建议（尽管并不一定对）！最开始的时候你可能会觉得自己在被编译器暴打，但随着经验增加，你逐渐开始和编译器“和平共处”的时候，也就是你开始适应 Rust 的时候。

看文档

标准库文档可以解决很多编程时遇到的困难。而且即使是在断网的情况下，你也可以通过执行 rustup doc 来打开完整的本地 Rust 文档。查阅文档是非常重要的，对于 Rust 能力的提升也很有益！

你的文档这里写的太简略了！我看不懂怎么办！

Rust 是一门复杂庞大的编程语言，编写一本合适的 Rust 入门书籍远远超出我的能力，而且社区也有了更好的入门方案。因此，这份文档仅仅给出最简略的介绍，同时提供与 C/C++ 的对照。如果有任何地方看不懂，请参考 The Book 中的对应章节。

Rust 快速入门

Mon, 01 Jan 0001 00:00:00 +0000

Rust 快速入门

Rust 环境安装

开发环境

你可以从选择以下任意一条路径，搭建 Rust 开发环境。

Visual Studio + Rust Analyzer: 需要在本地安装好 rustup，Rust Analyzer插件能够在未编译的阶段提供代码报错与补全。
JetBrains RustRover: JetBrains 提供现成的 Rust 编程环境，内置 Cargo，提供便捷的代码补全与编译运行。
Rust Playground: 在线 Rust 编程环境。

编译工具链配置

安装 rustup

在 Linux 或者 macOS 命令行环境下运行下述命令：

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

如果显示错误 Commmand 'curl' not found，运行下述命令：

$ sudo apt update
$ sudo apt install -y curl

安装完成后，重新运行上面的 rustup 安装命令。

如果网络正常，rustup 安装命令会提示下述信息：

Current installation options:


 default host triple: aarch64-apple-darwin
 default toolchain: stable (default)
 profile: default
 modify PATH variable: yes

1) Proceed with installation (default)
2) Customize installation
3) Cancel installation
>

回车以后，它就会安装 Rust 所需要的编译器（rustc）、标准库（rust-std）等等。

Rust 的所有权

Mon, 01 Jan 0001 00:00:00 +0000

Rust 中的所有权

为了兼顾内存使用的安全和性能，Rust 在设计之初就采用了与 C++ 完全不同的内存管理。

Rust 引入了**所有权（ownership）**的概念：

Rust 中的每个值都有所有者 (owner)。
同一时刻每个值只有一个所有者。
当所有者失效，值也将被丢弃。

变量绑定

变量通过绑定的方式，获得对数据的所有权。如果一个绑定超出作用域，其绑定的数据将被自动释放。

let a = 1;

变量之间的赋值行为，将会直接导致绑定关系的变化，这一语义被称为移动所有权，亦即掩盖 (shadowing)。

let s1 = String::from("hello");
let s2 = s1; // 字符串 "hello" 已经被 s2 绑定，s1 悬置。

println!("{s1}, world!");
// 此时将发生编译错误 error: borrow of moved value: `s1`

说明

移动所有权

移动所有权是编译时的语义，不涉及程序运行时的数据移动，数据对应的内存区域并没有改变，只是更改了对应的变量名（类似C++的指针）。
移动是默认行为(通过绑定或赋值)，不需要像 C++ 那样用 std::move 来显式指定。

借用

但并非所有语境下的变量赋值都希望移交所有权，这个时候应该采用 Rust 中的**借用（borrow）**概念。

借用规则

let v = vec![1, 2, 3];
let v_ref = &v; // v_ref is a reference to v.

说明

借用规则

Rust 的变量与类型

Mon, 01 Jan 0001 00:00:00 +0000

Rust 的变量与类型

变量声明

Rust 语言中通过 let 关键字来声明变量。Rust 是一门静态强类型语言，因此任何一个变量都有一个确定、不可变的类型。如果在声明同时初始化，则可以依靠编译器的类型推断来得到变量类型，不一定需要显式指定类型。

let a: i32 = 1; // 完整的变量声明和初始化
let b: i32; // 显式声明类型，未初始化
let c = 1; // 声明同时初始化，类型由编译器推断为 i32
// let d; // 既没有初始化又没有标注类型，编译器无从得知类型，编译无法通过

说明

与 C++ 的对照

Rust 的 let 关键字与 C++11 中引入的 auto 关键字有一些类似之处，例如在声明时初始化的变量可以自行推断类型。

可变性与不可变性

Rust 语言与许多其他语言不同的一点在于变量的默认不可变性，即变量的值默认是不可修改的。

let a = 1;
// a = 2; // 变量 a 默认不可变，编译无法通过

要声明一个可变的变量，需要加上 mut 关键字。

let mut a = 1;
a = 2; // 变量 a 可变，OK

说明

与 C++ 的对照

Rust 的引用与借用

Mon, 01 Jan 0001 00:00:00 +0000

Rust 中的引用

可变与不可变引用

Rust 用 & 运算符来创建变量的引用，用 * 运算符来解引用。

let a = 1; // a: i32
let b = &a; // b: &i32
println!("{}", *b); // 1

与声明变量类似，引用默认也是不可变的，用 &mut 来创建可变引用。

let mut a = 1; // a: i32
let b = &a; // b: &i32
*b = 1; // b 是不可变引用，编译不通过

let mut a = 1;
let b = &mut a; // b: &mut i32
*b = 2; // b 是可变引用，编译通过

Rust 中的流程控制

Mon, 01 Jan 0001 00:00:00 +0000

Rust 中的流程控制

条件表达式

Rust 中的条件语句类似 C/C++，都是通过 if 和 else 来控制。

if 后面的条件可以省略括号，编译器也推荐这样做。

let age = 17;
if age < 18 {
 println!("您未成年");
} else {
 println!("您成年了");
}

注意，if 实际上是表达式而非语句，因此可以拥有值。

let age = 17;
let adulthood = if age < 18 {
 false
} else {
 true
};

Rust 是一门基于表达式的语言，这仅仅是冰山一角。读者在实际采用 Rust 编程时将会对这一设计有更深刻的理解。

说明

与 C++ 的对照

Rust 中没有 C/C++ 中常见的三元表达式，但是可以用 if-else 表达式来实现相同的功能。

循环语句

`for` 循环

for 循环用于遍历容器中的每一个元素，这与 C 风格的 for 循环大为不同，而与 Python 更加类似。

Rust 的函数

Mon, 01 Jan 0001 00:00:00 +0000

Rust 中的函数

函数声明

Rust 中通过 fn 关键字声明函数，在函数名后的括号内声明参数（必须指定类型），在 -> 后面指定返回类型（如果没有，可以不加）。

fn func_1() {
 println!("Hello");
} // 无参数，无返回值的函数
// 无返回值的函数，会默认返回 单位元 ()

fn func_with_param(i: u32, j: u32) {
 println!("I love you {} times", i + j);
} // 有参数的函数

fn func_with_return_value(i: i32, j: i32) -> i32 {
 return i + j;
} // 有返回值的函数

fn func_with_return_value_mod(i: i32, j: i32) -> i32 {
 i + j
}
// 在有返回值的函数中，return 语句并不是必需的。在这里
// 由大括号包裹的代码块是一个表达式，i + j 就是表达式的值，
// 同样也就是函数的返回值。

说明

与 C++ 的对照

Rust 模式匹配

Mon, 01 Jan 0001 00:00:00 +0000

Rust 的枚举和匹配

枚举类型

Rust 的枚举通过关键字 enum 定义。

enum CoinType {
 Dime, // 一角
 Half, // 五角
 Yuan, // 一元
} // 这个枚举量仅仅标定了硬币的类型

struct Coin {
 kind: CoinType,
 value: u32
} // 这个结构体记录了硬币的类型和对应的面值

let coin = Coin {
 kind: CoinType::Dime,
 value: 10
};

枚举的每种变体 (variant) 可以:

没有数据(单位元变体)
有命名的数据域(结构体变体)
有不命名的有序数据域(元组变体)

enum Resultish { 
 Ok,
 Warning { code: i32, message: String },
 Err(String)
}

说明

与 C++ 的对照

Rust 的结构体

Mon, 01 Jan 0001 00:00:00 +0000

Rust 的结构体

结构体类型

说明

与 C++ 的对照

C++ 的 struct 本质上是默认 public 的 class，因此我们接下来仅讨论 Rust struct 和 C++ class 的区别。 Rust 中没有“类”的概念，但是保留了结构体。

struct Person {
 age: u32,
 name: String
}

let alice = Person {
 age: 20,
 name: String::from("Alice")
}

结构体方法

结构体可以有方法和关联函数，在 impl 块中实现。包含 self、&self 或 &mut self 的函数为方法，由 结构体.方法名() 调用；不包含的为关联函数，用 结构体名::关联函数名() 的方式调用。

impl Person {
 fn new(age: u32, name: String) -> Self {
 Self {
 age: age,
 name: name
 }
 }
 fn hello(&self) {
 println!("Hello! My name is {}.", name);
 }
}

let bob = Person::new(19, String::from("Bob"));
bob.hello();

执行以上代码将输出：

Rust 的特型

Mon, 01 Jan 0001 00:00:00 +0000

Rust 的特型

Rust 具有与 C++ 完全不同的面向对象，Rust 中没有继承的机制，对于“不同类共享相同的行为”这样的要求，Rust 使用一个叫做 trait 的机制来实现。

说明

组合优先于继承

Rust 特型机制的核心思想在于**“组合优先于继承”**，这种设计理念使得相比较于 C++ 更关注于抽象的类的继承关系，Rust 更关注每个对象的特性，通过特性的组合来定义一个完整的对象。

比如，我们想要定义一个鸟类，我们在鸟类中实现了非常多的特性。这个时候我们想把企鹅也加入到我们的系统中，企鹅也是鸟，但是企鹅不会飞。那这怎么解决呢？我们不得不重构我们的代码，比如再重新定义一个会飞的鸟和不会飞的鸟，然后共同继承自抽象鸟。然后我们还得把要求输入参数为鸟的函数都给按照实际情况改成抽象鸟或者会飞的鸟。过了一会，蝙蝠又要加入。蝙蝠在飞行方面和鸟很像，但确是哺乳动物，继续重构。不知不觉中我们的代码也越来越抽象了。

那如果用组合该如何解决这个问题呢？我们不必把所有鸟类共性都放到鸟类里面，而是可以把每一个共性单独定义成一个Trait，然后我想要能飞能吃饭且生物学上是鸟类的生物的时候可以把参数约束成Fly+Eat+BiologicallyBird ，只想要飞而不关心是不是鸟的时候可以约束成Fly。这样我们就可以很方便地组合出我们想要的生物了。

（参考自zhc7的2024暑培讲义） Rust 的 trait 机制通过如下代码实现：

struct Cat {}

struct Dog {}

trait CanMakeSound {
 fn make_sound(&self) -> String;
}

上文定义了一个叫做 CanMakeSound 的 trait，在其中声明了 make_sound 方法而没有实现。如果要为一个类型实现 trait，则需要实现该 trait 的所有方法。实现 trait 的语法形如 impl 特性名 for 类型名。

impl CanMakeSound for Cat {
 fn make_sound(&self) -> String {
 String::from("Meow")
 }
}

impl CanMakeSound for Dog {
 fn make_sound(&self) -> String {
 String::from("Woof")
 }
}

在一个类型实现该 trait 后，这个类型的变量就可以使用其方法。

Rust 的泛型

Mon, 01 Jan 0001 00:00:00 +0000

Rust 的泛型

Rust 中的泛型通过如下方式实现：

泛型函数

fn foo<T, U>(x: T, y: U) {
}

泛型枚举

enum Result<T, E> {
 Ok(T),
 Err(E), 
}

泛型结构体

struct Point<T> {
 x: T,
 y: T, 
}

impl<T> Point<T> // 在 impl 代码段开头声明泛型
where
 T: std::ops::Add<Output = T> + std::ops::Mul<Output = T> + Copy,
{
 fn distance_from_origin(&self) -> T {
 self.x * self.x + self.y * self.y
 }
}

Option 和 Result 类型

Rust 提供了两个非常方便的枚举类型：Option 和 Result。

enum Option<T> { 
 None,
 Some(T), 
}

enum Result<T,E> {
 Ok(T),
 Err(E),
}

合理地运用这两个枚举类型，可以便捷地传递参数、捕获错误。

Rust 语言基础 on ClearSec Wiki

Rust 入门的一点经验

给入门 Rust 人的一点经验

好的编程环境很重要

多练习

不要害怕编译错误

看文档

你的文档这里写的太简略了！我看不懂怎么办！

Rust 快速入门

Rust 快速入门

Rust 环境安装

开发环境

编译工具链配置

安装 rustup

Rust 的所有权

Rust 中的所有权

变量绑定

借用

借用规则

Rust 的变量与类型

Rust 的变量与类型

变量声明

可变性与不可变性

Rust 的引用与借用

Rust 中的引用

可变与不可变引用

Rust 中的流程控制

Rust 中的流程控制

条件表达式

循环语句

for 循环

Rust 的函数

Rust 中的函数

函数声明

Rust 模式匹配

Rust 的枚举和匹配

枚举类型

Rust 的结构体

Rust 的结构体

结构体类型

结构体方法

Rust 的特型

Rust 的特型

Rust 的泛型

Rust 的泛型

泛型函数

泛型枚举

泛型结构体

Option 和 Result 类型

`for` 循环