study Rust-4【所有权】这个太重要了！

由于Rust内存垃圾自动回收，那就得搞清楚这个所有权玩意。这个太重要了。因为关系到贯穿于你以后的程序编写。

几个概念：

一、移动

1、咱们一般语言，自己申请内存，自己管理和释放。就是new和free。

咱们搞不好就内存泄漏。

2、看Rust

let s1 = String::from("hello");
let s2 = s1;
println!("{}, world!", s1); // 错误！s1 已经失效

Rust内存管理看下图【 这就是Rust的移动管理】：

传统的内存管理看图：

二、克隆

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

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

s1 = hello, s2 = hello 
运行结果。

这里是真的将堆中的 "hello" 复制了一份，所以 s1 和 s2 都分别绑定了一个值，释放的时候也会被当作两个资源。

当然，克隆仅在需要复制的情况下使用，毕竟复制数据会花费更多的时间。

三、涉及函数的所有权机制

//请仔细看注释，已经把过程说明很清楚了

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 是基本类型, 无需释放

//函数返回值的所有权机制
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 被当作返回值移出函数
}

四、引用与租借【这段理解简单，但是使用复杂，比较绕】

引用（Reference）是 C++ 开发者较为熟悉的概念。

如果你熟悉指针的概念，你可以把它看作一种指针。

实质上"引用"是变量的间接访问方式。

fn main() {
    let s1 = String::from("hello");
    let s2 = &s1;
    println!("s1 is {}, s2 is {}", s1, s2);
}
//运行结果：s1 is hello, s2 is hello

=================================
fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
    s.len()
}
结果：The length of 'hello' is 5.

引用不会获得值的所有权。

引用只能租借（Borrow）值的所有权。

引用本身也是一个类型并具有一个值，这个值记录的是别的值所在的位置，但引用不具有所指值的所有权：

容易绕的地方：

fn main() {
    let s1 = String::from("hello");
    let s2 = &s1;//s2 租借的
    let s3 = s1;//s1所有权转移到s3了，所以s2将无法继续租借使用s1的所有权,s2也就无效了
    println!("{}", s2);
}
====================
//租来的只有使用权，不可编辑修改。看下面
fn main() {
    let s1 = String::from("run");
    let s2 = &s1; 
    println!("{}", s2);
    s2.push_str("oob"); // 错误，禁止修改租借的值
    println!("{}", s2);
}
=======================
你非要对租来的进行行使所有权，这样做：
fn main() {
    let mut s1 = String::from("run");
    // s1 是可变的
    let s2 = &mut s1;
    // s2 是可变的引用
    s2.push_str("oob");
    println!("{}", s2);
}
=====================
//可变引用与不可变引用相比除了权限不同以外，可变引用不允许多重引用，但不可变引用可以.下面是错误的
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;//多重引用，错误的
println!("{}, {}", r1, r2);

垂悬引用（Dangling References）【这个好理解】

这是一个换了个名字的概念，如果放在有指针概念的编程语言里它就指的是那种没有实际指向一个真正能访问的数据的指针（注意，不一定是空指针，还有可能是已经释放的资源）。它们就像失去悬挂物体的绳子，所以叫"垂悬引用"。

"垂悬引用"在 Rust 语言里不允许出现，如果有，编译器会发现它。