Johan Chane's Blog

This is my blog

Rust 智能指针

JohanChane 发布于 2025-04-26 收录于学习Rust

智能指针

Rust 中的智能指针是一种数据结构，它不仅表现得像一个指针（通过实现 Deref trait），还拥有额外的元数据和功能（最典型的是所有权和生命周期管理）。它们通常使用结构体实现，并实现了 Deref 和 Drop 这两个关键的 trait。

Rust 泛型

JohanChane 发布于 2025-04-25 收录于学习Rust

泛型函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    
    largest
}

fn main() {
    let numbers = vec![34, 50, 25, 100, 65];
    let result = largest(&numbers);
    println!("最大的数字是 {}", result);
    
    let chars = vec!['y', 'm', 'a', 'q'];
    let result = largest(&chars);
    println!("最大的字符是 {}", result);
}

泛型结构体

1
2
3
4
5
6
7
8
9
struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 1.0, y: 4.0 };
}

泛型结构体的实现:

Rust 重借用

JohanChane 发布于 2025-04-25 收录于学习Rust

重借用

可知 Rust 的不能同时有两个以上, 那么如下情况会有矛盾:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
fn increase(cnt: &mut i32) {
    *cnt += 10;
}

fn main() {
    let mut cnt = 10;
    let cnt_ref = &mut cnt;

    // do something

    increase(cnt_ref);    // 同时有两个以上的可变引用?
    increase(cnt_ref);
    println!("{}", cnt_ref);
}

上面情况在实现应用中, 应该会出现。那么 Rust 给出了 “重借用 (reborrowing)” 的概念来允许这种情况:

Rust 常用组合器

JohanChane 发布于 2025-04-20 收录于学习Rust

组合器的作用

一般函数都是返回 Option 或 Result。但是每次都要判断它们是否是 None 或 Err, 再取出 Value 来操作会导致很烦琐, 有些情况下, 用组合器会比较方便。比如: 使用组合器可以链式编程。比如, 处理容器数据:

Rust 面向对象的相关设计

JohanChane 发布于 2025-04-20 收录于学习Rust

面向对象的基本概念

面向对象的三大特性:

封装
继承 (继承接口/实现)
多态

Rust Trait 与面向对象的区别

设计哲学差异：

Rust 引用下的成员不能发生 Move

JohanChane 发布于 2025-04-20 收录于学习Rust

引用下的成员不能发生 move

For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
struct Foo {i: i32, string: String}

impl Foo {
    fn get_data(&self) -> i32 {
        return self.i;                  // 发生 Copy。
    }

    fn get_string(&self) -> String {
        return self.string;             // error. 引用的成员不能发生 Move。
    }

    fn move_string(self) -> String {    // 传拥有资源的标志符 self 才可以
        return self.string
    }
}
fn main() {
}

可见 Rust 比 C++ 在引用方面做了一些更加严格的限制。