Rust語言開發基礎（七）Rust 特性

這部分是Rust語言的核心部分，掌握起來有必定難度，特別是生命週期部分，讓人有Rust的學習曲線陡升的感受，爬過這座高峯，其它皆坦途。
這部分也是讓人以爲Rust語言比其它語言如C/C++等複雜的主要緣由之一，即便是寫文章介紹起來也感受不容易。

1、全部權（ownership）
基本概念：一個變量同一個時刻只能有一個擁有者。
全部權概念使Rust確保了對於任何給定的資源都正好（只）有一個綁定與之對應。
如同一個房子只能有一個主人，let的操做過程如同政府給這個主人頒發了房產證。

1. 全部權是變量綁定的一個屬性，發生來let的過程當中。

let v = vec![1, 2, 3]; 
let v2 = v;

第一行爲向量（vector）對象和它包含的數據分配了內存。向量對象儲存在棧上幷包含一個指向堆上  [1,2, 3] 內容的指針。
第二行當咱們從  v 移動到  v2 ，它爲  v2 建立了一個那個指針的拷貝。這意味着這將會有兩個 全部權指向向量內容的指針。這將會由於引入了一個數據競爭而違反Rust的安全保證。所以，Rust禁止咱們在移 動後使用  v 。
總結：了當全部權被轉移給另外一個綁定之後，你不能再使用原始綁定。

2.一些特殊狀況不會出現這種全部權限制：
狀況1：trait，它會實現copy。（trait相似接口定義的關鍵字，如java的interface）
狀況2：全部基本類型會自動實現copy。
let v = 1;
let v2 = v;
println!("v is: {}", v);

在這個狀況，  v 是一個  i32 ，它實現了  Copy 。這意味着，就像一個移動，當咱們把  v 賦值給  v2  ,產生了 一個數據的拷貝。不過，不像一個移動，咱們仍能夠在以後使用  v 。這是由於  i32 並無指向其它數據的 指針，對它的拷貝是一個完整的拷貝。

2、借用和引用（borowwing and Reference）

引用相似於C語言的指針，連符號都是同樣的：&, &point,&a
首先定義 let a = vec![1, 2, 3] 假設首先定義一座能夠住3我的的大房子，房主是a。
&a 意味着引用a的資源，就像出租屋管理中心登記了房子a的門牌號，之後找這座房子a就方便了
那麼let b = &a, 意味a將房子出租給b，a雖然還是房子的主人，可是因爲將房子出租給了b，在出租期間，房主人a是不能使用的。
正式的說法就是，b借用了a的資源，至於借出的期限是多少，這個涉及下個節的生命週期，在這個期限內，a不能使用，只有過了這個期限，才能夠從新使用。
若是是let b = &mut a, 這個是最大權限的借出了，借出期間，b能夠隨便修改房子裏的東西。

第一種類型的引用:&T，咱們稱  &T 類型爲一個」引用「，而與其擁有這個資源，它借用了全部權。一個借用變量的 綁定在它離開做用域時並不釋放資源。這意味着  foo() 調用以後，咱們能夠再次使用原始的綁定。
引用是不可變的，就像綁定同樣。這意味着在中，向量徹底不能被改變：
fn foo(v: &Vec<i32>) {
     v.push(5);
}
let v = vec![];
foo(&v);
上述代碼是會報錯的

第二種類型的引用：&mut T，稱爲「可變引用」，即容許你改變你借用的資源。
首先，被引用變量必須也是mut類型。
let mut x = 5;
let y = &mut x;  //x資源給y借用了
*y += 1;                                         
println!("{}", x);// 這裏嘗試借用x
                  // &mut x 的借用到這裏才結束
=============================以上錯誤，這些做用域衝突了：咱們不能在  y 在做用域中時生成一個  &x 。
let mut x = 5;
{
    let y = &mut x;
    *y += 1;
}
println!("{}", x);
=============================以上正確，用{}限定了範圍
這會打印  6 。咱們讓  y 是一個  x 的可變引用，接着把  y 指向的值加一。你會注意到  x 也必須被標記爲  mut ，若是它不是，咱們不能獲取一個不可變值的可變引用。
咱們的可變借用在咱們建立一個不可變引用以前離開了做用域。

