所有权是 rust 语言独有的特性，它保证了在没有垃圾回收机制下的内存安全，所以理解 rust 的所有权是很有必要的。接下来，我们来讨论所有权和它的几个特性：借用、切片和内存结构。
什么是所有权
Rust 的核心特性是所有权。各种语言都有它们自己管理内存的方式，有些是使用垃圾回收机制，有些是手动管理内存，而 rust 使用的是所有权机制来管理内存。
所有权规则
所有权规则如下：
- rust 中的每个值都有一个自己的变量。
- rust 值在同一时间只能绑定一个变量。
- 变量超出作用域，值会自动被销毁。
不懂没关系，跳过往后看。
变量作用域
rust 语言的变量作用域和其他语言是类似的，看例子：
{ // 变量 s 还没有被声明，s 在这里是无效的
let s = "hello"; // 变量 s 是这里声明的，从这里开始生效
// 从这里开始，可以使用 s 做一些工作
} // 变量 s 超出作用域，s 从这里开始不再生效复制代码可以总结两点重要特性：
- 当变量 s 声明之后开始生效
- 当变量 s 出了作用域失效
String 类型
在章节三中学习的数据类型都是存储在内存的栈空间中，当它们的作用域结束时清空栈空间，我们现在学习一下内存的堆空间中存储的数据是在何时被 rust 清空的。
我们在这里使用 String 类型作为例子，当然只是简单的使用，具体的内容后文介绍。
let s = "hello";复制代码这个例子是把 hello 字符串硬编码到程序中，我们把它叫做 字符串文字 (string literals 我不知道别人是怎么翻译的，我实在想不到合适的词，先这样叫着吧)，字符串文字很方便，但是它不能适用于任何场景，比如我们想要输入一个文本串的时候，原理如下：
- 字符串文字是不可修改的
- 编码(编译)时不确定文本串的内容 (比如保存用户的输入)
在这种情况下，我们会使用字符串的第二种类型——String。它是存储在堆内存中的，而且允许在编译期间不知道字符串的大小，我们先使用 from 函数从字符串文字中创建一个 String 类型的字符串。
let s = String::from("hello");复制代码这种双冒号的语法细节下个章节再说，这里先聚焦于字符串，例子中创建的字符串是可以改变的，比如：
let mut s = String::from("hello");
s.push_str(", world!"); // push_str() 在上个字符串后追加一个字符串
println!("{}", s); // 这里会打印 `hello, world!`复制代码内存分配
字符串文字是在编译期间就有确定的字符内容，所以文本可以直接硬编码到程序中，这就是字符串文字快捷方便的原因。但是字符串文字又是不可变的，我们没办法分配内存给编译期间未知大小及变化的字符串。
字符串类型则支持字符串的修改和增长，即使编译期间未知大小，也可以在堆内存分配一块空间用于存储数据，这意味着：
- 内存必须是在运行时，从操作系统中请求 (和大多数编程语言类似，当我们调用 String::from 方法时，就完成了对内存的请求)
- 当不使用这块内存时，我们才会把它返还给操作系统 (和其它语言不同，其它语言是使用垃圾回收机制或手动释放内存)
rust 则是另一种方式：一旦变量超出作用域，程序自动返还内存，通过下面的例子来看这个概念：
{
let s = String::from("hello"); // s 从这里开始生效
// 利用 s 做一些事情
} // s 超出作用域，不再生效复制代码当 s 超出作用域，rust 会自动帮我们调用一个特殊的函数—— drop 函数，它是用于返还内存的，当程序执行到 大括号右半块 } 的时候自动调用该函数。
变量和数据交互方式：移动
在 rust 中，可以使用不同的方式在多个变量间交互相同的数据，比如：
let x = 5; // 把 5 绑定到 x 上
let y = x; // 把 x 的值复制给 y，此时，x 和 y 的值都是 5复制代码再比如：
let s1 = String::from("hello"); // 创建一个字符串绑定到 s1 上
let s2 = s1; // 把 s1 的值移动给 s2，此时，s1 就失效了，只有 s2 是有效的复制代码s1 为什么失效，因为字符串是存储在堆内存中的，这里只是把栈内存中的 s1 的数据移动给 s2，堆内存不变，这种方式叫做浅克隆，也叫移动。如果想让 s1 仍然有效，可以使用深克隆。
变量和数据交互方式：克隆
关于深克隆，我们直接看例子吧：
let s1 = String::from("hello"); // 创建一个字符串绑定到 s1 上
let s2 = s1.clone(); // 把 s1 的值克隆给 s2，此时，s1 和 s2 都是有效的
println!("s1 = {}, s2 = {}", s1, s2); // 打印 s1 和 s2复制代码下一章节再详细介绍这种语法。
只有栈数据：复制
我们再回到前面的例子中：
let x = 5; // 把 5 绑定到 x 上
let y = x; // 把 x 的值复制给 y，此时，x 和 y 的值都是 5
println!("x = {}, y = {}", x, y); // 打印 x 和 y复制代码这里没有使用 clone 这个方法，但是 x 和 y 都是有效的。因为 x 和 y 都是整型，整型存储在栈内存中，即使调用了 clone 方法，也是做相同的事。下面总结一下复制的类型：
- 所有的整型，像 u32，i32
- 布尔类型，像 bool，值是 true， false
- 所有的浮点型，像 f32，f64
- 字符类型，像 char
- 元组，但是仅仅是包含前 4 种类型的元组，像 (u32, i32)，但是 (u32, String) 就不是了
所有权和函数
这里直接放一个例子应该就说清楚了，如下：
fn main() {
let s = String::from("hello"); // s 进入作用域
takes_ownership(s); // s 移动到函数里
// s 从这里开始不再生效，如果还使用 s，则会在编译期报错
let x = 5; // x 进入作用域
makes_copy(x); // x 复制(移动)到函数里,
// 但由于 x 是 i32 ，属于整型，仍有效
// 使用 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 移动进函数，函数返回值移动给 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 是返回值，移出调用函数
}复制代码引用和借用
前面都是把值传入传出函数，这里我们学习一下引用，看个例子：
fn main() {
let s1 = String::from("hello"); // 创建一个字符串 s1
let len = calculate_length(&s1); // 把 字符串 s1 的引用传给函数
println!("The length of '{}' is {}.", s1, len); // 这里可以继续使用 s1
}
fn calculate_length(s: &String) -> usize { // 接收到 字符串 s1 的引用 s
s.len() // 这里返回函数的长度
} // s 超出作用域，但是这里没有字符串的所有权，不释放内存复制代码&s1 语法是创建一个指向 s1 的值的引用，而不是 s1 本身，当引用超出作用域不会释放引用指向值的内存。被调用函数声明参数的时候，参数的类型也需要使用 & 来告知函数接收的参数是个引用。
修改引用
在上述例子中，如果在 calculate_length 函数中修改字符串的内容，编译器会报错，因为传入的引用在默认情况下是不可变引用，如果想要修改引用的内容，需要添加关键字 mut，看例子：
fn main() {
let mut s = String::from("hello");
change(&mut s); // mut 同意函数修改 s 的值
}
fn change(some_string: &mut String) { // mut 声明函数需要修改 some_string 的值
some_string.push_str(", world"); // 追加字符串
}复制代码可变引用有一个很大的限制：在特定作用域中针对同一引用，只能有一个可变引用。比如：
let mut s = String::from("hello");
let r1 = &mut s; // 这是第一个借用的可变引用
let r2 = &mut s; // 这是第二个借用的可变引用，这里会编译不通过
println!("{}, {}", r1, r2);复制代码这个限制的好处是编译器可以编译期间阻止数据竞争，数据竞争发生在如下情况：
- 两个或多个指针同时访问相同的数据
- 多个指针在写同一份数据
- 没有同步数据的机制
数据竞争会造成不可预知的错误，而且在运行时修复是很困难的，rust 在编译期间就阻止了数据竞争情况的发生。但是在不同的作用域下，是可以有多个可变引用的，比如：
let mut s = String::from("hello");
{
let r1 = &mut s;
} // r1 超出作用域
// 这里可以借用新的可变引用了
let r2 = &mut s;复制代码可变引用和不可变引用放在一起，也会出错，比如：
let mut s = String::from("hello");
let r1 = &s; // 不可变引用，没问题
let r2 = &s; // 不可变引用，没问题
let r3 = &mut s; // 可变引用，会发生大问题，因为后面还在使用 r1 和 r2
println!("{}, {}, and {}", r1, r2, r3);复制代码当存在不可变引用时，就不能再借用可变引用了。不可变引用不会修改引用的值，所以可以借用多个不可变引用。但是如果不可变引用都不使用了，就又可以借用可变引用了，比如：
let mut s = String::from("hello");
let r1 = &s; // 不可变引用，没问题
let r2 = &s; // 不可变引用，没问题
println!("{} and {}", r1, r2);
// r1 和 r2 从这里开始不再使用了
let r3 = &mut s; // 可变引用，也没问题了，因为后面没使用 r1 和 r2 的了
println!("{}", r3);复制代码悬空引用
在一些指针语言中，很容易就会错误地创建悬空指针。悬空指针就是过早地释放了指针指向的内存，也就是说，堆内存已经释放了，而指针还指向这块堆内存。在 rust 中，编译器可以保证不会产生悬空引用：如果有引用指向数据，编译器会确保引用指向的数据不会超出作用域，比如：
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String { // 这里希望返回字条串的引用
let s = String::from("hello"); // 创建字符串
&s // 这里返回了字符串的引用
} // 这里会把字符串的内存释放，因为 s 在这里超出作用域复制代码这个函数做个简单的修改就好了，看如下例子：
fn no_dangle() -> String { // 不返回字符串引用了，直接返回字符串
let s = String::from("hello");
s // 返回字符串
}复制代码引用规则
引用的规则如下：
- 任何时候，只能有一个可变引用或多个不可变引用
- 引用必须总是有效的
切片类型
另一个没有所有权的数据类型是切片。切片是集合中相邻的一系列元素，而不是整个集合。
做个小小的编程题目：有一个函数，输入一个英文字符串，返回第一个单词。如果字符串没有空格，则认为整个字符串是一个单词，返回整个字符串。
我们来思考一下这个函数结构：
fn first_word(s: &String) -> ? // 这里应该返回什么复制代码在这个函数中，字符串引用作参数，函数没有字符串的所有权，那我们应该返回什么呢？我们不能返回字符串的一部分，那么，我们可以返回第一个单词结束位置的索引。看实现：
fn first_word(s: &String) -> usize { // 返回一个无符号整型，因为索引不会小于 0
let bytes = s.as_bytes(); // 把字符串转换化字节类型的数组
// iter 方法用于遍历字节数组，enumerate 方法用于返回一个元组，元组的第 0 个元素是索引，第 1 个元素是字节数组的元素
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' { // 如果找到了空格，就返回对应的索引
return i;
}
}
s.len() // 如果没找到空格，就返回字符串的长度
}复制代码现在，我们找到了返回字符串第一个单词的末尾索引，但是还有一个问题：函数返回的是一个无符号整型，返回值只是字符串中的一个有意义的数字。换句话说，返回值和字符串是分开的值，不能保证它永远有意义，比如：
fn main() {
let mut s = String::from("hello world"); // 创建字符串
let word = first_word(&s); // word 被赋值为 5
s.clear(); // 清空字符串，现在字符串的值是 ""
// word 仍是5，但是我们不能得到单词 hello 了，这里使用 word，编译器也不会报错，但是这真的是一个 bug
}
复制代码还有一个问题，如果我们想得到第二个单词，应该怎么办？函数声明应该是：
fn second_word(s: &String) -> (usize, usize) {复制代码如果想得到很多个单词，又应该怎么办？
字符串切片
字符串切片就是字符串一部分的引用，如下：
let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];复制代码就是取字符串 s 中的一部分组成一个新的变量，取值区间左闭右开，就是说，包括左边的索引，不包括右边的索引。
如果左边索引是0，可省略：
let s = String::from("hello");
let slice = &s[0..2];
let slice = &s[..2]; // 和上一行等价复制代码如果右边索引是字符串末尾，可省略：
let s = String::from("hello");
let len = s.len();
let slice = &s[3..len];
let slice = &s[3..]; // 和上一行等价复制代码如果取整个字符串，可以把两边都省略：
let s = String::from("hello");
let len = s.len();
let slice = &s[0..len];
let slice = &s[..]; // 和上一行等价复制代码我们现在看一下一开始讨论的题目应该怎么做：
fn first_word(s: &String) -> &str {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[0..i];
}
}
&s[..]
}复制代码这样就直接返回了第一个单词的内容。如果要返回第二个单词，可写成：
fn second_word(s: &String) -> &str {复制代码我们再来看一下字符串清空的问题是否还存在：
fn main() {
let mut s = String::from("hello world");
let word = first_word(&s); // 不可变借用在这里声明
s.clear(); // 这里会报错，因为这里在修改 s 的内容
println!("the first word is: {}", word); // 不可变借用在这里使用
}复制代码不可变借用的声明和使用之间是不能使用可变借用的。
字符串文字是切片
前面我们讨论过字符串文字的存储问题，现在我们学习了切片，我们可以理解字符串文字了：
let s = "Hello, world!";复制代码s 的类型是 &str，这是一个指向了二进制程序特殊的位置的切片，这就是字符串文字不可变的原是，&str 是一个不可变引用
字符串切片作为参数
前面学习了字符串文字切片和字符串类型切片，我们来提高 first_word 函数的质量。有经验的 rust 开发者会把函数参数类型写成 &str，因为这样可以使得 &String 和 &str 使用相同的函数。好像不太好理解，直接上例子：
fn main() {
let my_string = String::from("hello world"); // 创建字符串
// first_word 使用 &String切片
let word = first_word(&my_string[..]);
let my_string_literal = "hello world"; // 创建字符串
// first_word 使用 &str切片
let word = first_word(&my_string_literal[..]);
// 因为字符串文字已经是字符串切片了，可以不使用切片语法
let word = first_word(my_string_literal);
}复制代码其它切片
我们只举一个 i32 类型切片的例子吧：
let a = [1, 2, 3, 4, 5];
let slice = &a[1..3]; // 值是： [2, 3]复制代码rust 使用了所有权、借用、切片，在编译期确保程序的内存安全。rust 语言提供了和其他编程语言相同的方式来控制内存，而不需要我们编写额外代码来手动管理内存，当数据超出所有者的作用域就会被自动清理。
欢迎阅读单鹏飞的学习笔记
有疑问加站长微信联系（非本文作者）
