539943419/Notebook-StarNet
1
0 Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
Notebook-StarNet/rust/rust1.md
T
539943419 44910b3d68 add rust1
2024-12-14 22:20:19 +08:00

13 KiB
Raw Permalink 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));
}
Reference in new issue View Git Blame Copy Permalink