什么是所有权

Rust的核心功能（之一）就是所有权，其令 Rust 无需垃圾回收即可保障内存安全。

所有运行的程序都必须管理其使用计算机内存的方式：

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

所有权规则

  • Rust中的每一个值都有一个被称为其所有者（owner）的变量；
  • 值只有一个所有者；
  • 当所有者（变量）离开作用域时，这个值将被丢弃；

变量作用域

1
2
3
4

{                     		 // s 在这里无效, 它尚未声明
    let s = "hello";  		 // 从此处起，s 是有效的
 	//...				 	 // 使用 s
}                      		 // 此作用域已结束，s 不再有效

String类型

String类型被分配到堆上，所以能够存储在编译时未知大小的文本。可以使用 from 函数基于字符串字面值来创建 String，如下：

1

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

这两个冒号（::）是运算符，允许将特定的 from 函数置于 String 类型的命名空间下，而不需要使用类似 string_from 这样的名字。

修改此类字符串 ：

1
2
3

let mut s = String::from("hello");
s.push_str(", world!"); 	// push_str() 在字符串后追加字面值
println!("{}", s); 			// 将打印 `hello, world!`

那么这里有什么区别呢？为什么 String 可变而字面值却不行呢？区别在于两个类型对内存的处理上。

内存与分配

字符串字面值，我们在编译时就知道其内容，所以文本被直接硬编码进最终的可执行文件中。

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

这意味着：

  • 必须在运行时向操作系统请求内存。
  • 需要一个当我们处理完 String 时将内存返回给操作系统的方法。

Rust 采取的策略是：内存在拥有它的变量离开作用域后就被自动释放。

👆上面这句话很重要，建议读三遍。

1
2
3
4
5

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

这是一个将 String 需要的内存返回给操作系统的很自然的位置：当 s 离开作用域的时候。

当变量离开作用域，Rust 为我们调用一个特殊的函数，这个函数叫做 drop。在这里 String 的作者可以放置释放内存的代码。Rust 在结尾的 } 处自动调用 drop。

数据移动

1
2

let x = 5;
let y = x;

我们大致可以猜到这在干什么：“将 5 绑定到 x；接着生成一个值 x 的拷贝并绑定到 y”。现在有了两个变量，x 和 y，都等于 5。

现在看看这个 String 版本：

1
2

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

这看起来与上面的代码非常类似，所以我们可能会假设他们的运行方式也是类似的：也就是说，第二行可能会生成一个 s1 的拷贝并绑定到 s2 上。不过，事实上并不完全是这样。

👇下面这张图展示了String类型的底层存储由三部分组成：

  • 一个指向存放字符串内容内存的指针
  • 一个长度
  • 一个容量 这一组数据存储在栈上。右侧则是堆上存放内容的内存部分。 在这里插入图片描述 当我们将 s1 赋值给 s2，String 的数据被复制了，这意味着我们从栈上拷贝了它的指针、长度和容量。我们并没有复制指针指向的堆上数据。换句话说，内存中数据的表现如下图所示： 在这里插入图片描述

之前我们提到过当变量离开作用域后，Rust 自动调用 drop 函数并清理变量的堆内存。不过上图展示了两个数据指针指向了同一位置。这就有了一个问题：当 s2 和 s1 离开作用域，他们都会尝试释放相同的内存。这是一个叫做 二次释放的错误，也是之前提到过的内存安全性 bug 之一。两次释放（相同）内存会导致内存污染，它可能会导致潜在的安全漏洞。

为了确保内存安全，Rust的处理是，与其尝试拷贝被分配的内存，Rust 则认为 s1 不再有效，因此 Rust 不需要在 s1 离开作用域后清理任何东西。

看看在 s2 被创建之后尝试使用 s1 会发生什么：

1
2
3

let s1 = String::from("hello");
let s2 = s1;
println!("s1 = {}, s2 = {}", s1, s2);

你会得到一个类似如下的错误，因为 Rust 禁止你使用无效的引用。

1
2
3
4
5
6
7
8
9

error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:4:31
  |
2 |     let s1 = String::from("hello");
  |         -- move occurs because `s1` has type `std::string::String`, which does not implement the `Copy` trait
3 |     let s2 = s1;
  |              -- value moved here
4 |     println!("s1 = {}, s2 = {}", s1, s2);
  |                                  ^^ value borrowed here after move

如果你在其他语言中听说过术语 浅拷贝（shallow copy）和 深拷贝（deep copy），那么拷贝指针、长度和容量而不拷贝数据可能听起来像浅拷贝。

这种 Rust 使第一个变量无效的操作被称为 移动（move），而不是浅拷贝。

那么当s1被移动到s2时，究竟发生了什么？ 在这里插入图片描述

这样就解决了我们的问题！因为只有 s2 是有效的，当其离开作用域，它就释放自己的内存，完毕。

另外，这里还隐含了一个设计选择：Rust 永远也不会自动创建数据的 “深拷贝”。因此，任何 自动 的复制可以被认为对运行时性能影响较小。

克隆

如果确实需要复制String堆上的数据，可以使用clone方法。

1
2
3

let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);

运行可以正常输出。

但是要注意，当调用clone方法时可能比较消耗资源。

拷贝

继续讨论下面的一段代码：

1
2
3

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

运行发现也没报错，和我们上面介绍的很矛盾：没有调clone，x也没被移动到y中。

原因是这种在编译时就已知大小的类型会被存储在栈上，拷贝也相当快速，就没必要在创建变量 y 后使 x 无效，即相当于自动调用了clone。

Copy trait 如果一个类型拥有Copy trait，一个旧的变量在将其赋值给其他变量后仍然可用（比如上面代码里面x）。Rust 不允许自身或其任何部分实现了Drop trait 的类型使用 Copy trait。

那么什么类型是 Copy 的呢？可以查看给定类型的文档来确认，不过作为一个通用的规则，任何简单标量值的组合可以是 Copy 的，不需要分配内存或某种形式资源的类型是 Copy 的。

如下是一些 Copy 的类型：

  • 所有整数类型，比如 u32。
  • 布尔类型bool，它的值是 true 和 false。
  • 所有浮点数类型，比如 f64。
  • 字符类型，char。
  • 元组，当且仅当其包含的类型也都是 Copy 的时候。比如，(i32, i32) 是 Copy 的，但 (i32, String) 就不是。

所有权与函数

将值传递给函数在语义上与给变量赋值相似，向函数传递值可能会移动或者复制，就像赋值语句一样。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

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 移出作用域。不会有特殊操作

返回值和作用域

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

 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

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("hello"); // 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 并移出给调用的函数
}

变量的所有权总是遵循相同的模式：

  • 将值赋给另一个变量时移动它，除非变量类型实现了Copy trait注解。
  • 当持有堆中数据值的变量离开作用域时，其值将通过 drop 被清理掉，除非数据被移动为另一个变量所有。

多值返回

函数或者方法可以使用元组来实现多值返回。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

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)
}