Rust所有权与借用检查器详解

fn main() {
    // String类型存储在堆上
    let s1 = String::from("hello");

    // 移动（move），s1不再有效
    let s2 = s1;

    // println!("{}", s1); // 编译错误：value borrowed here after move

    println!("{}", s2); // OK: s2是所有者
}
// s2离开作用域，堆内存被释放

// 移动发生的场景

// 1. 赋值
let a = String::from("hello");
let b = a; // a被移动

// 2. 函数传参
fn take_string(s: String) {
    println!("{}", s);
} // s在这里被drop

let s = String::from("world");
take_string(s); // s被移动到函数内
// println!("{}", s); // 编译错误

// 3. 函数返回值
fn give_string() -> String {
    let s = String::from("returned");
    s // 所有权转移给调用者
}
let s = give_string(); // s获得所有权

// 4. Copy trait - 栈上的简单类型不移动，而是复制
let x: i32 = 42;
let y = x; // 复制，x仍然有效
println!("x={}, y={}", x, y); // OK

// 实现了Copy的类型：
// 所有整数、浮点、bool、char
// 元组（如果所有元素都实现了Copy）
// 数组（如果元素实现了Copy）

// Clone: 显式深拷贝
let s1 = String::from("hello");
let s2 = s1.clone(); // 深拷贝，s1仍然有效
println!("s1={}, s2={}", s1, s2);

// 自定义类型
#[derive(Clone)]
struct Config {
    name: String,
    values: Vec<i32>,
}

let config1 = Config {
    name: String::from("test"),
    values: vec![1, 2, 3],
};
let config2 = config1.clone(); // 深拷贝

fn calculate_length(s: &String) -> usize {
    s.len()
    // s是借用，函数结束时不会drop原始数据
}

fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s); // 借用s
    println!("'{}' has length {}", s, len); // s仍然有效
}

fn append_world(s: &mut String) {
    s.push_str(" world");
}

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

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

    // 多个不可变借用 - OK
    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);

    // 可变借用 - OK (r1, r2已经不再使用)
    let r3 = &mut s;
    r3.push_str(" world");
    println!("{}", r3);

    // 不可变和可变同时存在 - ERROR
    // let r4 = &s;
    // let r5 = &mut s;
    // println!("{}", r4); // 如果r4在r5之后使用，编译错误
}

// Rust编译器阻止悬垂引用
fn dangle() -> &String {       // 编译错误
    let s = String::from("hello");
    &s // s在函数结束时被drop，引用将指向无效内存
}

// 正确做法：返回所有权
fn no_dangle() -> String {
    let s = String::from("hello");
    s // 移动所有权给调用者
}

// 编译器无法推断返回值的生命周期
// 返回值的引用来自x还是y？
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 string2 = String::from("xyz");
        let result = longest(string1.as_str(), string2.as_str());
        println!("Longest: {}", result);
    }
    // result不能超出string2的生命周期
}

// 编译器自动推断生命周期的三条规则：

// 规则1: 每个输入引用获得独立的生命周期
// fn foo(x: &str, y: &str) -> 推断为 -> fn foo<'a, 'b>(x: &'a str, y: &'b str)

// 规则2: 只有一个输入引用时，输出生命周期 = 输入生命周期
fn first_word(s: &str) -> &str { /* ... */ }
// 等同于: fn first_word<'a>(s: &'a str) -> &'a str

// 规则3: 方法中有&self时，输出生命周期 = &self的生命周期
impl Config {
    fn name(&self) -> &str {
        &self.name
    }
    // 等同于: fn name<'a>(&'a self) -> &'a str
}

// 当三条规则都无法确定时，需要显式标注
fn longest(x: &str, y: &str) -> &str { /* 编译错误，需要手动标注 */ }

// 结构体包含引用时必须标注生命周期
struct ImportantExcerpt<'a> {
    part: &'a str,
}

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

    // 规则3: 返回值生命周期 = &self
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention: {}", announcement);
        self.part
    }
}

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

