Rust

Jackcui NJU Loser
  2023-07-10 19:34 2023-07-10 19:34 Created   2024-11-04 12:58:38 2024-11-04 12:58 Updated    3.2k Words  13 Mins  

Preface

正好最近ZR先生暑校在学OOP，就临时抽出几天时间来跟一下。
学一下Rust，后续研究研究Tauri框架
笔记性质，内容来自菜鸟教程(Runoob)

Rust 环境配置

懒了，先用在线环境吧。。。

Cargo 包管理器

说实话学编程语言真的没什么可以记录的

语言基础

println!() 和 print!()。这两个”函数”都是向命令行输出字符串的方法，区别仅在于前者会在输出的最后附加输出一个换行符。

输出类似于Python的format

格式字符串中通过 分别转义代表 { 和 }。但是其他常用转义字符与 C 语言里的转义字符一样，都是反斜杠开头的形式。

Declaring Variables

1
let x = 5;
1
2
3
a = "abc"; //错，类型不同
a = 4.56; //错，Rust不允许损失精度的强制类型转换
a = 456; //错，这是个“不可变变量”
可变变量
1
2
let mut x = 5;
x = 6;

不可变变量不是常量，不可变变量是可以被rebind的，但是不能被改变，也就是重新开辟一个内存空间
而可变变量的再赋值是在原内存空间上进行的

变量的值可以”重新绑定”（常量不可以），但在”重新绑定”以前不能私自被改变，这样可以确保在每一次”绑定”之后的区域里编译器可以充分的推理程序逻辑。 ？？？？？？？？

“重新绑定”被称为”shadowing”，非常类似于Python中的assignment

Types

  • Integer
    i/u 8/16/32/64/128
    arch-dependent isize/usize
    f 32/64(default)
    支持自运算，不支持++，–
  • bool
  • char
    一般推荐使用字符串储存 UTF-8 文字
    在 Rust 中字符串和字符都必须使用 UTF-8 编码，否则编译器会报错。
  • tup
  • 数组，跟Python有一点点类似，但是默认都是不可变的
    粘过来一点示例
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    let a = [1, 2, 3, 4, 5];
    // a 是一个长度为 5 的整型数组

    let b = ["January", "February", "March"];
    // b 是一个长度为 3 的字符串数组

    let c: [i32; 5] = [1, 2, 3, 4, 5];
    // c 是一个长度为 5 的 i32 数组

    let d = [3; 5];
    // 等同于 let d = [3, 3, 3, 3, 3];

    let first = a[0];
    let second = a[1];
    // 数组访问

    a[0] = 123; // 错误：数组 a 不可变
    let mut a = [1, 2, 3];
    a[0] = 4; // 正确

Annotation

形似C
三个正斜杠 /// 依然是合法的注释开始。所以 Rust 可以用 /// 作为说明文档注释的开头
可以显示在 IDE 中
Cargo 具有 cargo doc 功能，开发者可以通过这个命令将工程中的说明注释转换成 HTML 格式的说明文档。

Function

fn <函数名> ( <参数> name: type ) <函数体>
不要求顺序

1
2
3
4
{
    let x = 3;
    x + 1
};

块中可以使用函数语句，最后一个步骤是表达式，此表达式的结果值是整个表达式块所代表的值。这种表达式块叫做函数体表达式。
道理有点类似于lambda表达式
返回值必须指明，否则认为是纯过程

1
2
3
fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

Control Flow

条件语句非常类似于C
两个区别

  1. 不能用单语句代替块(必须用花括号)
  2. 条件可以不写小括号

条件语句并不是非零即真，而必须是bool！
条件的选项当然也可以是函数体表达式

1
2
3
4
5
fn main() {
    let a = 3;
    let number = if a > 0 { 1 } else { -1 };
    println!("number 为 {}", number);
}

为什么if外面不需要花括号？？？？？？？？

循环while类似于C，区别同if/else
for循环类似于Python,还有一种有趣的整形遍历

1
2
3
for i in 0..5 {
        println!("a[{}] = {}", i, a[i]);
    }

无限循环 loop
还可以有返回值的循环
break ...;
这里究竟是函数还是表达式？？？？？？？？

Rust 高级特性

所有权（关于内存分配）

可行域类似。
在可行域结束后Rust自动释放内存。

