Rust 入门（三）：所有权、借用与生命周期

int* ptr = malloc(sizeof(int));
*ptr = 42;
free(ptr);  // 必须手动释放

String s = new String("hello");
// GC 自动回收，不需要 free

let s = String::from("hello");
// 离开作用域时自动释放

int* dangling() {
    int x = 42;
    return &x;  // ❌ x 已释放，返回无效指针
}

int* ptr = malloc(sizeof(int));
free(ptr);
free(ptr);  // ❌ 重复释放

void leak() {
    int* ptr = malloc(sizeof(int));
    // ❌ 忘记 free
}

{                       // s 无效，未声明
    let s = "hello";    // s 有效
    // 可以使用 s
}                       // s 离开作用域，不再有效

let s1 = String::from("hello");  // 堆分配
let s2 = s1;  // ⚠️ 移动（move），s1 不再有效

// println!("{}", s1);  // ❌ 编译错误：s1 已被移动
println!("{}", s2);     // ✅ OK

s1 (无效)
  |
  X (所有权已转移)

s2 -> [ptr, len, cap] -> 堆内存 ["hello"]

let s1 = String::from("hello");
let s2 = s1;  // 移动

// s1 不再有效

let s1 = String::from("hello");
let s2 = s1.clone();  // 克隆堆数据

println!("s1 = {}, s2 = {}", s1, s2);  // ✅ OK

let x = 5;
let y = x;  // 复制（不是移动）

println!("x = {}, y = {}", x, y);  // ✅ OK

fn main() {
    let s = String::from("hello");
    takes_ownership(s);  // s 移动到函数中
    // println!("{}", s);  // ❌ s 不再有效

    let x = 5;
    makes_copy(x);  // x 被复制
    println!("{}", x);  // ✅ x 仍有效
}

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}  // some_string 离开作用域，被 drop

fn makes_copy(some_integer: i32) {
    println!("{}", some_integer);
}  // some_integer 离开作用域，但无需 drop（栈上）

fn gives_ownership() -> String {
    let s = String::from("hello");
    s  // 返回 s，所有权移出函数
}

fn takes_and_gives_back(a_string: String) -> String {
    a_string  // 返回 a_string，所有权转移
}

fn main() {
    let s1 = gives_ownership();  // s1 获得所有权
    let s2 = String::from("hello");
    let s3 = takes_and_gives_back(s2);  // s2 移入，s3 获得所有权
}

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);  // 借用 s1
    println!("'{}' 的长度是 {}", s1, len);  // ✅ s1 仍有效
}

fn calculate_length(s: &String) -> usize {
    s.len()
}  // s 离开作用域，但不 drop（没有所有权）

fn main() {
    let mut s = String::from("hello");
    change(&mut s);
    println!("{}", s);  // "hello, world"
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

let mut s = String::from("hello");

let r1 = &mut s;
// let r2 = &mut s;  // ❌ 同一时间只能有一个可变引用

println!("{}", r1);

let mut s = String::from("hello");

let r1 = &s;      // OK
let r2 = &s;      // OK
// let r3 = &mut s;  // ❌ 错误：已有不可变引用

println!("{} and {}", r1, r2);

let mut s = String::from("hello");

let r1 = &s;
let r2 = &s;
println!("{} and {}", r1, r2);
// r1 和 r2 在这里不再使用

let r3 = &mut s;  // ✅ OK
println!("{}", r3);

// C 语言的悬垂指针
int* dangle() {
    int x = 42;
    return &x;  // ❌ 返回局部变量的指针
}

fn dangle() -> &String {  // ❌ 编译错误
    let s = String::from("hello");
    &s
}  // s 被 drop，返回的引用无效

error[E0106]: missing lifetime specifier

fn no_dangle() -> String {
    let s = String::from("hello");
    s  // 移动所有权
}

{
    let r;                // -------+-- 'a
                          //        |
    {                     //        |
        let x = 5;        // -+--'b |
        r = &x;           //  |     |
    }                     // -+     |
                          //        |
    // println!("{}", r); // ❌ x 已销毁
}                         // -------+

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

error[E0106]: missing lifetime specifier

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
        println!("{}", result);  // ✅ OK
    }
    // println!("{}", result);  // ❌ string2 已销毁
}

struct ImportantExcerpt<'a> {
    part: &'a str,  // 引用的生命周期
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let i = ImportantExcerpt {
        part: first_sentence,
    };
}

fn foo(x: &i32, y: &i32)
// 等价于
fn foo<'a, 'b>(x: &'a i32, y: &'b i32)

fn foo(x: &i32) -> &i32
// 等价于
fn foo<'a>(x: &'a i32) -> &'a i32

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }

    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {}", announcement);
        self.part
    }
}

let s = String::from("hello");
let s2 = s;
println!("{}", s);  // ❌ s 已移动

// 方案 1：克隆
let s = String::from("hello");
let s2 = s.clone();
println!("{} {}", s, s2);  // ✅ OK

// 方案 2：借用
let s = String::from("hello");
let s2 = &s;
println!("{} {}", s, s2);  // ✅ OK

let mut s = String::from("hello");
let r1 = &s;
let r2 = &mut s;  // ❌ 已有不可变引用
println!("{} {}", r1, r2);

let mut s = String::from("hello");
let r1 = &s;
println!("{}", r1);  // r1 最后使用

let r2 = &mut s;  // ✅ OK（r1 已结束）
println!("{}", r2);

fn dangle() -> &String {
    let s = String::from("hello");
    &s  // ❌ s 会被 drop
}

fn no_dangle() -> String {
    let s = String::from("hello");
    s  // ✅ 移动所有权
}

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");
    let word = first_word(&my_string);
    println!("{}", word);  // "hello"
}

fn main() {
    let mut s = String::from("hello world");
    let word = first_word(&s);
    // s.clear();  // ❌ 编译错误：已有不可变引用 word
    println!("{}", word);
}