---

0 引入

主要介绍Rust所有权的知识，涉及到变量的作用域，内存释放机制，移动，克隆，引用等知识，很多知识是Rust语言特有机制。

---

1、所有权

所有权有以下三条规则：

- Rust 中的每个值都有一个变量，称为其所有者。
- 一次只能有一个所有者。
- 当所有者不在程序运行范围时，该值将被删除。

{
    // 在声明以前，变量 s 无效
    let s = "runoob";
    // 这里是变量 s 的可用范围
}
// 变量范围已经结束，变量 s 无效

---

2、内存和分配

大多数的编程语言都有管理内存的功能：

1、C/C++ 这样的语言主要通过手动方式管理内存，开发者需要手动的申请和释放内存资源。但为了提高开发效率，只要不影响程序功能的实现，许多开发者没有及时释放内存的习惯。所以手动管理内存的方式常常造成资源浪费，而且容易出现内存释放遗忘，造成内存泄漏。
2、Java 语言编写的程序在虚拟机（JVM）中运行，JVM 具备自动回收内存资源的功能。但这种方式常常会降低运行时效率，所以 JVM 会尽可能少的回收资源，这样也会使程序占用较大的内存资源。
3、所有权对大多数开发者而言是一个新颖的概念，它是 Rust 语言为高效使用内存而设计的语法机制。所有权概念是为了让 Rust 在编译阶段更有效地分析内存资源的有用性以实现内存管理而诞生的概念。
4、所有权的设定，看起来很奇怪，其实本质上就是在语言层面禁止了同一个可变数据会有多个变量引用的情况，一旦作为参数传递了，就会发生所有权的移动（Move）或借用（Borrow）。赋值给另一个变更也就自动放弃了所有权。从根本上杜绝了并发情景下的数据共享冲突。
5、Rust数据类型可以分为基本的数据类型和其他可变数据类型（String等可变长）
基本数据"类型有这些：
所有整数类型，例如 i32 、 u32 、 i64 等。
布尔类型 bool，值为 true 或 false 。
所有浮点类型，f32 和 f64。
字符类型 char。
仅包含以上类型数据的元组（Tuples）。
基本数据一般定义的时候都在栈上，其他的在堆上，数据在哪上面，只要所有权丧失，Rust就会自动释放

---

3、移动与克隆

3.1、移动

如下代码：

    //基本数据在栈中定义，交互数据是直接复制的，通过移动复制
    let x = 5;
    let y = x;
    println!("{}, {}",x,y);

	//其他数据在堆中交互
	let s1 = String::from("hello");
	let s2 = s1;                // 为了确保安全，在给 s2 赋值时 s1 已经无效了
	println!("{}, world!", s1); // 错误！s1 已经失效

3.2、克隆

Rust会尽可能地降低程序的运行成本，所以默认情况下，长度较大的数据存放在堆中，且采用移动的方式进行数据交互。但如果需要将数据单纯的复制一份以供他用，可以使用数据的第二种交互方式——克隆。

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

这样就会有两份独立的数据。

---

4、引用与租借

4.1、引用

引用（Reference）是 C++ 开发者较为熟悉的概念。如果你熟悉指针的概念，你可以把它看作一种指针。实质上"引用"是变量的间接访问方式。

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

1、当一个变量的值被引用时，变量本身不会被认定无效。因为"引用"并没有在栈中复制变量的值；
2、引用不会获得值的所有权。引用只能租借（Borrow）值的所有权。引用本身也是一个类型并具有一个值，这个值记录的是别的值所在的位置，但引用不具有所指值的所有权；

fn main() {
    let s1 = String::from("hello");
    let s2 = &s1;
    let s3 = s1;
    println!("{}", s2);
}
//注意 因为 s2 租借的 s1 已经将所有权移动到 s3，所以 s2 将无法继续租借使用 s1 的所有权。如果需要使用 s2 使用该值，必须重新租借，如下

fn main() {
    let s1 = String::from("hello");
    let mut s2 = &s1;
    let s3 = s1;
    s2 = &s3;        // 重新从 s3 租借所有权
    println!("{}", s2);
}

3、租借的所有权不能修改所有者的值，既然引用不具有所有权，即使它租借了所有权，它也只享有使用权。
4、可变引用与不可变引用相比除了权限不同以外，可变引用不允许多重引用，但不可变引用可以。

fn main() {
    let s1 = String::from("run");
    let s2 = &s1;
    println!("{}", s2);
    s2.push_str("oob"); // 错误，禁止修改租借的值
    println!("{}", s2);
}
//当然加上 mut表示可变变量时候，是允许修改的
fn main() {
    let mut s1 = String::from("run");
    // s1 是可变的

    let s2 = &mut s1;
    // s2 是可变的引用

    s2.push_str("oob");
    println!("{}", s2);
}

4.1、垂悬引用

在C++中就是：放在有指针概念的编程语言里它就指的是那种没有实际指向一个真正能访问的数据的指针（注意，不一定是空指针，还有可能是已经释放的资源），Rust中不允许这样情况发生。
典型的就是在一个函数定义一个局部变量，函数返回值是一个引用，讲局部变量引用返回这种情况。

–

5、函数中变量

5.1 参数变量

函数中变量释放机制和上面介绍的一样，注意品味下面的。

fn main() {
    let s = String::from("hello"); // s 被声明有效
    takes_ownership(s); // s 的值被当作参数传入函数， 所以可以当作 s 已经被移动，从这里开始已经无效
    let x = 5;          // x 被声明有效
    makes_copy(x);      // x 的值被当作参数传入函数
                        // 但 x 是基本类型，依然有效
                        // 在这里依然可以使用 x 却不能使用 s
} // 函数结束, x 无效, 然后是 s. 但 s 已被移动, 所以不用被释放

fn takes_ownership(some_string: String) { // 一个 String 参数 some_string 传入，有效
    println!("{}", some_string);
} // 函数结束, 参数 some_string 在这里释放

fn makes_copy(some_integer: i32) {// 一个 i32 参数 some_integer 传入，有效
    println!("{}", some_integer);
} // 函数结束, 参数 some_integer 是基本类型, 无需释放

5.2 、返回值变量

被当作函数返回值的变量所有权将会被移动出函数并返回到调用函数的地方，而不会直接被无效释放。

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 {
    let some_string = String::from("hello"); // some_string 被声明有效
    return some_string; // some_string 被当作返回值移动出函数
}
fn takes_and_gives_back(a_string: String) -> String { 
    // a_string 被声明有效
    a_string  // a_string 被当作返回值移出函数
}