fn main() {
    // s 不可用
    let s = "s"; // s 可用
    // s 可用
}
// s 作用域结束，s 不可用

fn main() {
    let mut s = String::from("s");
    s.push_str("ss");
    println!("{}", s);
}
// s 离开作用域，调用 drop 函数释放内存，之后将不可用

// 整数是已知固定大小的简单的值，这两个 5 被压到 stack 中
let x = 5;
let y = x; // 复制了一个 5，压入栈

// String 类型由三部分组成:
// 1. 指向存放字符串内容的内存的指针
// 2. 长度 len (存放字符串内容所需的字节数)
// 3. 容量 capacity (String 从操作系统总共获得内存的总字节数)
// 上面这些内容放在 stack 中
// 存放字符串内容的部分在 heap 上
let s1 = String::from("s");
let s2 = s1;
// 其他语言的做法
// 当把 s1 赋值给 s2 时，String 在 stack 中存储的东西就被复制了一份给 s2 了
// 但是 heap 的内容不复制，所以 s1 s2 的指针所指向的 heap 内存是一样的
// 当变量离开作用域时，Rust 会自动调用 drop 函数，并将变量使用的 heap 内存释放
// **当 s1 s2 离开作用域时，它们都会尝试释放相同的内存**
//  - 这会引起二次释放的 bug (double free)

let s1 = String::from("s");
let s2 = s1; // s1 失效了，move 给了 s2

println!("{}", s1); // s1 不可用, 报错

let s1 = String::from("s");
let s2 = s1.clone();

println!("{} {}", s1, s2); // ok

// 已知大小的数据会存放在 stack 中，它们这样的操作是 copy 行为，会将 stack 上的数据 copy 一份
let x = 5;
let y = x; // 复制了一个 5，压入栈

println!("{} {}", x, y); // ok

fn main() {
    let s = String::from("hello world");
    take_ownership(s); // s move 到了函数中
    // s 不可用

    let x = 5;
    make_copy(x); // x copy 到了函数中
    println!("x: {}", x); // x 还是可用
}

fn make_ownership(some_str: String) {
    println!("{}", some_str);
}

fn make_copy(some_num: i32) {
    println!("{}", some_num);
}

fn main() {
    let s1 = gives_ownership(); // 函数里面的返回值 move 给了 s1
    let s2 = String::from("hello world");
    let s3 = takes_and_gives_back(s2); // s2 move 进了函数，又 move 给了 s3
}

fn gives_ownership() -> String {
    let some_str = String::from("hello world");
    some_str
}

fn takes_and_gives_back(a: String) -> String {
    a
}

fn main() {
    let s1 = String::from("hello world");
    let len = calc_len(&s1); // 将 s1 的引用传入了函数，没有发生所有权的转移

    println!("{}, {}", s1, len); // 由于 s1 所有权没有转移，所以其在该作用域内还是存活的
}

fn calc_len(s: &String) -> usize {
    // s.push_str("ss") // 报错，引用默认是不可变的
    s.len()
}

let mut s1 = String::from("hello world");
let len = calc_len(&mut s1);

fn calc_len(s: &mut String) -> usize {
    s.push_str("ss"); // 借用到的是可变引用，可以修改
    s.len()
}

// 可以通过创建新的作用域，来允许非同时的创建多个可变引用
fn main() {
    let mut s = String::from("hello world");
    {
        let s1 = &mut s;
    }
    let s2 = &mut s;
}

fn main() {
    let mut s = String::from("hello world");
    let r1 = &s;
    let r2 = &s;
    let s1 = &mut s; // 不可以，当前作用域已经有不可变引用了
}

fn main() {
  let mut arr = vec![1, 2, 3];
  let last = arr.last(); // 访问不可变引用
  arr.push(4); // 访问可变引用
  println!("last: {:?}", last); // 访问不可变引用 (报错), 此时之前的可变引用
  // 该例中可变不可变相互纠缠, 相互交叉, 破坏了互斥原则, 所以报错
}

// 修改为下
// 不可变和可变引用的界限分明了, 编译通过
fn main() {
  let mut arr = vec![1, 2, 3];
  let last = arr.last(); // 访问不可变引用
  println!("last: {:?}", last); // 访问不可变引用, print "last: Some(3)"
  // 不可变引用访问结束, 此时再访问可变引用, 就不冲突了
  arr.push(4); // 访问可变引用
}

fn main() {
    let mut data = vec![1, 2, 3];
    let data1 = vec![&data[0]]; // 访问了 data 的不可变引用
    println!("data[0]: {:p}", &data[0]);

    for i in 0..100 {
        // 如果继续添加元素，堆上的数据预留的空间不够了，就会重新分配一片足够大的内存，
        // 把之前的值拷过来，然后释放旧的内存。
        // 这样就会让 data1 中保存的 &data[0] 引用失效，导致内存安全问题
        data.push(i); // 访问了 data 的可变引用
    }

    println!("data[0]: {:p}", &data[0]);
    println!("boxed: {:p}", &data1); // 访问了 data 的不可变引用 (和可变引用互斥了, 报错)
}

fn dangle() -> &String {
    let s = String::from("hello world");
    &s // 报错, 离开作用域 s 被销毁了，s 的引用会指向一个已经被释放的空间，所以编译器不允许返回 &s
}