当前位置：首页>后端>正文

Rust标准库

后端2024-05-03 04:19:47

[TOC]

Rust标准库

Rust中的智能指针Box

Box 允许将一个值放在堆上而不是栈上，留在栈上的则是指向堆数据的指针。Box 是一个指向堆的智能指针，当一个 Box 超出作用域时，它的析构函数被调用，内部对象被销毁，堆上的内存被释放。

fn main() {
    let b = Box::new(5);
    println!("b = {}", b);
}

Box 没有运行上的性能损失，虽然如此，但它却只在以下场景中比起默认的栈上分配更适用：

当有一个在编译时未知大小的类型，而又想要在需要确切大小的上下文中使用这个类型值的时候
当有大量数据并希望在确保数据不被拷贝的情况下转移所有权的时候
当希望拥有一个值并只关心它的类型是否实现了特定 trait 而不是其具体类型的时候

场景1代码示例：

// 场景1：当有一个在编译时未知大小的类型，而又想要在需要确切大小的上下文中使用这个类型值的时候
// 例如递归的类型，自己可以包含自己
// ConsList 每一项包含两个元素：当前项和下一项，若为Nil则是结束项
// ConsList(0, ConsList(1, ConsList(2, Nil)))
enum List {
    Cons(i32, Box<List>),
    Nil,
}

fn example1() {
    let list = List::Cons(0, Box::new(List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))))));
}

场景2代码示例：

// 场景2：当有大量数据并希望在确保数据不被拷贝的情况下转移所有权的时候
fn example2() {
    let a = [0; 1024 * 512];
    let a_box = Box::new(a);
    // 这两种写法等价，都会先在栈上分配数据，然后再拷贝数据到堆上，不过后面再转移所有权时不会再拷贝数据，只会转移地址
    let a_box2 = Box::new([0; 1024 * 512]);
}

场景3代码示例：

// 场景3：当希望拥有一个值并只关心它的类型是否实现了特定 trait 而不是其具体类型的时候
fn example3() -> Result<(), Box<dyn std::error::Error>>{
    let f = std::fs::read("/tmp/not_exist")?;
    Ok(())
}

Rust中的引用计数Rc

你可以将 Rc 看作 Box 的高级版本：它是带引用计数的智能指针。只有当它的引用计数为 0 时，数据才会被清理。

考虑我们上一小节提到的 ConsList 场景，如果多个节点共享一个节点，例如：

0 -> 1 \
        |-> 4
2 -> 3 /

节点 4 它所拥有的值会有多个所有者，这个时候就需要使用 Rc 来进行包装。

代码示例：

use std::rc::Rc;

enum List2 {
    Cons(i32, Rc<List2>),
    Nil,
}

fn rc_example() {
    // 通过Rc可以实现一个值可以有多个所有者
    let four = Rc::new(List2::Cons(4, Rc::new(List2::Nil)));
    // 调用 clone 时，Rc的引用计数会加一
    let zero_one = List2::Cons(0, Rc::new(List2::Cons(1, four.clone())));
    // 另一种等价写法
    // let zero_one = List2::Cons(0, Rc::new(List2::Cons(1, Rc::clone(&four))));
    let two_three = List2::Cons(2, Rc::new(List2::Cons(3, four)));
}

Rust中的Vector动态数组

Vector 是动态大小的数组。与切片一样，它们的大小在编译时是未知的，但它们可以随时增长或收缩，向量使用 3 个参数表示：

指向数据的指针
长度
容量

容量表示为向量预留了多少内存。一旦长度大于容量，向量将申请更大的内存进行重新分配：

fn main() {
    let mut v: Vec<i32> = Vec::new();
    v.push(1);
    println!("{:?}", v[0]);
    
    // 通过宏创建Vector的写法
    let v2: Vec<i32> = vec![0, 1, 2, 3, 4, 5];
    println!("{:?}", v2[2]);
    
    // 修改Vector内的元素值
    for e in v.iter_mut() {
        *e *= 2;
    }
}

Rust中的HashMap

HashMap 是一种从 Key 映射到 Value 的数据结构。与 Vector 一样，HashMap 也是可以动态调整大小的，可以使用以下方法创建一个 HashMap：

use std::collections::HashMap;

fn main() {
    let map = HashMap::new();
    map.insert("key", "value");
    println!("{:?}", map.get(&"key"));
    map.remove(&"key");
    
    for (&k, &v) in map.iter() {
        println!("{:?} {:?}", k, v);
    }
}

大多数数据类型都可以作为 HashMap 的 Key，只要它们实现了 Eq 和 Hash traits。

Rust 中的多种字符串String

Rust 里表示“字符串”有多种方式，你可能已经见过 str，&str 与 String，但它们之间有什么区别？如果我想使用“字符串”类型，我应当如何使用？

fn  main() {

    let  s  =  "Hello World!";

    // "Hello World!" 是字符串字面量, 它直接存储在二进制文件中. 我们无法直接操作这些数据,
    // 必须借由 &str, 即它的引用来与之交互. 由于 "Hello World!" 存在二进制文件中, 因此它
    // 具有静态生命周期: 它在程序的整个运行期间都有效.

    // 变量 s 的类型是 &str, 表明它是 str 的一个引用. 但 str 是什么str 是存储在内存中的
    // 字符串数据. 这里的内存可以是栈, 可以是堆, 也可以是数据段(二进制文件中). &str 是对 str
    // 的引用.

    let  t  =  String::from(s);

    // t 的类型是 String. String 存在堆中, 是一个可增长的缓冲区, 它拥有它的数据, 因此我们
    // 可以修改 t 的内容.

}

通常情况下：

你几乎不会用到 str 类型
如果你在定义一个函数，该函数接收字符串类型，那么请使用 &str
如果你在定义一个结构体，结构体中包含一个字符串成员，那么使用 String 是更好的选择

Rust中的系统时间SystemTime

在程序中处理时间是一个常见的需求，我们来看下如何在 Rust 中处理时间相关的功能：

use std::thread::sleep;
use std::time::{Duration, SystemTime};

fn main() {
    // 获取当前时间
    let mut now = SystemTime::now();
    println!("{:?}", now);

    // 获取 UNIX TIMESTAMP
    let timestamp = now.duration_since(SystemTime::UNIX_EPOCH);
    println!("{:?}", timestamp);

    sleep(Duration::from_secs(4));

    // 获取流逝的时间
    println!("{:?}", now.elapsed());

    // 时刻的增减
    now.checked_add(Duration::from_secs(60))
}

如果你需要处理日期，可以使用第三方库 chrono

查看全文

https://www.xamrdz.com/backend/35h1941201.html

Rust标准库

Rust中的智能指针Box

Rust中的引用计数Rc

Rust中的Vector动态数组

Rust中的HashMap

Rust 中的多种字符串String

Rust中的系统时间SystemTime

相关文章：