1. 简介

所有运行的程序都必须管理其使用计算机内存的方式。一些语言中具有垃圾回收机制,在程序运行时不断地寻找不再使用的内存;在另一些语言中,程序员必须亲自分配和释放内存。Rust 则选择了第三种方式:通过所有权系统管理内存,编译器在编译时会根据一系列的规则进行检查。在运行时,所有权系统的任何功能都不会减慢程序。

2. 所有权规则

  • Rust 中每一个值都有一个被称为「所有者」的变量。
  • 值在任一时刻有且只有一个所有者。
  • 当所有者离开作用域,这个值将被丢弃(内存回收)。

2.1 作用域

变量的作用域是其在程序中有效的范围,一个变量作用域从声明的地方开始一直持续到最后一次使用为止,且其作用域被限制在变量声明所处的最内层 {} 代码块中,即最大不能超出其所处的最内层 {} 区域。

2.2 垃圾回收

  • 在有垃圾回收(garbage collector,GC)的语言中, GC 记录并清除不再使用的内存,而我们并不需要关心它。
  • 在没有 GC 的语言中,需要手动识别出不再使用的内存并调用代码显式释放,跟请求内存的时候一样。

Rust 采取了一个不同的策略:内存在拥有它的变量离开作用域后就被自动释放。

3. 变量与数据交互方式

以 Rust 标准库中的 String 数据类型为例。一个 String 类型的变量实际由三部分组成:

  • 一个指向存放字符串内容内存的指针字段
  • 一个长度字段
  • 一个容量字段

以上三部分都是存储在栈上,而由指针指向的字符串是存储在堆上的。

String

3.1 移动

  • 对于在栈上的变量,本质上并没有移动的概念。
  • 对于在堆上的变量,比如 String,当将一个 String 变量赋值给另一个 String 变量时,拷贝的只是存储在栈上的内容:
1
2
let s1 = String::from("hello");
let s2 = s1;

StringAsign

因此,两个数据指针同时指向同一个堆内存位置,即同一个堆内存地址有两个所有者,这样会导致在垃圾回收时出现「二次释放」的错误。即当 s1s2 离开作用域是都将尝试释放同一块堆内存。

  • 为了确保内存安全,与其尝试拷贝被分配的内存,Rust 则认为 s1 不再有效,因此 Rust 不需要在 s1 离开作用域后清理任何东西。
  • 当将 s1 赋值给 s2 后,s1 就失效了,往后对它的访问都会引发错误。
  • 这样看起来将 s1 赋值给 s2 不是「拷贝」,而是「移动」。

StringMove

【注】「将值传递给函数」以及「将值从函数返回」在语义上与给变量赋值相似。

3.2 克隆

  • 对于栈上的变量,将一个变量赋值给另一个变量即为克隆。
  • 对于堆上的变量,将一个变量赋值给另一个变量实为移动,如果确实需要赋值 s1 中堆上的数据,而不仅仅是栈上的数据,可以使用 clone 函数来实现克隆。克隆后的两个 String 变量指向的堆内存是不相同的,因此都是有效的:
1
2
3
4
let s1 = String::from("hello");
let s2 = s1.clone();

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

StringClone

【注】当出现 clone 调用时,一些特定的代码被执行而且这些代码可能相当消耗资源。

4. 引用

如果我们想将一个 String 变量传给调用函数,并在调用函数后仍然能够使用该 String

  • 一种方式是将该 String 作为函数返回值的一部分,但这过于繁琐。
  • 另一种方式就是使用不获取值的所有权的「引用」。

在 Rust 中,使用 & 来获取一个变量的引用。变量的引用允许使用值但不获得其所有权。

Reference

  • 引用可以看作是一种特殊的变量,其有效作用域和普通变量一样。
  • 当引用离开作用域后并不丢弃它指向的数据,因为它没有指向的数据的所有权。
  • 正如变量默认是不可变的,引用也一样,(默认)不允许修改引用的值。
  • 若需要创建可变引用,首先需要将原 String 变量设为 mut,然后使用 &mut 创建可变引用。
1
2
let mut s = String::from("hello");
let r = &mut s;
  • 可变引用有一个很大的限制:在特定作用域中的特定数据只能有一个可变引用,而且也不能在拥有不可变引用的同时拥有可变引用。
  • 一个引用的作用域从声明的地方开始一直持续到最后一次使用为止,因此在最后一次使用不可变引用后是可以声明可变引用的(因为它们的作用域没有重叠)。
1
2
3
4
5
6
7
8
9
let mut s = String::from("hello");

let r1 = &s; // 没问题
let r2 = &s; // 没问题
println!("{} and {}", r1, r2);
// 此位置之后 r1 和 r2 不再使用

let r3 = &mut s; // 没问题
println!("{}", r3);
  • 编译器会确保指向 String 的引用持续有效。

【注】在任意给定时间,要么只能有一个可变引用,要么只能有多个不可变引用;而且在作用域内引用必须总是有效的。

在 Rust 中,将获取「引用」作为函数参数称为「借用」。

5. Slice

Slice 是一种特殊的引用,它允许你引用集合中一段连续的元素序列,而不用引用整个集合。可以使用一个由中括号中的 [starting_index..ending_index] 指定的 range 创建一个 Slice:

  • starting_index 是 Slice 的第一个位置,ending_index 则是 Slice 最后一个位置的后一个值。
  • 在其内部,Slice 的数据结构存储了 Slice 的开始位置和长度,长度对应于 ending_index 减去 starting_index 的值。
  • 如果 Slice 包含第一个索引(0),可以不写两个点号之前的值。
  • 如果 Slice 包含最后一个索引,可以不写两个点号之后的值。
1
2
3
4
let s = String::from("hello world");

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

Slice

了解了 Slice,就可以正确地理解「字符串字面值」:字符串字面值本质就是 Slice。

1
let s = "Hello, world!";

其中,s 的类型是 &str,它是一个执行二进制程序特定位置的 Slice。这也就是为什么字符串字面值是不可变的,因为 &str 是一个不可变引用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 读取字符串第一个单词
fn first_word(s: &str) -> &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");

// first_word 中传入 `String` 的 Slice
let word = first_word(&my_string[..]);

let my_string_literal = "hello world";

// first_word 中传入字符串字面值的 Slice
let word = first_word(&my_string_literal[..]);

// 因为字符串字面值就是字符串 Slice,
// 这样写也可以,即不使用 Slice 语法!
let word = first_word(my_string_literal);
}