借用（borowwing）有一些規則
第一，任何借用必須位於比擁有者更小的做用域。（真正主人的使用期限固然要大於借用者的使用期限）
第二，你能夠有一個或另外一個這兩種類型的借用，不過不能同時擁有它們。（東西不能同時借給不少人用，輪流用才行）
0個或N個資源的引用（&T）。
只有1個可變引用（(&mut T）。

經過引用，你能夠擁有你像擁有的任意多的引用，由於它們沒有一個在寫。若是你在寫，而且你須要2個或 更多相同內存的指針，則你只能一次擁有一個  &mut 。這就是Rust如何在編譯時避免數據競爭：咱們會獲得 錯誤，若是咱們打破規則的話。

3、生命週期（困難曲線陡升的東西）
1. http://www.rust.cc/t/rustde-lifetimede-zuo-yong/712/6
2. https://wiki.rust-china.org/Rust-Lifetime
3. http://stackoverflow.com/questions/17490716/lifetimes-in-rust
4. https://wiki.rust-china.org/Rust-Lifetime
5. 案例：https://github.com/hyperium/hyper/blob/master/src/server/request.rs

一、生命週期是什麼？
https://github.com/rustcc/RustPrimer/blob/master/13-ownership-system/13-03-lifetimes.md
理論上講，生命週期是一種構想，在這個構想裏面，編譯器將用於確保全部變量的借用是有效的。一個變量的生命週期開始於這個變量被創造的時候，結束於這個變量被摧毀的時候。另外，生命週期lifetime和scope常常給一塊兒說起，可是它們是不同的。通常來說，能夠經過Scope做用域來理解生命週期，「生命週期」在編譯階段就已經決定變量應該在何時銷燬內存該何時釋放，生命週期就是告訴編譯器，內存何時銷燬。

通俗的講，生命週期就是a借東西給b，借用期限就是這個生命週期了，每一個借用都必須有借用期，不能隨便借出不還了，想永久霸佔是不行滴，固然有時候在必定條件下，這東西若是借給你複製拷貝一下，也是能夠的。lifetime和scope能夠理解成使用期限和使用範圍。

總之，要理解生命週期，必須先要徹底理解上面的全部權，引用和借用的概念。

二、生命週期用什麼表達？
使用單引號加單個字母：'a

有一個生命週期：foo<'a> 表示foo有個生命週期'a
說明：使用生命週期，須要用到泛型<>，這種表達意味着foo的生命週期不可能超過它的泛型'a
類型的精確的註解還有 & 'a T 這種形式，
有多個生命週期：foo<'a, 'b>
說明：這種表達覺得foo的生命週期不可能超過它的泛型'a 或'b

三、什麼場合要用到生命週期
函數
- any reference must have an annotated lifetime.
- any reference being returned must have the same lifetime as an input or be static.
A.對函數來講，任何引用都必須有一個被註解的生命週期。
B.任何引用被函數返回時，都必須有一樣的生命週期被輸入或者是靜態的參數。
只有函數返回引用時，必須加lifetime，若是不加，編譯器不知道返回值的生存期。

實例1，fun1因只有一個入參，返回的lifetime默認跟入參一致，但fun2就必需要加lifetime了
fn main() {
   let mut i = 10;
   let k = fun1(&mut i);
   println!("{:?}", k);

   let mut x = 10;
   let mut y = 5;
   let z = fun2(&mut x, &y);
   println!("{:?}", z);
}

fn fun1(c: &mut i32) -> &i32 {
   *c = *c + 1; c
}

fn fun2<'a,'b>(c1: &'a mut i32, c2: &'b i32) -> &'a i32 {
   *c1 = *c1 + *c2;
   c1
}

每個借用都會有一個生存期。生存期用來表示借用的有效範圍。
Rust對於每個引用的生命週期都是嚴格控制的，在編譯期就保證了引用的陽壽不會長過它引用的對象，從而確保了「野指針」的 不可發生性 。

 

結構體
struct Foo<'a> {
    x: &'a i32,
}
fn main() {
    let y = &5; // this is the same as `let _y = 5; let y = &_y;`
    let f = Foo { x: y };
    println!("{}", f.x);
}
使用它，是由於咱們須要確保任何  Foo 的引用不能比它包含 的  i32 的引用活的更久。
在整個impl塊中：
struct Foo<'a> {
    x: &'a i32,
}
impl<'a> Foo<'a> {
    fn x(&self) -> &'a i32 { self.x }
}
fn main() {
    let y = &5; // this is the same as `let _y = 5; let y = &_y;`
    let f = Foo { x: y };
    println!("x is: {}", f.x());
}
如你所見，咱們須要在  impl 行爲  Foo 聲明一個生命週期。咱們重複了  'a 兩次，就像在函數 中：
impl<'a> 定義了一個生命週期  'a ，而  Foo<'a> 使用它。

四、Lifetime要解決什麼問題？

其中一個就是要解決懸垂指針「Dangling pointer」的問題，好比
fn dangling<'a>() -> &'a i32 {
    letlocal_var: i32 = 1;
    &local_var
}

五、關於Lifetime究竟是怎麼推導的?
生存期是用來作類型限定的，並非不少人口中說的用來作推斷的。

它就是類型系統的一部分，不是有什麼用，是必須用，不然就必須放棄今天的以item爲範圍進行推導而改爲在全局推導。

不妨看一下這段程序：
fn echo<'a>(a: &'a str) -> &'a str {
   a
}

如上這個函數echo，它接受一個參數a，而後直接把它返回回去，返回值的Lifetime與參數一致。
那麼若是有以下調用：
let ret = echo("hello world");
那麼咱們就開始推導，首先"hello world"的類型是&'static str，代入到echo中，'a = 'static，所以返回值ret的類型就是&'static str。驗證結論的方法是
let ret: &'static str = echo("hello world");
並不會報錯。

那麼若是咱們傳別的呢？

fn outer() {
    // ... 其它代碼
    let string: String = "hello world".to_owned();
    let ret = echo(&string[..]);
    // ... 其它代碼
}

在這種狀況下'a應該是什麼呢？答案就是string的做用域（Scope），即outer函數體。