Rust Ownership

Dec 9, 2023 · Sricor

所有权

每一个值都有一个所有者
At any given time, you can have either (but not both) one mutable reference or any number of immutable references.
References must always be valid.
将值赋给另一个变量（包含函数实参）时移动它
当持有堆中数据值的变量离开作用域时，其值将通过 drop 被清理掉，除非数据被移动为另一个变量所有

所有权与函数

fn main() {
    let s = String::from("hello");  // s 进入作用域

    takes_ownership(s);             // s 的值移动到函数里 ...
                                    // ... 所以到这里不再有效

    let x = 5;                      // x 进入作用域

    makes_copy(x);                  // x 应该移动函数里，
                                    // 但 i32 是 Copy 的，
                                    // 所以在后面可继续使用 x

} // 这里，x 先移出了作用域，然后是 s。但因为 s 的值已被移走，所以不会发生改变

fn takes_ownership(some_string: String) { // some_string 进入作用域
    println!("{}", some_string);
} // 这里，some_string 移出作用域并调用 `drop` 方法。
  // 占用的内存被释放

fn makes_copy(some_integer: i32) { // some_integer 进入作用域
    println!("{}", some_integer);
} // some_integer 移出作用域

返回值与作用域

返回值也可以转移所有权。

fn main() {
    let s1 = gives_ownership();         // gives_ownership 将返回值
                                        // 转移给 s1

    let s2 = String::from("hello");     // s2 进入作用域

    let s3 = takes_and_gives_back(s2);  // s2 被移动到
                                        // takes_and_gives_back 中，
                                        // 它也将返回值移给 s3

} // s3 移出作用域并被丢弃。
  // s2 也移出作用域，但已被移走，所以什么也不会发生。
  // s1 离开作用域并被丢弃。

fn gives_ownership() -> String {             // gives_ownership 会将
                                             // 返回值移动给
                                             // 调用它的函数

    let some_string = String::from("yours"); // some_string 进入作用域。

    some_string                              // 返回 some_string 
                                             // 并移出给调用的函数
                                             // 
}

// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域
                                                      // 

    a_string  // 返回 a_string 并移出给调用的函数
}

使用元组来返回多个值

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

    let (s2, len) = calculate_length(s1);

    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len(); // len() 返回字符串的长度

    (s, length)
}

变量的所有权总是遵循相同的模式：将值赋给另一个变量（包含函数实参）时移动它。 当持有堆中数据值的变量离开作用域时，其值将通过 drop 被清理掉，除非数据被移动为另一个变量所有。

变量与数据交互的方式（一）：移动

let x = 5; 
let y = x;

将 5 绑定到 x，接着生成一个值 x 的拷贝并绑定到 y。现在有了两个变量，x 和 y，都等于 5。因为整数是有已知固定大小的简单值，所以这两个 5 被放入了栈中。

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

// Error borrow of moved value: `s1`
// println!("{}, world!", s1);  // s1 不再有效

假如 s2 同时拷贝 s1 栈与堆的数据，当数据量比较大的时候会对性能造成非常大的影响
假如 s2 只拷贝 s1 栈上的数据，而不拷贝堆上数据，当 s2 与 s1 离开作用域时，自动调用 drop 函数并尝试释放相同的堆内存，会出现二次释放错误，可能会导致潜在的安全漏洞 为了确保内存安全，在 let s2 = s1; 之后，s1 被移动到了 s2，s1将不再有效 ![[Drawing 2023-11-19 19.57.45.excalidraw.svg]] Rust 永远也不会自动创建数据的 “深拷贝”，任何自动的复制都可以被认为是对运行时性能影响较小的。

变量与数据交互的方式（二）：克隆

如果我们确实需要深度复制 String 中堆上的数据，而不仅仅是栈上的数据，可以使用一个叫做 clone 的通用函数，这可能相当消耗资源。

let s1 = String::from("hello");
let s2 = s1.clone();  // 堆上的数据被复制了

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

对于只在栈上的数据，是直接克隆的。编译时已知大小的类型被整个存储在栈上，所以拷贝其实际的值是快速的。

let x = 5; 
let y = x; 
println!("x = {}, y = {}", x, y);

如果一个类型实现了 Copy trait，那么一个旧的变量在将其赋值给其他变量后仍然可用。

实现了 Copy trait的类型 任何一组简单标量值的组合都可以实现 Copy 任何不需要分配内存或某种形式资源的类型都可以实现 Copy，如下：

所有整数类型
所有浮点数类型
布尔类型
字符类型
元组（当且仅当其包含的所以元素类型也都实现 Copy ）

Rust 不允许自身或其任何部分实现了 Drop trait 的类型使用 Copy trait

内存与分配

字符串字面值在编译时就知道其内容，所以文本被直接硬编码进最终的可执行文件中。这使得字符串字面值快速且高效，不过这些特性都只得益于字符串字面值的不可变性。

对于 String 为了支持一个可变，可增长的文本片段，需要在堆上分配一块在编译时未知大小的内存来存放内容，意味着需要：

必须在运行时向内存分配器（Memory Allocator）请求内存
需要一个当我们处理完 String 时将内存返回给分配器的方法

第一部分由我们完成：当调用 String::from 时，它的实现请求其所需的内存。第二部分由Rust完成：当变量离开作用域，Rust 在结尾的 } 处自动调用 drop，内存在拥有它的变量离开作用域后就被自动释放。

{
	let s = String::from("hello"); // 从此处起，s 是有效的
	...
}                                  // 此作用域已结束，s 不再有效

在生命周期结束时释放资源的模式被称作 资源获取即初始化（Resource Acquisition Is Initialization (RAII)）。

切片类型

在 Rust 中，切片（slice）是对集合中一部分元素的引用，允许你引用集合中的连续或非连续的元素序列而无需复制数据。切片是一种轻量级的数据结构，主要有两种类型：数组切片和字符串切片。

数组切片：
- 对于数组，切片是对数组的引用，指定了数组的一部分。
- 语法示例：&array[start..end]，其中 start 是起始索引，end 是结束索引。
- 例如： let my_array = [1, 2, 3, 4, 5]; let my_slice = &my_array[1..4];
字符串切片：
- 对于字符串，切片是对字符串的引用，指定了字符串的一部分。
- 语法示例：&str[start..end]，其中 start 是起始索引，end 是结束索引。
- 例如： let my_string = “Hello, World!”; let my_slice = &my_string[7..12];

切片的使用使得你能够在不拥有整个集合所有权的情况下，访问集合的一部分。切片是一个很重要的 Rust 特性，它在处理数据时允许更灵活的操作，而不会引入额外的性能开销。

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

let hello = &s[0..5];  // &str
let world = &s[6..11];