539943419/Notebook-StarNet

0 Fork 0

Files

T

539943419 44910b3d68 add rust1

2024-12-14 22:20:19 +08:00

13 KiB

Raw Blame History

Rust 语法学习

用例 1：猜数游戏

生成一个随机 1-100 的数并让玩家猜测


// rust默认隐式引入prelude
// 除了prelude以外都要显式引入
use rand::random;

fn main() {
    // 使用常量定义一个偏置量
    // 常量在编译时就已经确定，所以不能通过如CONST XX = XX()来初始化
    // let声明的不可变变量虽然不可变，但是在编译时默认为未知的。
    const BIAS: u8 = 1;

    println!("guess number game");

    // let: 声明变量，默认不可变
    // mut：声明变量可变
    // String::new()，冒号表示这是一个String类的关联函数
    // 关联函数就是类似于静态方法
    let secret_number = random::<u8>() + BIAS;
    println!("secret number is {}", secret_number);

    // mut使得变量可变
    let mut user_guess: u8 = 0;
    let mut user_input = String::new();
    while user_guess != secret_number {
        // 清空之前的输入
        user_input.clear();

        // io::stdin()：标准输入
        // read_line：读取一行
        // &：取地址符号，表示引用，默认不可变
        // &mut：声明可变引用
        std::io::stdin().read_line(&mut user_input).expect("read fail");
        // 将输入的字符串转换为数字
        // user_guess = user_input.trim().parse().expect("parse fail");
        // 使用 match 表达式判断用户输入的是否为数字
        // 比使用if else更简洁
        user_guess = match user_input.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("please input a number");
                continue;
            }
        };

        // 判断用户输入的数字与随机数的大小关系
        // if user_guess > secret_number {
        //     println!("user number is too large");
        // } else if user_guess < secret_number {
        //     println!("user number is too small");
        // } else {
        //     println!("user number is correct");
        //     break;
        // }
        // 使用 match 表达式判断用户输入的数字与随机数的大小关系
        // 比使用if else更简洁
        match user_guess.cmp(&secret_number) {
            std::cmp::Ordering::Greater => println!("user number is too large"),
            std::cmp::Ordering::Less => println!("user number is too small"),
            std::cmp::Ordering::Equal => {
                println!("user number is correct");
                break;
            }

        }
        println!("user number is {}", user_input);
    }


}

特性： shadow

在同一个作用域内，可以重复声明同名的变量，会覆盖之前的变量

fn main() {
    let x = 5;
    // 重复声明同名的变量，会覆盖之前的变量
    let x = x + 1;
    let x = x * 2;
    println!("The value of x is: {}", x); // 12
}

类型

基本类型

整数类型

整数：i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize
整数类型范围：
- 有符号：-2^n+1 ~ 2^(n-1)-1
- 无符号：0 ~ 2^n-1
isize, usize：取决于运行程序的计算机的架构
表示
- hex: 0x12345678
- oct: 0o12345678
- bin: 0b1010_1010
- Byte: b'A'

浮点数类型

浮点数：f32, f64, 默认是 f64
表示
- 科学计数法：1.23e3
- 小数点：1.23

布尔类型

布尔类型：bool
表示
- true, false

字符类型

字符类型：char
表示
- 'a', 'A', '1', '中'
- 单引号表示
占用 4 字节

复合类型

元组类型（Tuple）

可以将多个类型的多个值放在一个类型里
长度是固定的，一旦声明就无法改变
声明例： let tup: (i32, f64, u8) = (500, 6.4, 1);
访问例 1： let (x, y, z) = tup;
访问例 2： let x = tup.0;

数组类型（Array）

可以将多个类型的多个值放在一个类型里
长度也是固定的，一旦声明就无法改变
想要使用有固定数量的元素时使用数组更有好处
声明例： let arr: [i32; 5] = [1, 2, 3, 4, 5];
声明例 2： let arr = [3; 5]; // 表示数组有 5 个 3
访问例： let x = arr[0];
没有 Vector 灵活

函数

函数名小写，单词间使用下划线进行分割

例子：