变量与数据交互

  • 移动
    • 数据在栈中
      基本类型数据，整形，浮点，布尔，字符和只包括前四个的元组。
      直接复制数据。
    • 数据在堆中
      为了方便回收，当一个新指针指向一个堆中的数据时，原来的指针就会被废弃。
      赋值给其他变量之后，原来的变量就不能再使用了。
      图片.png
  • 克隆
    在堆中复制一份绑定上去（指针还是一对一
  • 引用
    可以用s2 = &s1来引用s1,相当于是s2指向s1的指针，s1相当于一个proxy
    引用只是借用值，不会获得值的所有权。
    引用本身也是一个类型（就像是指针类型）
    如果租借完之后原来的所有权被转让，那么就无法访问了，除非重新租借
    A有一所房子，B可以住，但是A也可以卖掉房子，B就要被赶走了
    B不可以改动房子，但如果合同签好了可以改就可以改，s2 = &mut s1
    可变引用只能有一个（也不能再有不可变引用），不可变引用可以有多个
    可以看出这样避免了数据竞争。
  • 有所有权机制的保证，Rust可以在编译时检查出空指针和飘飞的指针，从而在编译阶段避免这些问题。
一个非常重要的示例
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
 fn main() {
    let s = String::from("hello");
    // s 被声明有效

    takes_ownership(s);
    // s 的值被当作参数传入函数
    // 所以可以当作 s 已经被移动，从这里开始已经无效

    let x = 5;
    // x 被声明有效

    makes_copy(x);
    // x 的值被当作参数传入函数
    // 但 x 是基本类型，依然有效
    // 在这里依然可以使用 x 却不能使用 s

} // 函数结束, x 无效, 然后是 s. 但 s 已被移动, 所以不用被释放


fn takes_ownership(some_string: String) {
    // 一个 String 参数 some_string 传入，有效
    println!("{}", some_string);
} // 函数结束, 参数 some_string 在这里释放

fn makes_copy(some_integer: i32) {
    // 一个 i32 参数 some_integer 传入，有效
    println!("{}", some_integer);
} // 函数结束, 参数 some_integer 是基本类型, 无需释放

如果将变量当作参数传入函数，那么它和移动的效果是一样的。

令一个非常重要的示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
fn main() {
    let s1 = gives_ownership();
    // gives_ownership 移动它的返回值到 s1

    let s2 = String::from("hello");
    // s2 被声明有效

    let s3 = takes_and_gives_back(s2);
    // s2 被当作参数移动, s3 获得返回值所有权
} // s3 无效被释放, s2 被移动, s1 无效被释放.

fn gives_ownership() -> String {
    let some_string = String::from("hello");
    // some_string 被声明有效

    return some_string;
    // some_string 被当作返回值移动出函数
}

fn takes_and_gives_back(a_string: String) -> String { 
    // a_string 被声明有效

    a_string  // a_string 被当作返回值移出函数
}

被当作函数返回值的变量所有权将会被移动出函数并返回到调用函数的地方，而不会直接被无效释放。

  • 引用
    当一个变量的值被引用时，变量本身不会被认定无效。因为”引用”并没有在栈中复制变量的值
    图片.png
    栗子
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
      // Code 1
      fn main() {
        let s1 = String::from("hello");

        let len = calculate_length(&s1);

        println!("The length of '{}' is {}.", s1, len);// 正确
    }

    fn calculate_length(s: &String) -> usize {
        s.len()
    }
      // Code 2
      fn main() {
        let s1 = String::from("hello");

        let len = calculate_length(s1);

        println!("The length of '{}' is {}.", s1, len);// 错，没有所有权！
    }

    fn calculate_length(s: String) -> usize {
        s.len()
    }
    引用不会获得值的所有权。
    引用只能租借（Borrow）值的所有权。
    引用本身也是一个类型并具有一个值，这个值记录的是别的值所在的位置，但引用不具有所指值的所有权
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    fn main() {
        let s1 = String::from("hello");
        let s2 = &s1;
        let s3 = s1;
        println!("{}", s2);// 错误！所有权发生变更，s2需要重新租借
        // 注意，此处的报错一般是所有权被租借后不能转让，这种描述似乎不准确，如下
    }
    fn main() {
        let s1 = String::from("hello");
        let mut s2 = &s1;
        let s3 = s1;
        let s2 = &s3;
        println!("{}", s2);
        //这段程序是正确的，此处可以看出在所有权租借状况下可以变更，本质还是重新租借的问题。
        //注意Rust是编译型语言，不同于解释型语言，它的编译语法检查是上下文敏感的。
        //不知道说的对不对。。。
    }
    租借来使用权的变量不能修改值，只有使用权，没有处置权。
    也可以授予处置权：&mut（后面就不用&了）
    可变引用不允许多重引用，但不可变引用可以。
    】

结构体

所有权问题，结构体必须具备所有字段的所有权，因此一般不能用引用

打印结构体
导入#[derive(Debug)]宏，然后println!("{:?}", 结构体名);或者println!("{:#?}", 结构体名);（更美观）

