張大胖被別人安利了一個新的語言：Rust，作為編程語言的狂熱愛好者，他自然要嘗試一番。

[[275114]]

第一個程序自然是hello world，太簡單了，都懶得去寫，看看就行了：

fn main() { 
   println!("hello world"); 
} 

張大胖原來用過C語言， 當時覺得非常不爽的是它本身沒有內置常用的數據結構，比如一個可以動態增長的數組，這Rust怎么樣呢?

fn main() { 
    let v = Vec::new(); //創建了一個數組 
    v.push(4);  // 向數組添加一個元素 
} 

張大胖寫下let就意識到，這里是將值(數組)綁定到變量v ， 應該是借鑒了Lisp的模式匹配，可以預見將來會遇到這樣的代碼：

let (name,age) = ("Andy", 30); 

還有就是這Rust具備自動類型推斷能力，這點挺不錯的。

編譯吧!咦，居然失敗了，錯誤信息是：cannot borrow `v` as mutable, as it is not declared as mutable

Rust編譯器：我們把對象分為可變的和不可變的，對于不可變的，一旦創建以后，就不能再改了。那就加個關鍵字mut，讓它變成可變的就可以了：let mut v = Vec::new()

張大胖想起了《effective java》中的一條實踐：把可變性限制到最小。他嘴里咕噥著：“嗯，Rust默認是不可變，這個思路也許是對的。”

所有權

他又探索著寫下一些代碼：

fn main() { 
    //用另外一種方式創建了一個可變Vector  
    let mut v = vec![1,2];    
    let v1 = v; 
    println!(" the 1st element is {}",v[0]);     
} 

編譯，又失敗了，WTF!到底是怎么回事?這么簡單的程序也會出錯?!

Rust編譯器：誰讓你手賤!加了一行代碼：let v1 = v

張大胖：這有什么關系?在Java中，這就相當于對同一個對象，又添加了一個引用而已!

Rust編譯器：那是Java，在我Rust這里，你一定要放下Java的執念!要理解一下所有權的問題。

張大胖：什么所有權?

Rust編譯器：對于任何給定的對象都只有一個綁定與之對應。你用let mut v = Vec::new()就意味著 v 和這個Vector對象綁定了!現在v擁有這個對象的所有權。這一行代碼 let v1 = v ，讓所有權發生轉移了， 現在v1是新主人了。v就不能再訪問這個Vector， 我把這種情況叫做“轉移語義”。

 

碼農翻身注：實際上， Rust也支持Copy語義，這里不在詳述。

張大胖不滿地說：這不是徒增煩惱嗎?那我要是把v傳遞給另外一個函數呢?

fn main() { 
    let mut v = vec![1,2,3,4]; //創建了一個可變Vector 
    print_vector(v); 
    println!(" the 1st element is {}",v[0]); 
 
} 
fn print_vector(v: Vec<i32>){ 
    for i in v { 
        println!("{}", i); 
    } 
} 

編譯還是出錯!

Rust編譯器：這和剛才是一個道理，v的所有權在傳遞給函數時，被拿走了，所以在main中不能再訪問v了 !

借用

張大胖：太變態了，我就是想在調用print_vector以后想訪問再訪問變量v，該怎么辦?

Rust編譯器: 你可以把所有權暫時借用(&v)給print_vector，等函數返回就可以接著使用了。

fn main() { 
    let mut v = vec![1,2,3,4]; //創建一個可變Vector 
    print_vector(&v); 
    println!(" the 1st element is {}",v[0]);     
} 
fn print_vector(v: &Vec<i32>){ 
  ...... 
} 

這個借用就相當于Java語言的引用了，張大胖想，print_vector函數已經“借到”所有權，應該可以為所欲為了吧，于是在函數內做了修改：

fn print_vector(v: &Vec<i32>) { 
    v.push(3); 
    ..... 
} 

再次編譯，再次失敗!張大胖感覺到要吐血了，這Rust實在太不講道理了。

Rust編譯器：“你這個借用想要改變原來的對象，也得加上 &mut才行!”

fn main() { 
    let mut v = vec![1,2,3,4]; //創建了一個Vector 
    print_vector(&mut v); 
    println!(" the 1st element is {}",v[0]);     
} 
 
fn print_vector(v: &mut Vec<i32>) { 
    v.push(3); 
    ...... 
} 

總結一下：

 

張大胖繼續寫代碼，想繼續測試這個所謂“借用”：

fn main() { 
    let mut x = String::from("hello"); 
    let x1 = &x; 
    let x2 = &mut x;     
    println!("{}", x1);     
} 

編譯還是出錯：‘x’已經有一個不可變借用了，不能再以可變的方式來借用!

張大胖徹底懵逼了!想我叱咤編程界多年，先后學會了C,C++, Java, Ruby ,Python， 從來就沒見過這么復雜的語言，這么簡單的程序，編譯都通不過。

Rust編譯器：道理很簡單，x1是不可變引用，x2是可變引用，使用x1的"用戶"可不希望訪問x1時，數據已經改變了。我告訴你一個簡單的口訣，以后再遇到問題就迎刃而解了：共享不可變， 可變不共享。

(用嚴格的描述來說是這樣： 同一時刻，要么只有一個可變(&mut)借用，要么有多個不可變(&) 借用，不能同時存在可變和不可變借用。

 

(都對一個對象做讀操作，安全!)

 

(只有小張可以寫，因為他是可變的借用)

張大胖琢磨了一下，這口訣用人話來說是這樣的： 當大家都在讀一個東西的時候，是不能寫的。當一個人在寫的時候，別人是不能讀的， 這不就是經典的讀寫鎖問題嗎?這Rust居然在編譯器級別做了這種限制 !

Rust編譯器：我之所以由這么嚴格的限制，就是為了內存安全，我的這套體系是不需要GC的，只要你能按照我的規矩來，內存安全就能保證。

張大胖：你啊，是為了懶省事，把本來可以讓虛擬機干自動做的事情，都交給程序員來做了，這是要把我們累死啊!

Rust編譯器：你到底做過系統級編程沒有?系統級編程要求：

1. 非常快

2. runtime 很小(虛擬機就是一個巨大無比的Runtime)

3. 能直接訪問內存，并且內存安全。

C和C++基本滿足，但是內存不安全， 像Java, Python,Ruby 除了內存安全之外，別的都不滿足，只適合應用層編程。

張大胖無語了，這家伙的目標是要替換C/C++，自己也寫過不少C代碼，由于內存問題，不知道搞垮過多少個程序，懸空的指針就像幽靈一樣到處飄蕩，無蹤可循，然后在一個未知的地點，未知的時刻突然爆裂。

這個Rust，每個對象都有唯一的“主人”，然后有對讀寫施加了這么嚴格的限制，如果程序員掌握了，確實比C語言安全， 我還是接著學吧!

【本文為51CTO專欄作者“劉欣”的原創稿件，轉載請通過作者微信公眾號coderising獲取授權】 

戳這里，看該作者更多好文