fn f(x: i32, y: i32) -> i32 {
    // 这里不加分号，因为是表达式，会返回值
    // 函数默认使用最后一个表达式作为返回值
    x + y
}

fn f2(x: i32, y: i32) {
    let z = {
        x + y + 1
    };
    z
}

控制流

if 表达式

如果使用多于一个的 if-else，最好使用 match 对代码进行重构
if 表达式是一个表达式，所以可以将其赋值给一个变量

fn main() {
    let x = 5;
    if x < 5 {
        println!("x is less than 5");
    } else if x > 5 {
        println!("x is greater than 5");
    } else {
        println!("x is 5");
    }
    // 使用 match 对代码进行重构
    let x = 5;
    match x.cmp(&5) {
        std::cmp::Ordering::Less => println!("x is less than 5"),
        std::cmp::Ordering::Greater => println!("x is greater than 5"),
        std::cmp::Ordering::Equal => println!("x is 5"),
    }

    let y = if x < 5 {
        1
    } else {
        2
    };
}

循环

fn main() {
    let mut x = 0;
    while x < 5 {
        println!("x is {}", x);
        x += 1;
    }
    x = 0;
    // 使用 .. 表示一个范围，不包含右边的数
    // 实际的类型是std::ops::Range<{integer}>
    // 可以通过(1..5).rev() 表示一个倒序的范围
    for x in 0..5 {
        println!("x is {}", x);
    }
    const A: [i32; 5] = [1, 2, 3, 4, 5];
    // iter 方法返回一个迭代器，迭代器是一个可以遍历集合的对象
    for x in A.iter() {
        println!("x is {}", x);
    }
    x = 0;
    loop {
        println!("x is {}", x);
        x += 1;
        if x > 5 {
            break;
        }
    }
    // loop 表达式是一个表达式，所以可以将其赋值给一个变量
    let result = loop {
        if x > 5 {
            break x * 2;
        }
        x += 1;
    };
}

所有权

内存管理分为两个部分：栈和堆
所有权是 Rust 最独特的特性之一
在 Rust 中，每个值都有一个变量，这个变量被称为所有者
每个值在任意时刻有且只有一个所有者
当所有者离开 scope（作用域），这个值将被删除

作用域

例：

fn main() {
    {
        let x = 5;
        println!("x is {}", x);
    }
    // x 已经离开作用域
}

copy trait

赋值要么发生移动，要么发生复制
Rust 中的基本类型都实现了 copy trait
如果一个类型实现了 copy trait，则旧的变量在赋值后仍然可以使用
否则就像下面的 String 一样，赋值以后旧的变量会失效
内容全为已实现 copy 的 tuple 也是可 copy 的

所有权和函数

rust 函数传参与赋值操作类似
所以可能发生移动，使得一些变量失效
返回值时所有权也很发生移动或复制
一个变量的所有权总是遵循同样的模式
- 把一个值赋给其他变量的时候会发生移动
- 当一个包含 heap 数据的变量离开作用域时。这个值就会被 drop 函数删除
- 除非其所有权发生了转移

例：

fn main() {
    let s = String::from("hello");
    takes_ownership(s);
    // 这里会报错，因为s已经失效了
    // println!("{}", s);
    let x = 5;
    makes_copy(x);
    // 这里不会报错，因为x仍然可以使用
    println!("{}", x);

    let s1 = generates_string();

    let s2 = String::from("hello");

    let s3 = takes_and_gives_back(s2);
    println!("{}", s1);
    // 这里会报错，因为s2已经失效了
    println!("{}", s2);
    println!("{}", s3);
}

fn takes_and_gives_back(a_string: String) -> String {
    a_string
}

fn generates_string() -> String {
    let s = String::from("hello");
    s
}

fn makes_copy(x: i32) {
    println!("{}", x);
}

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}

引用和借用

引用是一个指向某个值的指针
引用不会获取到值的所有权
引用的变量默认是不可变的
引用的变量可以通过 mut 关键字声明为可变的
特定的作用域内，一个变量只能有一个可变引用
不可同时拥有可变引用与不可变引用
不可变引用可以有多个
rust 在编译时会防止悬空指针的出现例