结构体方法

第一个参数必须是&self,不需要声明类型
用impl关键字在结构体外部实现方法

结构体关联函数

类似于Python的类方法，没有self参数
使用的时候结构体名::函数名
好像就是个关联，没有什么特别实际的意义。

文件组织

根是crate
路径是用::分隔的
文件是模块，模块是树状结构
绝对路径：crate::a::b::c
相对路径：super::a或者self::a

以模块为单位组织
默认是私有的，可以用pub关键字公开
模块中的结构体也是私有的，可以用pub公开
字段也是私有的，可以用pub公开

use关键字可以导入模块,as关键字可以别名
pub use可以将模块公开？

枚举

类似于C的枚举

1
2
3
4
enum IpAddrKind {
    V4,
    V6,
}

可以带有数据

1
2
3
4
enum IpAddr {
    V4(String),
    V6(String),
}

也可以是不同类型

1
2
3
4
enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

甚至可以含有结构体

1
2
3
4
5
6
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

match

类似于switch

1
2
3
4
5
6
fn route(ip_type: IpAddrKind) {
    match ip_type {
        IpAddrKind::V4 => println!("V4"),
        IpAddrKind::V6 => println!("V6"),
    }
}

可以带有值

1
2
3
4
5
6
fn route(ip_type: IpAddr) {
    match ip_type {
        IpAddr::V4(s) => println!("V4: {}", s),
        IpAddr::V6(s) => println!("V6: {}", s),
    }
}

match语句也可以当作表达式来返回值，但所有的分支都必须返回相同类型的值

1
2
3
4
5
6
fn route(ip_type: IpAddr) -> String {
    match ip_type {
        IpAddr::V4(s) => format!("V4: {}", s),
        IpAddr::V6(s) => format!("V6: {}", s),
    }
}

不只是枚举类型，match也可以用于别的类型
但需要用_来匹配其他情况

if let

1
2
3
if let 匹配值 = 源变量 {
    语句块
}

类似于两个类的match语句的简化版
还可以有else语句

异常处理

panic!宏可以抛出异常

可恢复异常：
Result枚举类型，Ok和Err两种情况

1
2
3
4
enum Result<T, E> {
    Ok(T),
    Err(E),
}

标准库里可以产生异常的函数都返回Result类型
一个不错的写法

1
2
3
4
5
6
7
8
9
10
use std::fs::File;

fn main() {
    let f = File::open("hello.txt");
    if let Ok(file) = f {
        println!("File opened successfully.");
    } else {
        println!("Failed to open the file.");
    }
}

自己写的函数呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
fn f(i: i32) -> Result<i32, bool> {
    if i >= 0 { Ok(i) }
    else { Err(false) }
}

fn g(i: i32) -> Result<i32, bool> {
    let t = f(i)?;
    Ok(t) // 因为确定 t 不是 Err, t 在这里已经是 i32 类型
}

fn main() {
    let r = g(10000);
    if let Ok(v) = r {
        println!("Ok: g(10000) = {}", v);
    } else {
        println!("Err");
    }
}

? 符的实际作用是将 Result 类非异常的值直接取出，如果有异常就将异常 Result 返回出去。所以，? 符仅用于返回值类型为 Result<T, E> 的函数，其中 E 类型必须和 ? 所处理的 Result 的 E 类型一致。

用kind方法可以获取错误类型
像try catch一样的用法

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

use std::io;
use std::io::Read;
use std::fs::File;

fn read_text_from_file(path: &str) -> Result<String, io::Error> {
    let mut f = File::open(path)?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

fn main() {
    let str_file = read_text_from_file("hello.txt");
    match str_file {
        Ok(s) => println!("{}", s),
        Err(e) => {
            match e.kind() {
                io::ErrorKind::NotFound => {
                    println!("No such file");
                },
                _ => {
                    println!("Cannot read the file");
                }
            }
        }
    }
}
  • Post title：Rust
  • Post author：Jackcui
  • Create time：2023-07-10 19:34:00
  • Post link：https://jackcuii.github.io/2023/07/10/Rust/
  • Copyright Notice：All articles in this blog are licensed under BY-NC-SA unless stating additionally.
 Comments
On this page
Rust
  1. Preface
  2. Rust 环境配置
  3. Cargo 包管理器
  4. 语言基础
    1. Declaring Variables
    2. Types
    3. Annotation
    4. Function
    5. Control Flow
  5. Rust 高级特性
    1. 所有权（关于内存分配）
      1. 变量与数据交互
    2. 结构体
      1. 结构体方法
      2. 结构体关联函数
    3. 文件组织
    4. 枚举
      1. match
      2. if let
    5. 异常处理