emacs 中 C++ 缩进的设置

#[derive(Clone)]
pub struct Letter {
    text: String,
}

pub struct Envelope {
    letter: Option<Letter>,
}

pub struct PickupLorryHandle {
    done: bool,
}

impl Letter {
    pub fn new(text: String) -> Self {
        Letter { text: text }
    }
}

impl Envelope {
    pub fn wrap(&mut self, letter: &Letter) {
        self.letter = Some(letter.clone());
    }
}

pub fn buy_prestamped_envelope() -> Envelope {
    Envelope { letter: None }
}

impl PickupLorryHandle {
    pub fn pickup(&mut self, _envelope: &Envelope) {
        // give letter
    }

    pub fn done(&mut self) {
        self.done = true;
        println!("sent");
    }
}

pub fn order_pickup() -> PickupLorryHandle {
    PickupLorryHandle { done: false }
}

fn main() {
    let letter = Letter::new(String::from("Dear RustFest"));
    let mut envelope = buy_prestamped_envelope();
    envelope.wrap(&letter);
    let mut lorry = order_pickup();
    lorry.pickup(&envelope);
    lorry.done();
}

sent

上面存在的问题：

阅读全文

Rust 中的 trait 系统

xhcoding

2021-09-20

trait 是 Rust 的灵魂，Rust 中的所有抽象，如接口抽象，OOP 范式抽象，函数式范式抽象，都是基于 trait 完成的。

trait 是在行为上对类型的约束，这种约束让 trait 有如下四种用法：

阅读全文

Rust 中的析构顺序

xhcoding

2021-09-16

一般来讲，变量的析构顺序和声明顺序相反，但是并不是所有的情况都是这样。

本地变量

本地变量先声明后析构。

struct PrintDrop(&'static str);
impl Drop for PrintDrop {
    fn drop(&mut self) {
        println!("Dropping {}", self.0)
    }
}

fn main() {
    let _x = PrintDrop("x");
    let _y = PrintDrop("y");
}

1
2

Dropping y
Dropping x

元组

struct PrintDrop(&'static str);
impl Drop for PrintDrop {
    fn drop(&mut self) {
        println!("Dropping {}", self.0)
    }
}

fn main() {
    let _tup1 = (PrintDrop("x"), PrintDrop("y"));
    let _tup2 = (PrintDrop("s"), PrintDrop("z"));
}

Dropping s
Dropping z
Dropping x
Dropping y

先析构 tup2 ，后析构 tup1 ，在元组内部是前面的先析构，后面的后析构。

阅读全文