所有权是 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 语言提供了和其他编程语言相同的方式来控制内存，而不需要我们编写额外代码来手动管理内存，当数据超出所有者的作用域就会被自动清理。
欢迎阅读单鹏飞的学习笔记