Rust 程序设计期末复习

// 创建项目
cargo new hello           // 生成 Cargo.toml + src/main.rs
cargo run                 // 编译并运行
cargo build               // 默认 debug 编译
cargo build --release     // release 编译，启用优化
cargo check               // 只检查，不生成可执行文件
cargo test                // 运行单元测试
cargo clean               // 清除 target/

fn main() {
    let x = 5;
    // x = 6;          // 错误：cannot assign twice to immutable variable
    let mut y = 5;
    y = 6;             // OK

    let x = x + 1;     // shadowing，新 x
    {
        let x = x * 2; // 内层 shadowing
        println!("{}", x); // 12
    }
    println!("{}", x);     // 6
}

fn main() {
    let y = {
        let z = 7;
        z * z          // 末尾无分号：作为块值返回
    };
    println!("{}", y); // 49
}

fn main() {
    assert_eq!(10_i8 as u16, 10_u16);       // 零扩展
    assert_eq!(-1_i16 as i32, -1_i32);      // 符号扩展
    assert_eq!(1000_i16 as i8, -24_i8);     // 截断
    assert_eq!(255_u8 as i8, -1_i8);        // 截断后解释
}

assert_eq!(100_u8.checked_add(200), None);
assert_eq!(500_u16.wrapping_mul(500), 53392);
assert_eq!(255_u8.overflowing_add(2), (1, true));
assert_eq!(32760_i16.saturating_add(10), 32767);

fn main() {
    let t: (i32, bool, f64) = (1, false, 3.14);
    println!("{}, {}", t.0, t.2);
    let one = (1,);  // 1-tuple
}

fn main() {
    let a: [i32; 3] = [1, 2, 3];
    let mut v = vec![1, 2, 3];
    v.push(4);

    let s: &[i32] = &a[0..2];     // 切片
    let all: &[i32] = &v[..];     // 整个向量切片
    print_slice(all);
}

fn print_slice(s: &[i32]) {       // 同时适用于数组和向量
    for x in s { println!("{}", x); }
}

fn main() {
    let s = String::from("hello");
    let slice: &str = &s[1..4];   // "ell"
    let literal: &str = "world";   // 字符串字面量，位于只读区

    let mut z = String::from("中文");
    z.push('字');
    println!("{} 字节, {} 字符", z.len(), z.chars().count());
}

fn main() {
    let mut v = vec![1, 2, 3];
    let r1 = &v;
    let r2 = &v;          // OK：多个共享引用
    println!("{} {}", r1[0], r2[0]);

    let m = &mut v;       // 共享引用使用完后才能借可变
    m.push(4);
}

fn smallest(v: &[i32]) -> &i32 {   // 隐式等价于 <'a>
    let mut s = &v[0];
    for r in &v[1..] {
        if r < s { s = r; }
    }
    s
}

fn main() {
    let s;
    {
        let v = [9, 4, 1];
        s = smallest(&v);          // 错误：v 活得不够长
    }
    println!("{}", s);
}

fn first_third(point: &[i32; 3]) -> (&i32, &i32) {
    (&point[0], &point[2])
}
// 等价于
fn first_third<'a>(point: &'a [i32; 3]) -> (&'a i32, &'a i32) { ... }

fn main() {
    struct Label { name: String }
    let label = Label { name: String::from("dog") };
    let r = &label;
    println!("{}", r.name);   // 自动解引用，等价于 (*r).name

    let mut v = vec![3, 1, 2];
    v.sort();                  // 自动取 &mut v
}

fn main() {
    let a = 42;
    let b = if a > 0 { true } else { false };   // 两分支类型必须相同
    println!("{}", b);

    let code = 42;
    let msg = match code {
        0 => "OK",
        1 => "Wires Tangled",
        2 => "User Asleep",
        _ => "Unknown",
    };
    println!("{}", msg);
}

fn main() {
    let mut n = 81;
    let sqrt = 'outer: loop {
        n += 1;
        for i in 1.. {
            let square = i * i;
            if square == n { break 'outer i; }
            if square > n { break; }
        }
    };
    println!("{}", sqrt); // 10
}

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

fn read_number(s: &str) -> Result<i32, std::num::ParseIntError> {
    let n = s.parse::<i32>()?;   // Err 时直接返回
    Ok(n * 2)
}

pub mod arith {
    pub mod simple {
        pub fn add(a: u32, b: u32) -> u32 { a + b }
    }
}

fn demo() {
    crate::arith::simple::add(1, 2);   // 从 crate root
    self::arith::simple::add(1, 2);    // 从当前模块
    super::...;                         // 父模块
    ::arith::simple::add(1, 2);         // 外部 crate（顶层虚拟模块）
}

use std::collections::{HashMap, HashSet};
use std::io::Result as IoResult;      // 重命名

pub use self::inner::add;             // re-export，把私有模块的项公开

# 本地路径依赖
[dependencies]
calc = { path = "../calc" }

# crates.io 依赖（语义版本）
[dependencies]
image = "0.23"          # 等价于 ^0.23

[workspace]
members = ["crate_1", "crate_2"]

struct ColorImage {
    size: (usize, usize),
    pixels: Vec<u32>,
}

fn new_image(size: (usize, usize), pixels: Vec<u32>) -> ColorImage {
    ColorImage { size, pixels }   // 字段初始化简写
}

struct Demon { name: String, age: u32, addr: String }

fn main() {
    let d = Demon { name: "孙悟空".to_string(), age: 10000, addr: "花果山".to_string() };
    let name = d.name;            // 部分移动
    println!("{}", d.age);        // OK：age 仍可用
    // println!("{:?}", d);        // 错误：d 已被部分移动

    // 只能用仍拥有的剩余字段重新构造
    let d2 = Demon { name, age: d.age / 2, addr: d.addr };
    println!("{}", d2.name);
}

let whole = Demon { name: "a".to_string(), age: 1, addr: "b".to_string() };
let d2 = Demon { age: whole.age / 2, ..whole };   // whole 被整体消耗

pub struct Queue<T> {
    older: Vec<T>,
    ynger: Vec<T>,
}

impl<T> Queue<T> {
    pub fn new() -> Self { Self { older: vec![], ynger: vec![] } }
    pub fn push(&mut self, t: T) { self.ynger.push(t); }
    pub fn is_empty(&self) -> bool { self.older.is_empty() && self.ynger.is_empty() }
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
struct Point { x: f64, y: f64 }

enum Ordering { Less, Equal, Greater }              // C-style
enum Color { RGB(u8, u8, u8), Gray(u8) }            // tuple 变体
enum Message {                                     // struct 变体
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

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

enum TimeUnit { Second, Minute, Hour }

fn plural(unit: TimeUnit) -> &'static str {
    match unit {
        TimeUnit::Second => "seconds",
        TimeUnit::Minute => "minutes",
        TimeUnit::Hour   => "hours",
    }   // 必须覆盖所有变体
}

#[derive(Debug)]
struct Point { x: f64, y: f64 }

fn describe(point: &Point) {
    match point {
        &Point { x: 0.0, y } => println!("y axis, y={}", y),
        p @ &Point { x, y } if x == y => println!("diag {:?}", p),
        _ => {}
    }
}

if let Some(v) = opt { println!("{}", v); }

while let Some(top) = stack.pop() {
    println!("{}", top);
}

trait Drawable {
    fn draw(&self);
    fn describe(&self) -> String { String::from("a drawable") }
}

struct Circle { radius: f64 }

impl Drawable for Circle {
    fn draw(&self) { println!("circle {}", self.radius); }
}

fn min<T: Ord>(a: T, b: T) -> T { if a < b { a } else { b } }

fn dump<I>(iter: I)
where
    I: Iterator,
    I::Item: std::fmt::Debug,
{
    for (i, v) in iter.enumerate() { println!("{}: {:?}", i, v); }
}

trait Iterator {
    type Item;                       // 关联类型
    fn next(&mut self) -> Option<Self::Item>;
}

// 与类型参数的区别：一个类型只能实现一次某个关联类型 trait