1. References
Ownership 中的最后一個(gè)例子，我們?nèi)绻胍俅文没貍魅氲膶?duì)象的話意鲸，就得返回出來(lái)，這種做法有點(diǎn)繁瑣做粤，為此Rust提供了一個(gè)references類(lèi)型
有點(diǎn)像指針，但是一定可以保證其對(duì)應(yīng)的值是一個(gè)valid的
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()
}
參數(shù)內(nèi)容如下圖所示：
圖片.png
用ownership來(lái)解釋如下：
&s1創(chuàng)建了一個(gè)reference來(lái)引用s1捉撮，但是這個(gè)reference并不擁有它,則reference指向的值在該reference離開(kāi)作用域的時(shí)候怕品，并不會(huì)drop掉
fn calculate_length(s: &String) -> usize { // s is a reference to a String
s.len()
} // Here, s goes out of scope. But because it does not have ownership of what
// it refers to, it is not dropped.
1.1 Borrowing
We call the action of creating a reference borrowing
As in real life, if a person owns something, you can borrow it from them. When you’re done, you have to give it back. You don’t own it
1.2 Borrowing戒律
Borrowing得到的引用默認(rèn)是不可變的
fn main() {
let s = String::from("hello");
change(&s);
}
fn change(some_string: &String) {
some_string.push_str(", world");
}
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
--> src/main.rs:8:5
|
7 | fn change(some_string: &String) {
| ------- help: consider changing this to be a mutable reference: `&mut String`
8 | some_string.push_str(", world");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable
For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` due to previous error
1.3 Mutable References
上述代碼，可以采用Mutable References來(lái)解決
fn main() {
let mut s = String::from("hello");
change(&mut s);
}
fn change(some_string: &mut String) {
some_string.push_str(", world");
}
1.3.1 Mutable References具有唯一性巾遭，避免多個(gè)寫(xiě)操作
fn main() {
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{}, {}", r1, r2);
}
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
--> src/main.rs:5:14
|
4 | let r1 = &mut s;
| ------ first mutable borrow occurs here
5 | let r2 = &mut s;
| ^^^^^^ second mutable borrow occurs here
6 |
7 | println!("{}, {}", r1, r2);
| -- first borrow later used here
For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` due to previous error
1.3.2 多個(gè)Mutable References采用不同作用域
fn main() {
let mut s = String::from("hello");
{
let r1 = &mut s;
} // r1 goes out of scope here, so we can make a new reference with no problems.
let r2 = &mut s;
}
1.3.3 Mutable References和Immutable References混用
fn main() {
let mut s = String::from("hello");
let r1 = &s; // no problem
let r2 = &s; // no problem
let r3 = &mut s; // BIG PROBLEM
println!("{}, {}, and {}", r1, r2, r3);
}
可以采用作用域的方式繞過(guò)去
fn main() {
let mut s = String::from("hello");
let r1 = &s; // no problem
let r2 = &s; // no problem
println!("{} and {}", r1, r2);
// variables r1 and r2 will not be used after this point
let r3 = &mut s; // no problem
println!("{}", r3);
}
1.4 Dangling References
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String {
let s = String::from("hello");
&s
}
上述代碼報(bào)錯(cuò)如下：
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
--> src/main.rs:5:16
|
5 | fn dangle() -> &String {
| ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime
|
5 | fn dangle() -> &'static String {
| ~~~~~~~~
For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` due to previous error
可以看到：
this function's return type contains a borrowed value, but there is no value for it to be borrowed from
上述代碼詳細(xì)注釋如下：
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String { // dangle returns a reference to a String
let s = String::from("hello"); // s is a new String
&s // we return a reference to the String, s
} // Here, s goes out of scope, and is dropped. Its memory goes away.
// Danger!
s對(duì)象離開(kāi)了作用域之后會(huì)被drop掉肉康，而引用也自然就沒(méi)用了
一種簡(jiǎn)單的解決方法是直接返回對(duì)象：
fn main() {
let string = no_dangle();
}
fn no_dangle() -> String {
let s = String::from("hello");
s
}
Ref:
