Rust 难点笔记

• 一般情况下rust创建的变量是u32（无符号32位变量），这个变量在rust中最快
• 对于String和&str，一般认为String是可变的，而&str是不可变的，故一般创建函数中的参数和返回值多用&str，可用类型转换成String代替（高风险）例如：

fn first_word(s:&str)-> &str{
    &s[0..3]
}

• switch 语法很经典，但在 Rust 中并不支持，很多语言摒弃 switch 的原因都是因为 switch 容易存在因忘记添加 break 而产生的串接运行问题，Java 和 C# 这类语言通过安全检查杜绝这种情况出现。
• match 除了能够对枚举类进行分支选择以外，还可以对整数、浮点数、字符和字符串切片引用（&str）类型的数据进行分支选择。其中，浮点数类型被分支选择虽然合法，但不推荐这样使用，因为精度问题可能会导致分支错误。对非枚举类进行分支选择时必须注意处理例外情况，即使在例外情况下没有任何要做的事 . 例外情况用下划线 _ 表示：

fn main() {
    let t = "abc";
    match t {
        "abc" => println!("Yes"),
        _ => {},
    }
}

• println!(),Rust为结构体提供了打印调试信息的功能.:?,:#?
• 关于 vector 放入不同类型的值

enum SpreadsheetCell{
    Int(i32),
    Float(f64),
    Text(String),
}

fn main(){
    let row = vec![
        SpreadsheetCell::Int(3), 
        SpreadsheetCell::Text(String::from("blue")),
        SpreadsheetCell::Float(10.12),
    ];

    match &row[0] {
        SpreadsheetCell::Int(value) => println!("value: {}", value),
        SpreadsheetCell::Text(value) => println!("value: {}", value),
        SpreadsheetCell::Float(value) => println!("value: {}", value),
    }

    for elem in row {
        // println!("{:?}", elem);
        match elem {
            SpreadsheetCell::Int(value) => println!("value: {}", value),
            SpreadsheetCell::Text(value) => println!("value: {}", value),
            SpreadsheetCell::Float(value) => println!("value: {}", value),
        }
    }
    
}

• 不过可变引用并不是随心所欲、想用就用的，它有一个很大的限制： 同一作用域，特定数据只能有一个可变引用

fn main() {
let mut s = String::from("hello");

let r1 = &mut s;
let r2 = &mut s;

println!("{}, {}", r1, r2);
}

• 切片是指针，指向原字符串某个位置

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear(); // error!，此处不但是清空包括改变，都会报错

    println!("the first word is: {}", word);//这里的word是一个指向s的指针，但是s已经被改变，导致word会变成空指针，所以报错
}
fn first_word(s: &String) -> &str {
    &s[..1]
}

• 泛型是个难点，要好好看看

struct Point<T, U> {
    x: T,
    y: U,
}

impl<T, U> Point<T, U> {
    fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, V> {
        Point {
            x: self.x,
            y: other.x,
        }
    }
}
# 这里有两个泛型应用，它们并不冲突，说白了，你可以理解为，一个是结构体泛型，一个是函数泛型

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hello", y: 'c'};

    let p3 = p1.mixup(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}