? ? 所有權(quán)轉(zhuǎn)移，Rust中沒(méi)有垃圾收集器，使用所有權(quán)規(guī)則確保內(nèi)存安全，所有權(quán)規(guī)則如下：

? ? 1、每個(gè)值在Rust中都有一個(gè)被稱(chēng)為其所有者（owner）的變量，值在任何時(shí)候只能有一個(gè)所有者。

? ? 2、當(dāng)所有者離開(kāi)作用域，這個(gè)值將被丟棄。

? ? 3、所有權(quán)的轉(zhuǎn)移時(shí)零成本的，這里不需要對(duì)新的變量開(kāi)辟一塊內(nèi)存用于存儲(chǔ)數(shù)據(jù)。新變量只是重新分配了資源的所有權(quán)。

? ? 例子1：所有權(quán)傳遞（變量）

    fn main(){let x="hello".to_string();//"hello"的所有者為xlet y=x;//"hello"的所有者變?yōu)閥，這個(gè)時(shí)候原來(lái)的所有者x已失效println!("{}",x);//}

例子2：所有權(quán)傳遞（函數(shù)）

    fn create_string() ->String {// 創(chuàng)建并返回一個(gè)新的StringString::from("Hell,ownership!")}fn transfer_ownership(s:String) -> String {//返回輸入的String,轉(zhuǎn)移所有權(quán)s}fn main() {//create_string函數(shù)創(chuàng)建了一個(gè)值"Hell,ownership!"，并將所有權(quán)傳遞給了my_string。let my_string=create_string(); //my_string將值"Hell,ownership!"的所有權(quán)傳遞給了函數(shù)transfer_ownership，函數(shù)又將所有權(quán)傳遞給了transferred_stringlet transferred_string=transfer_ownership(my_string);//此時(shí)my_string已不再對(duì)值"Hell,ownership!"擁有所有權(quán)。println!("my_string string: {}", my_string); // 此時(shí)transferred_string對(duì)值"Hell,ownership!"擁有所有權(quán)。println!("Transferred string: {}", transferred_string); }

? ? 克隆：

? ? 1、當(dāng)克隆一個(gè)變量時(shí)，相當(dāng)于創(chuàng)建了數(shù)據(jù)的一個(gè)完整副本。

? ? 2、與所有權(quán)轉(zhuǎn)移相比，克隆的成本較大，因?yàn)樯婕暗搅艘獌?nèi)存的使用和數(shù)據(jù)的復(fù)制。

? ? 3、所有權(quán)轉(zhuǎn)移后原始變量失效，克隆之后原始變量仍然有效，并且原始變量保留了數(shù)據(jù)的所有權(quán)。這里需要注意，克隆后，兩個(gè)變量是完全獨(dú)立的數(shù)據(jù)實(shí)例。