// 'static表示引用在整个程序运行期间都有效
let s: &'static str = "I have a static lifetime";
// 字符串字面量都是'static的，它们存储在程序的二进制文件中

// 注意：不要随意使用'static来解决生命周期错误
// 这通常意味着设计有问题

// Rust 2015: 借用在整个词法作用域有效
fn example_old() {
    let mut data = vec![1, 2, 3];
    let first = &data[0]; // 借用开始
    // 在Rust 2015中，first的借用延续到作用域结束
    // data.push(4); // 2015编译错误，即使first之后不再使用
    println!("{}", first);
    // Rust 2015: first的借用在这里仍然"活着"
}

// Rust 2018+ (NLL): 借用在最后一次使用后结束
fn example_nll() {
    let mut data = vec![1, 2, 3];
    let first = &data[0]; // 借用开始
    println!("{}", first); // 借用最后一次使用
    // NLL: first的借用到这里就结束了
    data.push(4); // OK! 不再有活跃的不可变借用
    println!("{:?}", data);
}

// 使用&str而非&String作为函数参数
fn greet(name: &str) {  // 接受&str和&String
    println!("Hello, {}!", name);
}

let owned = String::from("World");
let literal = "World";

greet(&owned);   // &String自动解引用为&str
greet(literal);  // &str直接传入

fn main() {
    let names = vec![
        String::from("Alice"),
        String::from("Bob"),
        String::from("Charlie"),
    ];

    // iter()返回&T，不消费原集合
    for name in names.iter() {
        println!("Hello, {}", name);
    }
    println!("Still have {} names", names.len()); // OK

    // into_iter()消费集合，获取所有权
    for name in names.into_iter() {
        println!("Goodbye, {}", name);
    }
    // println!("{:?}", names); // 编译错误：names已被消费

    // iter_mut()获取可变引用
    let mut scores = vec![1, 2, 3];
    for score in scores.iter_mut() {
        *score *= 2;
    }
    println!("{:?}", scores); // [2, 4, 6]
}

use std::cell::RefCell;

// RefCell: 运行时借用检查（单线程）
struct Logger {
    messages: RefCell<Vec<String>>,
}

impl Logger {
    fn new() -> Self {
        Logger {
            messages: RefCell::new(Vec::new()),
        }
    }

    // 即使&self是不可变引用，也能修改messages
    fn log(&self, msg: &str) {
        self.messages.borrow_mut().push(String::from(msg));
    }

    fn dump(&self) {
        for msg in self.messages.borrow().iter() {
            println!("{}", msg);
        }
    }
}

use std::borrow::Cow;

// Cow: 避免不必要的克隆
fn process_name(name: &str) -> Cow<str> {
    if name.contains(' ') {
        // 需要修改，返回拥有的String
        Cow::Owned(name.replace(' ', "_"))
    } else {
        // 不需要修改，返回借用
        Cow::Borrowed(name)
    }
}

let name1 = process_name("hello");        // Borrowed, 无分配
let name2 = process_name("hello world");  // Owned, 有分配

// 错误1: 同时存在可变和不可变借用
let mut v = vec![1, 2, 3];
let first = &v[0];
v.push(4);              // 错误！
println!("{}", first);
// 解决: 将println移到push之前

// 错误2: 从借用的值中移动
let v = vec![String::from("hello")];
let s = v[0];           // 错误！不能从Vec中移动
// 解决: 使用clone或引用
let s = v[0].clone();   // 或 let s = &v[0];

// 错误3: 返回局部变量的引用
fn bad() -> &str {
    let s = String::from("hello");
    &s                   // 错误！s会被drop
}
// 解决: 返回所有权
fn good() -> String {
    String::from("hello")
}

// 错误4: 闭包捕获可变引用
let mut data = vec![1, 2, 3];
let closure = || data.push(4);  // 闭包捕获&mut data
data.push(5);                    // 错误！data已被闭包借用
closure();
// 解决: 调整使用顺序，先用完data再创建闭包