fn main() {
    let s1 = String::from("hello");
    // 这里的s2是一个引用，指向s1
    let len = calculate_length(&s1);
    change_string(&mut s1);
    println!("{}", s2);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

fn change_string(s: &mut String) {
    s.push_str(", world");
}

slice 切片

slice 是一个引用，指向一个字符串/数组的一部分
定义函数时使用字符串切片（&str）来代替字符串引用会使我们的 api 更加通用且不会损失任何功能

fn main() {
    let s = String::from("hello world");
    let wordIndex = first_word(&s);
    let hello = &s[0..5];
    let world = &s[6..11];
    // 这里会报错，因为clear会导致可变，但是 s已被不可变引用
    s.clear();
    let a: [u8; 5] = [1, 2, 3, 4, 5];
    let slice = &a[0..2];
}

fn first_word(s: &str) -> usize {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[i..];
        }
    }
    &s[..]
}

String

相比于使用双引号创建的字符串，使用 String 类型可以动态地分配内存
String 是一个可变的字符串类型
String 是一个堆上的字符串，而不是栈上的字符串
底层实现上：
- String 是一个结构体，包含一个指向堆上的字符串的指针和一个长度，一个容量
- 结构体储存在栈上
- 真实的字符串储存在堆上

fn main() {
    // 在heap上分配内存了
    let mut s = String::from("hello");
    // 和js类似，s1和s实际上是同一个字符串
    // 但是因为一些所有权的问题，所以在s1生效以后，s就失效了
    let s1 = s;
    // 克隆消耗资源，但是原来的不会失效了
    let s2 = s1.clone();
    // 这样会报错，因为s已经失效了
    s.push_str(", world");
    s1.push_str(", world");
    println!("s is {}", s1);
}

struct 结构体

结构体是一个自定义的类型
一旦结构体是可变的，那么结构体的所有字段就是可变的
只要 struct 是有效的，则里面的引用也都是有效的

struct User {
    name: String,
    age: u8,
    id: u32,
}

// tuple struct 元组结构体
struct Color(i32, i32, i32)

// 这样可以将结构体打印出来
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

// impl关键字用于为结构体实现接口或者关联函数或者方法
impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }

    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }

    // 关联函数，不需要实例化就可以调用，通常用于创建结构体
    // 类似于静态方法
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let id: u32 = 1;
    let user = User {
        name: String::from("hello"),
        age: 18,
        id, // 如果字段名和变量名相同，可以省略变量名
    };
    let user2 = User {
        name: String::from("world"),
        id: 2,
        ..user //struct更新语法
    };
    println!("user is {}", user.name);

    let color = Color(255, 0, 0);
    let rect = Rectangle {
        width: 10,
        height: 20,
    };
    let rect2 = Rectangle {
        width: 5,
        height: 10,
    };
    println!("rect is {:#?}", rect);
    println!("rect area is {}", rect.area());
    println!("rect can hold rect2? {}", rect.can_hold(&rect2));
}

枚举

枚举是一个自定义的类型例

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

fn main() {
    let home = IpAddr::V4(127, 0, 0, 1);
    let loopback = IpAddr::V6((String::from("::1")));
}

Option

Option 是一个枚举类型，表示一个值可能不存在
包含在预导入库中，可以直接使用

enum Option<T> {
    Some(T),
    None,
}

如 let x: Option = None;
通过unwrap方法可以获取到Some的值

match

match可以提供一种匹配

enum UsState {
    Alabama,
    Alaska,
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state);
            25
        },
    }
}

fn main() {
    let coin = Coin::Quarter(UsState::Alaska);
    println!("value_in_cents is {}", value_in_cents(coin));
}

13 KiB Raw Blame History Unescape Escape

Rust 语法学习

用例 1：猜数游戏

特性： shadow

类型

基本类型

整数类型

浮点数类型

布尔类型

字符类型

复合类型

元组类型（Tuple）

数组类型（Array）

函数

控制流

if 表达式

循环

所有权

作用域

copy trait

所有权和函数

引用和借用

slice 切片

String

struct 结构体

枚举

Option

match

13 KiB

Raw Blame History