rust入门

“妈的，之后看到的语法要随手记下来”

调用库： use std::io;
生成文档：cargo doc --open
match 关键字：

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }

ownership :
- 每个值有一个变量作为owner
- 同时只能有一个owner
- 当owner到scope外时，值会消失

rust 特性：

所有权机制保证的安全性
显示变量类型语言，但支持类型的推导
作用域特性：变量在定义的作用域外会被丢弃
不允许空值（null）
不允许悬挂指针
不允许 race condition（因此同一个变量只能有一个可变引用 或 多个不可变引用）

! 结尾表示宏展开

通用语法

for 循环：

for x in 0..10 {
    println!("{}", x); // x: i32
}

// enumerate 版本
for (i,j) in (5..10).enumerate() { 
    println!("i = {} and j = {}", i, j);
}

区间： a..b 表示 [a, b)，类型 core::ops::Range ，标准库为其实现了 Iterator 的 trait

match 语句：

match v.get(2) {
    Some(third) => println!("The third element is {}", third),
    None => println!("There is no third element."),
}

同时是 Option<&T> 的应用
Option 定义 ：

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

Result 定义 ：

enum Result<T, E> {
    Ok(T),
    Err(E),
}

结构体定义与结构体函数：

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, W> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

tuple 结构体：

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
println!("{} {} {}", black.0, black.1, black.2);

triait 定义与使用：

pub trait Summary {
    fn summarize(&self) -> String;
}
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

trait 参数传入：

pub fn notify(item1: impl Summary, item2: impl Summary) {}
pub fn notify(item: impl Summary + Display) {}
pub fn notify<T: Summary + Display>(item: T) {}

函数 && 泛型： fn largest<T>(list: &[T]) -> T { }

生命周期注解：

&i32        // 引用
&'a i32     // 带有显式生命周期的引用
&'a mut i32 // 带有显式生命周期的可变引用

手动 drop 引用 ：
core::mem::drop(inner);

数组：let mut app_start: [usize; MAX_APP_NUM + 1] = [0; MAX_APP_NUM + 1];

具体其他

新建 vector : let v : Vec<i32> = Vec::new();, let v = vec![1, 2, 3]

box : 在堆上分配内存空间。

// 把栈上变量转移到堆上
let val: u8 = 5;
let boxed: Box<u8> = Box::new(val);

// 把变量从堆上转移到栈上
let boxed: Box<u8> = Box::new(5);
let val: u8 = *boxed;

string :

&str : string slices, 定长，不能 mut，是指向 UTF-8 字节串的 reference
let greeting = "Hello there.";
"Hello there." 为 string literal，类型 &static str，编译时分配，lifetime为整个程序
let s = String::from("hello"); 类型 String
let slice = &s[3..]; 类型 &str，为切片, slice.len()
s.as_str() 类型 &str
let s1 = "Hello world!"; 类型 &str，为切片

数组切片 :

let a = [1,2,3,4,5];
let slice = &a[1..3]; 类型 &[i32] 为数组切片

升级概念（？）

普通指针：类型 & 和 &mut 两种

    let mut num = 5;
    let num_ref = &mut num;
    *num_ref = 100;

胖指针：如切片，保存了指针和长度信息，类型 & 和 &mut 两种

    let mut arr = [1, 2, 3, 4];
    let slice = &mut arr[1..4];
    slice[0] = 100;

裸指针：类似 C++ 指针，可能为 null
创建裸指针为safe操作，读写裸指针为unsafe 操作，类型 *mut 和 *const 两种

    let mut num = 1;
    // 将引用转为裸指针
    let num_raw_point = &mut num as *mut i32;
    unsafe {
        *num_raw_point = 100;
        println!("{} {} {:p}", num, *num_raw_point, &num); 
        // Output: 100 100 0x8d8c6ff6bc
    }

访问 *mut 裸指针元素： *a.offset(1) = 1

#[derive(Copy, Clone)] 在类前添加，让编译器自动添加 Copy/Clone trait，使传参时不会发生所有权转移

结构相关

目录下 mod.rs 和与目录同名的 .rs 文件起到导出内部接口作用