所有权三原则 ​

核心概念 ​

所有权(Ownership)是 Rust 最核心的特性,它让 Rust 在没有垃圾回收的前提下实现了内存安全。整个所有权系统建立在三条简单的规则之上,编译器在编译期检查这些规则,违反任何一条都会导致编译错误。

规则一:每个值都有且只有一个所有者 ​

在 Rust 中,每个值在任意时刻都有且只有一个变量作为它的"所有者"。不存在两个变量同时拥有同一个值的情况。

rust
fn main() {
    // s1 是字符串 "hello" 的所有者
    let s1 = String::from("hello");

    // 所有权从 s1 转移到 s2(移动语义)
    let s2 = s1;
    // 此时 s2 是所有者,s1 不再有效

    println!("{}", s2);    // 可以使用 s2
    // println!("{}", s1); // 编译错误:s1 的所有权已经转移
}

规则二:同一时间只能有一个所有者 ​

当所有权从一个变量转移到另一个变量时,原变量立即失效。这杜绝了"两个变量同时拥有同一份堆数据"的情况,从根源上避免了双重释放(double free)问题。

rust
fn main() {
    let v1 = vec![1, 2, 3];

    // 赋值导致所有权转移
    let v2 = v1;
    // v1 不再有效,v2 是唯一的所有者

    // 传参也会转移所有权
    let v3 = vec![4, 5, 6];
    take_ownership(v3);
    // v3 不再有效,所有权已转移到函数参数中

    println!("{:?}", v2);
    // println!("{:?}", v3); // 编译错误:值已移动
}

fn take_ownership(data: Vec<i32>) {
    // data 是这个 Vec 的所有者
    println!("接收到: {:?}", data);
    // 函数结束时 data 被销毁
}

规则三:当所有者离开作用域,值被销毁 ​

变量离开其所在的作用域时,Rust 自动调用 drop 函数释放该变量拥有的资源。不需要手动释放内存,也不需要垃圾回收器。

rust
fn main() {
    {
        let s = String::from("hello");
        // s 在这个作用域内有效
        println!("{}", s);
    } // s 离开作用域,String 的内存被自动释放

    // println!("{}", s); // 编译错误:s 已不存在
}

所有权转移的场景 ​

rust
fn main() {
    // 场景一:变量赋值
    let a = String::from("data");
    let b = a;  // 所有权从 a 转移到 b
    // a 不再可用

    // 场景二:函数传参
    let c = String::from("param");
    process(c);  // 所有权转移到函数参数
    // c 不再可用

    // 场景三:函数返回值
    let d = create();  // 所有权从函数返回给 d
    println!("{}", d);

    // 场景四:集合操作
    let mut items = vec![String::from("a"), String::from("b")];
    let first = items.remove(0);  // 所有权从 Vec 转移到 first
    println!("取出: {}", first);
    println!("剩余: {:?}", items);
}

fn process(s: String) {
    println!("处理: {}", s);
    // s 在函数结束时被销毁
}

fn create() -> String {
    let s = String::from("新创建的");
    s  // 所有权转移给调用者
}

Copy 类型的例外 ​

基本类型(整数、浮点数、布尔值、字符)实现了 Copy trait,赋值时是复制而不是移动,原变量仍然可用。

rust
fn main() {
    // 基本类型:复制,不是移动
    let x = 42;
    let y = x;  // x 被复制了一份给 y
    println!("x = {}, y = {}", x, y);  // 两个都可用

    let a = true;
    let b = a;  // 复制
    println!("a = {}, b = {}", a, b);

    let c = 3.14;
    let d = c;  // 复制
    println!("c = {}, d = {}", c, d);

    // 堆分配类型:移动,不是复制
    let s1 = String::from("hello");
    let s2 = s1;  // 移动
    // println!("{}", s1);  // 编译错误

    // 元组:如果所有元素都是 Copy 的,元组也是 Copy 的
    let t1 = (1, 2.0, true);
    let t2 = t1;  // 复制
    println!("{:?}, {:?}", t1, t2);  // 两个都可用

    // 元组:如果包含非 Copy 类型,就是移动
    let t3 = (1, String::from("hello"));
    let t4 = t3;  // 移动
    // println!("{:?}", t3);  // 编译错误
    println!("{:?}", t4);
}
行为Copy 类型非 Copy 类型
赋值 let b = a复制,a 仍可用移动,a 不可用
传参 foo(a)复制,a 仍可用移动,a 不可用
内存位置栈上通常涉及堆
释放无需特殊处理离开作用域时 drop
常见类型i32、f64、bool、charString、Vec、Box

