rust 快速一览

最新推荐文章于 2024-04-23 17:11:27 发布

pardon110

最新推荐文章于 2024-04-23 17:11:27 发布

阅读量1.1k

点赞数 21

文章标签： rust 算法开发语言

本文链接：https://blog.csdn.net/u011584949/article/details/136326018

版权

Rust

install

rustup
- rustc
- cargo
cargo cmd
- cargo run
- cargo build --release
- cargo install 安装二进制命令
- cargo add .. 安装依赖
- cargo test 运行时 #[cfg(test)] 属性，条件编译生效

language

conditional
- continue/break 支持标签 'tag 跳出
- loop 唯一返回有意义值的循环结构，保证至少被输入一次
- for 语句支持对数组进行迭代(但不支持元组)
  - rust 中没有传统的 for (i = 0; i < 3; i++)
  - 更倾向于使用迭代器(iterator)和 for 循环结构来进行循环操作
type
- array [T;N]
- tuple (T,) t.0
- <T=b> 表示在泛型类型参数T没有明确指定类型的情况下，将使用类型 b 作为默认类型

match

match 支持 guard,

    #[test]
    fn test_match_usage() {
        let input = 'x';
        match input {
            'q' => println!("Quitting..."),
            'a' | 's' | 'w' | 'd' => println!("Movining..."),
            '0'..='9' => println!("number input"),
            key if key.is_lowercase() => println!("Lowercase: {key}"),
            _ => println!("other..."),
        }
    }

let 控制流

if let 表达式
while let
let else expressions
- “else” 分支必须执行不同的结束方式, 如 return、break 或 panic
let else

fn hex_or_die_trying(maybe_string: Option<String>) -> Result<u32, String> {
    let Some(s) = maybe_string else {
        return Err(String::from("got None"));
    };

    let Some(first_byte_char) = s.chars().next() else {
        return Err(String::from("got empty string"));
    };

    let Some(digit) = first_byte_char.to_digit(16) else {
        return Err(String::from("not a hex digit"));
    };

    return Ok(digit);
}

references
- let mut x_coord: &i32 vs let x_coord: &mut i32
  - 前者是共享引用，可以改变目标值 x_coord
  - 后者是独占引用，可以改变持有的引用值内容，但不可改变目标值 x_coord
- rust 中只有可变变量才能创建可变引用
```
fn main() {
    let mut x = 5;
    let y = &mut x; // 创建对可变变量 x 的可变引用 y
    *y += 1; // 通过可变引用修改变量 x 的值
    println!("x: {}", x); // 输出修改后的 x 的值
}
```
Macros
- assert_ne assert_eq assert
Error
- e @ Err(_) vs Err(e)
  - 前者 e 值绑定 Err(_), 后者绑定 _
std lib
- core 嵌入式常用，大部分不依赖 libc 或操作系统上的分配器
- alloc 全局堆分配器 Vec,Box,Arc
- std

Trait

比较
- PartialEq and Eq (eq 自反性)
- PartialOrd and Ord partial_cmp
运算符
- std::ops Add…
From 和 Into 类型转换
- 实现 From 后，系统会自动实现 Into
as 显式强制类型转换
Read 和 Write 对 u8 来源进行抽象化处理
Default 为类型生成默认值
- 可以通过 #[derive(Default)] 派生出它
- 若为结构体，则其中所有类型也都必须实现 Default
闭包 Fn FnMut FnOnce
- 默认情况下，闭包会依据引用来捕获数据（如果可以的话）
- move 关键字则可让闭包依据值来捕获数据

支持trait 嵌套组合

示例

    trait TraitA {
    fn method_a(&self);
    }

    trait TraitB {
        fn method_b(&self);
    }

    trait CombinedTrait: TraitA + TraitB {
        fn combined_method(&self) {
            self.method_a();
            self.method_b();
        }
    }

动态分发
- Box<dyn Pet>

Mem

程序分配内存
- 栈：局部变量的连续内存区域。
  - 值在编译时具有已知的固定大小。
  - 速度极快：只需移动一个栈指针。
  - 易于管理：遵循函数调用规则。
  - 优秀的内存局部性。
