以下代码简单介绍了 Rust 的所有权机制

// 1. Rust 通过所有权机制来来管理内存，编译器在编译时就会根据所有权规则对内存的使用进行检查
// 2. 堆和栈
// 编译时数据的类型大小是固定的，就是分配在栈上的
// 编译时数据的类型大小不固定，就是分配在堆上的
// 3. 作用域 {}
// 4. String 内存回收
// 5. 移动
// 6. clone
// 7. 栈上数据拷贝
// 8. 函数和作用域

fn main() {
    // x，y 定义在栈上
    let x: i32 = 1;
    {
        let y: i32 = 1;
        println!("x = {}", x);
        println!("y = {}", y);
    }

    {
        // s1 定义在堆上
        let s1 = String::from("hello");
        // s1.push_str("world");
        println!("s1 = {}", s1);    // String 类型离开作用域时会调用 drop 方法

        let s2 = s1;
        println!("s2 = {}", s2);
        // println!("s1 = {}", s1);    // move to s2, s1 invalid

        // clone
        let s3 = s2.clone();
        println!("s3 = {}", s3);
        println!("s2 = {}", s2);
    }

    // copy trait
    let a = 1;
    let b = a;
    println!("a = {}, b = {}", a, b);
    // 常用的具有 copy trait 的有：
    // 整形
    // 浮点型
    // 布尔值
    // 字符类型
    // 元组

    let s = String::from("hello");
    let s_s = takes_ownership(s);
    println!("s_s = {}", s_s);
    
    let x = 5;
    makes_copy(x);
    println!("x = {}", x);
}

fn takes_ownership(some_string: String) -> String {
    println!("{}", some_string);
    some_string
}

fn makes_copy(i: i32) {
    println!("i = {}", i);
}

输入 cargo r 后，输出如下：

x = 1
y = 1
s1 = hello
s2 = hello
s3 = hello
s2 = hello
a = 1, b = 1
hello
s_s = hello
i = 5
x = 5