? ? 例子3：

    fn main(){let x="Hello".to_string();//x獲取了"Hello"的所有權(quán)l(xiāng)et y=x.clone();//傳遞x的副本給yclone_ownership(y);//傳遞x的副本y給函數(shù)clone_ownership//x依然對(duì)"Hello"擁有所有權(quán)println!("x String:{}",x);//y對(duì)"Hello"還擁有所有權(quán)嗎？不再擁有所有權(quán)了，因?yàn)橐呀?jīng)將所有權(quán)傳遞給了函數(shù)clone_ownership// println!("y String:{}",y);}fn clone_ownership(s:String){println!("{}",s);}

? ? 引用：

? ? 1、引用有可變引用(&mut T)和不可變引用(&T)。

? ? 2、可變引用允許修改引用所指向的值，而不可變引用不允許修改引用所指向的值。

? ? 3、為了防止數(shù)據(jù)競(jìng)爭(zhēng)，Rust中在任何時(shí)間，只能擁有一個(gè)可變引用到特定的數(shù)據(jù)。

? ? 4、由于不可變引用不會(huì)改變數(shù)據(jù)，Rust中可以擁有任意數(shù)量的不可變引用。

? ? ?例子4：

// 定義一個(gè)函數(shù)，它接受一個(gè)整數(shù)的不可變引用
fn print_int(value:&i32)
{// 打印出傳入整數(shù)的值println!("The value is: {}",value);
}fn  main()
{let _int=11;// 調(diào)用函數(shù)，傳入整數(shù)的不可變引用print_int(&_int); 
}

? ? 例子5：

// 定義一個(gè)函數(shù)，它接受一個(gè)整數(shù)的可變引用
fn print_int(value:&mut i32)
{// 將整數(shù)的值加倍*value *=10; 
}fn  main()
{let mut _int=10;// 調(diào)用函數(shù)，傳入整數(shù)的可變引用print_int(&mut _int);// 打印加倍后的整數(shù)值println!("The value is :{}",_int);   
}

5、生命周期參數(shù)，它可以告訴編輯器，參數(shù)的引用和返回值的引用都具有相同的生命周期。例子6中的'a就是生命周期參數(shù)

?

    例子6fn return_reference<'a>(data:&'a String)->&'a String{data //返回的引用與輸入的引用具有相同的生命周期}fn main(){let external_string=String::from("Hello world");let string_ref=return_reference(&external_string);println!("{}",string_ref);// 這是安全的，因?yàn)閑xternal_string的生命周期貫穿了整個(gè)main函數(shù)}

    例子7//定義一個(gè)包含引用的結(jié)構(gòu)體，需要生命周期注解struct  Item<'a>{//'a表示引用的生命周期name:&'a str,}// 實(shí)現(xiàn)結(jié)構(gòu)體，戰(zhàn)術(shù)如何使用生命周期impl<'a> Item<'a>{// 創(chuàng)建一個(gè)新的Item實(shí)例，返回一個(gè)帶有生命周期的實(shí)例fn new(name:&'a str)->Self{Item {name}}}fn main(){let name =String::from("Rust Programming");// 創(chuàng)建一個(gè)String類(lèi)型的變量let item= Item::new(&name);//借用name的引用來(lái)創(chuàng)建Item實(shí)例println!("Item name:{}",item.name);//打印Item中的name字段}//name的生命周期結(jié)束，item.name的引用也不再有效

    例子8fn print_shorter(r:&str){println!("The string is:{}",r);}fn main(){let long_lived_string=String::from("This is a long-lived string.");{let short_lived_str:&str=&long_lived_string;//創(chuàng)建一個(gè)常生命周期的引用// 下面的函數(shù)調(diào)用中，short_lived_str的生命周期會(huì)被強(qiáng)制縮短以匹配print_shorterprint_shorter(short_lived_str);}//short_lived_str的生命周期結(jié)束//這里long_lived_string仍然有效，因此上面的強(qiáng)制轉(zhuǎn)換是安全的println!("{}",long_lived_string);}

    例子9fn main(){let mut data=vec![1,2,3,4,5];//創(chuàng)建一個(gè)不可變引用let data_ref=&data;//打印使用不可變引用的數(shù)據(jù)println!("Values via immutable reference:{:?}",data_ref);// 下面嘗試創(chuàng)建一個(gè)可變引用將會(huì)失敗，因?yàn)?#96;data`已經(jīng)被不可變引用借用let data_mut_ref = &mut data; println!("{}", data_mut_ref);// 這行會(huì)導(dǎo)致編譯錯(cuò)誤，編譯錯(cuò)誤如下圖//下面嘗試創(chuàng)建一個(gè)可變引用將不會(huì)失敗// let data_mut_ref=&mut data;// println!("{:?}",data_mut_ref);//只有當(dāng)不可變引用不再使用后，才能創(chuàng)建可變引用//這里不再使用不可變引用data_ref，因此可以創(chuàng)建可變引用// let data_mut_ref=&mut data;// data_mut_ref.push(6);// println!("Values after mutation:{:?}",data_mut_ref);}

從錯(cuò)誤截圖上看，只有使用{:?}編譯器錯(cuò)誤就不存在了。

    例子10:如果有一個(gè)或多個(gè)不可變引用&T，那么在同一作用域內(nèi)不能有可變引用&mut T。
如果有一個(gè)可變引用&mut T,那么在同一作用域內(nèi)不能有其他的可變引用或不可變引用&T。
編譯器報(bào)錯(cuò)提示如下struct MyStruct{value:i32,}//這個(gè)函數(shù)嘗試同時(shí)接受一個(gè)對(duì)象的可變和不可變引用fn example_fn(mutable_ref:&mut MyStruct,immutable_ref:&MyStruct){println!("Mutable reference value:{}",mutable_ref.value);println!("Immutable reference value:{}",immutable_ref);}fn  main() {let mut my_object=MyStruct{value:10};//嘗試同時(shí)借用可變引用和不可變引用example_fn(&mut my_object, &my_object);}

?

?

    例子11：fn main(){let x=10;//定義一個(gè)整數(shù)變量xlet y=&x;//創(chuàng)建一個(gè)指向x的引用yprintln!("The value of x is:{}",x);//直接打印變量x的值。println!("The address of x is:{:p}",y);//打印引用y的地址，使用{:p}格式化指針地址println!("The value of y is:{}",y);//打印應(yīng)用y的值，這里會(huì)打印出地址  注意這里打印出來(lái)的是10而不是地址，不確定是不是Rust版本的問(wèn)題。println!("The value pointed to by is :{}",*y);//使用解引用操作符來(lái)打印y指向的值}

    例子12// 定義一個(gè)包含字符串引用的結(jié)構(gòu)體Bookstruct Book<'a>{//'a是一個(gè)生命周期注解，表示title的生命周期title:&'a str,}fn main(){let title=String::from("The Rust Programming Language");let book=Book{//title 是一個(gè)字符串切片，他引用了title變量的數(shù)據(jù)title:&title,};println!("Book title:{}",book.title);}

    例子13// longset 函數(shù)定義了一個(gè)生命周期參數(shù)'a，這個(gè)生命周期參數(shù)制定了輸入?yún)?shù)和返回值的生命周期必須相同。fn longset<'a>(x:&'a str,y:&'a str)->&'a str{if x.len()>y.len(){x// 如果x的長(zhǎng)度大于y，返回x}else {y //否則，返回y}}fn main(){let string1=String::from("Rust");let string2=String::from("C++");let result=longset(string1.as_str(), string2.as_str());//longset函數(shù)比較兩個(gè)字符串切片的長(zhǎng)度println!("The longeset string is {}",result);//注意 result 的生命周期與string1和string2的生命周期相關(guān)，因此它們必須在result被使用之前保持有效}

    例子14// 定義一個(gè)結(jié)構(gòu)體ImportantExcerpt，它包含一個(gè)字符串切片字段partstruct  ImportantExcerpt<'a>{part:&'a str,}fn main(){let novel=String::from("Call me ishmael. Some years ago ...");let first_sentence=novel.split('.').next().expect("Could not find a '.'");let excerpt=ImportantExcerpt{part:first_sentence,};//打印出結(jié)構(gòu)體中的字符串切片println!("Important excerpt:{}",excerpt.part);}

    例子15// 定義一個(gè)結(jié)構(gòu)體ImportantExcerpt，它包含一個(gè)字符串切片字段partstruct  ImportantExcerpt<'a>    {part:&'a str,}//為ImportantExcept結(jié)構(gòu)體實(shí)現(xiàn)方法impl <'a> ImportantExcerpt<'a> {fn announce_and_return_part(&self,announcement:&str)->&str{println!("Attention please:{}",announcement);self.part}}fn main(){let novel=String::from("Call me ishmael. Some years ago ...");let first_sentence=novel.split('.').next().expect("Could not find a '.'");let excerpt=ImportantExcerpt{part:first_sentence,};let announcement="I'm going to tell you something important!";let part=excerpt.announce_and_return_part(announcement);//打印出結(jié)構(gòu)體中的字符串切片println!("Important excerpt:{}",part);  }

    例子16//定義一個(gè)擁有靜態(tài)生命周期的字符串常量static MESSAGE:&'static str="Hello,this is a static lifetime example";fn main(){//打印這個(gè)靜態(tài)生命周期的字符串println!("{}",MESSAGE);}

    例子17//定義一個(gè)函數(shù)，該函數(shù)接收兩個(gè)引用參數(shù)：一個(gè)是不帶生命周期的引用，另一個(gè)是帶生命周期的'a的引用fn select<'a>(first:&i32,second:&'a i32)->&'a i32{//這里我們簡(jiǎn)單地返回第二個(gè)參數(shù)，它帶有生命周期'asecond}fn main(){let num1=10;let num2=20;//創(chuàng)建一個(gè)生命周期較長(zhǎng)的引用let result;{let num3=num2;//調(diào)用函數(shù)，num1的引用不帶生命周期，num3的引用帶有生命周期result=select(&num1, &num3);}//num3的生命周期結(jié)束//打印結(jié)果，result引用的是num2，因?yàn)樗cnum3共享相同的數(shù)據(jù)println!("The selected number is {}",result);}

    例子18//定義一個(gè)結(jié)構(gòu)體Book，包含一個(gè)字符串切片引用，代碼書(shū)名struct Book<'a>{name:&'a str,}//實(shí)現(xiàn)Book結(jié)構(gòu)體的一個(gè)方法get_name，返回書(shū)名的引用//這里沒(méi)有顯示標(biāo)注生命周期，因?yàn)榫幾g器會(huì)自動(dòng)應(yīng)用生命周期省略規(guī)則impl<'a> Book<'a>{//根據(jù)省略規(guī)則，這里的返回值生命周期被自動(dòng)推導(dǎo)問(wèn)為與&self相同fn get_name(&self)->&str{self.name}    }fn main(){let book=Book{name:"The Rust Programming Language"};//調(diào)用get_name方法，打印返回的書(shū)名引用println!("Book name:{}",book.get_name());}

例子19
// 定義一個(gè)泛型函數(shù)`slice_first`，它有一個(gè)泛型類(lèi)型`T`和生命周期`'a`
fn slice_first<'a, T>(data: &'a [T]) -> Option<&'a T> {// 使用`.get()`方法來(lái)嘗試獲取slice的第一個(gè)元素的引用// 如果存在，則返回Some(&T)，否則返回Nonedata.get(0)
}fn main() {// 創(chuàng)建一個(gè)整數(shù)類(lèi)型的slicelet numbers = vec![1, 2, 3, 4, 5];// 調(diào)用`slice_first`函數(shù)，并打印返回的結(jié)果if let Some(first) = slice_first(&numbers) {println!("The first number is {}", first);} else {println!("The slice is empty.");}// 創(chuàng)建一個(gè)字符類(lèi)型的slicelet letters = vec!['a', 'b', 'c', 'd', 'e'];// 同樣調(diào)用`slice_first`函數(shù)，并打印返回的結(jié)果if let Some(first) = slice_first(&letters) {println!("The first letter is {}", first);} else {println!("The slice is empty.");}
}