为什么需要所有权 ​

所有权系统解决了其他语言中常见的内存问题:

rust
fn main() {
    // 问题一:双重释放 —— Rust 通过所有权转移杜绝
    let s1 = String::from("hello");
    let s2 = s1;  // s1 失效,只有 s2 会释放内存
    // 不可能两个变量都去释放同一块内存

    // 问题二:悬垂指针 —— Rust 不允许引用超过数据的生命周期
    // fn dangling() -> &String {  // 编译错误
    //     let s = String::from("hello");
    //     &s  // s 在函数结束时被释放,引用会悬垂
    // }

    // 问题三:内存泄漏 —— Rust 在所有者离开作用域时自动释放
    {
        let data = vec![1, 2, 3, 4, 5];
        // 使用 data...
    } // data 自动释放,不会泄漏

    println!("{}", s2);
}

基本示例 ​

用所有权规则管理资源的完整示例:

rust
struct FileHandle {
    name: String,
    content: String,
}

impl FileHandle {
    // 创建时获得所有权
    fn new(name: &str) -> FileHandle {
        println!("[打开] {}", name);
        FileHandle {
            name: name.to_string(),
            content: String::new(),
        }
    }

    // &mut self:借用,不转移所有权
    fn write(&mut self, data: &str) {
        self.content.push_str(data);
        println!("[写入] {} -> '{}'", self.name, data);
    }

    // &self:借用,不转移所有权
    fn read(&self) -> &str {
        &self.content
    }
}

// 实现 Drop trait:所有者离开作用域时自动调用
impl Drop for FileHandle {
    fn drop(&mut self) {
        println!("[关闭] {}", self.name);
    }
}

fn process_file(mut file: FileHandle) {
    // file 获得了所有权
    file.write("被处理函数写入的内容");
    println!("内容:{}", file.read());
    // 函数结束时 file 被销毁,自动调用 drop
}

fn main() {
    let mut f1 = FileHandle::new("config.txt");
    f1.write("key=value");
    println!("读取:{}", f1.read());

    // 所有权转移给函数
    process_file(f1);
    // f1 不再可用,FileHandle 已在 process_file 结束时关闭

    {
        let f2 = FileHandle::new("temp.txt");
        // f2 在作用域结束时自动关闭
    }

    println!("程序继续...");
}

常见问题 ​

问题一:为什么 Rust 不像 Java/Go 那样用垃圾回收?

垃圾回收有运行时开销(暂停、内存占用、不可预测的延迟)。Rust 的所有权系统在编译期就确定了每个值什么时候释放,运行时零开销,释放时机完全可预测。

问题二:所有权转移后还想用原来的变量怎么办?

三种方式:用 .clone() 创建深拷贝、用引用(&T 或 &mut T)借用而不转移所有权、让函数返回值把所有权还回来。

问题三:所有三条规则是编译器检查的还是运行时检查的?

完全是编译期检查。如果代码违反所有权规则,程序根本无法编译通过。编译通过的代码不会出现所有权相关的内存错误。

问题四:为什么基本类型可以复制而 String 不行?

基本类型(如 i32)只在栈上存储,大小固定且很小,复制成本极低。String 包含堆上的动态数据,浅拷贝会导致两个变量指向同一块堆内存,产生双重释放问题。

适用场景 ​

  • 资源管理:文件句柄、网络连接、数据库连接等通过所有权自动释放
  • 内存安全:编译器保证没有悬垂指针、双重释放、使用已释放的内存
  • 线程安全:所有权规则天然防止数据竞争
  • API 设计:通过函数参数的所有权/借用选择来表达接口意图

注意事项 ​

  • 每个值只有一个所有者,赋值和传参会转移所有权(非 Copy 类型)
  • Copy 类型赋值时是复制,原变量仍然有效
  • 所有者离开作用域时值被自动释放
  • 如果需要保留原变量,用 .clone() 或引用
  • 所有权规则是编译期检查,没有运行时开销
  • 不要为了避免所有权转移而到处 .clone(),优先考虑使用引用

总结 ​

Rust 所有权系统建立在三条规则上:每个值有且只有一个所有者、同一时间只能有一个所有者、所有者离开作用域时值被销毁。这三条规则让编译器能在编译期确定每个值的生命周期和释放时机,实现了无垃圾回收的内存安全。赋值和传参默认会转移所有权(移动语义),实现了 Copy trait 的基本类型除外。所有权系统是 Rust 的核心特性,理解它是掌握 Rust 编程的第一步。