- 堆：函数调用之外的值的存储。
  - 值具有动态大小，具体大小需在运行时确定。
  - 比栈稍慢：需要向系统申请空间。
  - 不保证内存局部性。
内存管理方法
- 通过手动内存管理实现完全控制： c, c++,pascal...
- 运行时通过自动内存管理实现完全安全： java,python,go..
- Rust通过编译时强制执行正确内存, 基于明确的所有权实现
移动语义
- 默认移动语义，但实现Copy trait类型则会默认复制
- 在Rust中，克隆是显式的
  - 通常的做法是，先使用克隆操作解决借用检查器问题，在后续通过优化消除这些克隆操作
Copy VS Clone
- 复制是指内存区域的按位复制，不适用于任意对象。
- 复制不允许自定义逻辑（不同于 C++ 中的复制构造函数）。
- 克隆是一种更通用的操作，也允许通过实现 Clone trait 来自定义行为。
- 复制不适用于实现 Drop trait 的类型。
std::mem::drop
- 只是一个采用任何值的空函数。
- 重要的是它获得了值的所有权，因此在其作用域结束时便会被丢弃
references 借用检查
- shared references 一个或多个共享引用，只读
- exclusive reference 独占引用，可读写
内部可变性 Interior Mutability

持有共享引用又可以改变数据
- Cell 非运行时借用检查, 使用&self移动语义通过get/set支持内部可变
- RefCell 强制运行时借用检查 borrow/borrow_mut
- Rc 多引用计数允许只读访问，不支持内部可变性
slice
- 切片提供对集合 collections 的视图 view
- 切片从被切片的类型中借用borrow
- 等价
  - &a[0…a.len()] 与 &a[…a.len()]
  - &a[2…a.len()] &a[2…]
  - &a[…]
lifetimes
- 函数
  - 每个没有生命周期注解的参数都会添加一个生命周期注解
  - 如果只有一个参数生命周期，则将其赋予所有未加注解的返回值
  - 如果有多个参数生命周期，但第一个是self的，则将该生命周期赋予所有未加注解的返回值
- 结构体
  - 如果数据类型存储了借用的数据，则必须对其添加生命周期注解
迭代器 (next方法决定迭代视图)
- Iterator 迭代器操作
  - 元素操作 next map filter...
  - 迭代器方法 for 循环, collect 方法…
- IntoIterator into_iter
  - IntoIterator::into_iter 获取 self 所有权
- FromIterator collect
  - FromIterator 可通过 Iterator 构建一个集合
  - implementations of FromIterator for Vec, HashMap, etc

Mod

crate 根目录
- src/lib.rs（对于库 crate, 入口文件）
- src/main.rs（对于二进制文件 crate）
层次结构
- 若省略模块内容，则会指示 Rust 在另一个文件中查找:
```
    mod garden;
```
- module/mod.rs rust2018 之前
- 引入filename.rs 来替代filename/mod.rs
- 即使主模块是文件，更深层次嵌套也可以使用文件夹
```
    src/
    ├── main.rs
    ├── top_module.rs
    └── top_module/
        └── sub_module.rs
```
- Rust 寻找模块的位置可通过编译器指令更改
```
    #[path = "some/path.rs"]
    mod some_module;
```
可见性
- 默认情况下，模块项是私有的
- 父项和同级子项始终可见
- pub(crate) 关键字来指定一个项（函数、结构体、枚举等）在当前 crate 中可见，但在其他 crate 中不可见。
路径
- pub use 重新导出
- foo 或 self::foo 是指当前模块中的 foo
- crate::foo 是指当前 crate 的根中的 foo 绝对路径
- bar::foo 是指bar crate 中的foo，绝对路径

Test

在 Rust 中，空的代码块 {} 是一个表达式，它的值是 ()，表示一个空的元组
test/ 目录支持集成测试
lint / Clippy 静态代码分析工具

    fn main() {
        println!("length: {}", collatz_length(11));
    }

    fn collatz_length(mut n: i32) -> u32 {
        let mut len= 1;

        while n > 1 {
            n = if n % 2 == 0 { n / 2 } else { 3 * n + 1 };
            len += 1;
        }
        len
    }

    #[test]
    fn test_collatz_length() {
        assert_eq!(collatz_length(11),15);
    }