《Rust快速入门》14. 高级主题

January 18, 2025

高级主题：Rust 中的不安全代码、生命周期与高级特性

Rust 是一门以安全性著称的系统编程语言，但它也提供了 unsafe 关键字，允许开发者绕过编译器的安全检查，直接操作内存和硬件。此外，Rust 的生命周期系统是确保内存安全的核心机制之一。本文还将介绍 Rust 的一些高级特性，如运算符重载和 Deref trait。通过完整的代码示例和详尽的指导过程，本文将帮助读者深入理解这些高级主题。

1. 不安全代码（`unsafe`）

1.1 `unsafe` 关键字的使用场景

unsafe 关键字用于标记不安全的代码块或函数。在 unsafe 块中，开发者可以执行以下操作：

解引用裸指针（*const T 和 *mut T）。
调用不安全的函数。
访问或修改可变静态变量。
实现不安全的 trait。

示例 1：解引用裸指针

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


fn main() {
    let mut num = 5;

    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;

    unsafe {
        println!("r1 is: {}", *r1);
        println!("r2 is: {}", *r2);
    }
}

解释：

let r1 = &num as *const i32; 创建一个不可变裸指针。
let r2 = &mut num as *mut i32; 创建一个可变裸指针。
unsafe { ... } 块中解引用裸指针。

示例 2：调用不安全的函数

1
2
3
4
5
6
7
8
9


unsafe fn dangerous() {
    println!("This is an unsafe function");
}

fn main() {
    unsafe {
        dangerous();
    }
}

解释：

unsafe fn dangerous() 定义了一个不安全的函数。
unsafe { dangerous(); } 调用不安全的函数。

1.2 实现不安全的 trait

某些 trait 可能要求实现者保证特定的行为，这时需要使用 unsafe 关键字。

示例 3：实现不安全的 trait

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


unsafe trait MyUnsafeTrait {
    fn do_something(&self);
}

struct MyStruct;

unsafe impl MyUnsafeTrait for MyStruct {
    fn do_something(&self) {
        println!("Doing something unsafe");
    }
}

fn main() {
    let my_struct = MyStruct;
    my_struct.do_something();
}

解释：

unsafe trait MyUnsafeTrait 定义了一个不安全的 trait。
unsafe impl MyUnsafeTrait for MyStruct 为 MyStruct 实现了不安全的 trait。

2. 生命周期

2.1 生命周期标注

生命周期标注用于描述引用的有效范围，确保引用不会变成悬空引用。

示例 4：生命周期标注

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string is long");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {}", result);
}

解释：

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str 定义了一个带有生命周期标注的函数。
'a 是生命周期参数，表示 x 和 y 的生命周期至少与 'a 一样长。
返回值的生命周期也与 'a 相同。

2.2 结构体中的生命周期

结构体可以包含引用，但需要显式标注生命周期。

示例 5：结构体中的生命周期

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let i = ImportantExcerpt {
        part: first_sentence,
    };

    println!("Important excerpt: {}", i.part);
}

解释：

struct ImportantExcerpt<'a> { ... } 定义了一个包含引用的结构体。
part: &'a str 是结构体的字段，其生命周期与 'a 相同。

3. 高级特性

3.1 运算符重载

Rust 允许通过实现 std::ops 中的 trait 来重载运算符。

示例 6：运算符重载

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


use std::ops::Add;

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point;

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 3, y: 4 };
    let p3 = p1 + p2;

    println!("{:?}", p3); // 输出：Point { x: 4, y: 6 }
}

解释：

impl Add for Point 为 Point 实现了 Add trait。
type Output = Point 定义了运算符的返回类型。
fn add(self, other: Point) -> Point 实现了加法运算。

3.2 `Deref` trait

Deref trait 用于自定义解引用操作。

示例 7：实现 `Deref` trait

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


use std::ops::Deref;

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

impl<T> Deref for MyBox<T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.0
    }
}

fn main() {
    let x = 5;
    let y = MyBox::new(x);

    assert_eq!(5, *y);
}

解释：

impl<T> Deref for MyBox<T> 为 MyBox 实现了 Deref trait。
fn deref(&self) -> &T 返回内部值的引用。
*y 解引用 MyBox，获取内部值。

4. 综合示例

以下是一个综合示例，展示了不安全代码、生命周期和高级特性的结合使用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


use std::ops::{Deref, Add};
use std::fmt;

#[derive(Debug)]
struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

impl<T> Deref for MyBox<T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.0
    }
}

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point;

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    // 使用 MyBox
    let x = 5;
    let y = MyBox::new(x);
    assert_eq!(5, *y);

    // 使用 Point 和运算符重载
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 3, y: 4 };
    let p3 = p1 + p2;
    println!("{:?}", p3); // 输出：Point { x: 4, y: 6 }

    // 使用不安全代码
    let mut num = 10;
    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;

    unsafe {
        println!("r1 is: {}", *r1);
        println!("r2 is: {}", *r2);
    }
}

解释：

该示例展示了 MyBox 的自定义解引用、Point 的运算符重载以及不安全代码的使用。

5. 总结

Rust 的高级主题包括不安全代码、生命周期和高级特性（如运算符重载和 Deref trait）。通过 unsafe 关键字，开发者可以绕过编译器的安全检查，直接操作内存和硬件；生命周期系统确保了引用的有效性；高级特性则提供了更灵活的代码抽象能力。掌握这些高级主题是编写高效、安全的 Rust 程序的关键。

高级主题：Rust 中的不安全代码、生命周期与高级特性

1. 不安全代码（unsafe）

1.1 unsafe 关键字的使用场景

示例 1：解引用裸指针

示例 2：调用不安全的函数

1.2 实现不安全的 trait

示例 3：实现不安全的 trait

2. 生命周期

2.1 生命周期标注

示例 4：生命周期标注

2.2 结构体中的生命周期

示例 5：结构体中的生命周期

3. 高级特性

3.1 运算符重载

示例 6：运算符重载

3.2 Deref trait

示例 7：实现 Deref trait

4. 综合示例

5. 总结

1. 不安全代码（`unsafe`）

1.1 `unsafe` 关键字的使用场景

3.2 `Deref` trait

示例 7：实现 `Deref` trait