Rust中的智慧指標是什麼
智慧指標(smart pointers)是一類資料結構,是擁有資料所有權和額外功能的指標。是指標的進一步發展
指標(pointer)是一個包含記憶體地址的變數的通用概念。這個地址引用,或 ” 指向”(points at)一些其 他資料 。引用以 & 符號為標誌並借用了他們所 指向的值。除了引用資料沒有任何其他特殊功能。它們也沒有任何額外開銷,所以在Rust中應用得最多。
智慧指標是Rust中一種特殊的資料結構。它與普通指標的本質區別在於普通指標是對值的借用,而智慧指標通常擁有對資料的所有權。並且可以實現很多額外的功能。
Rust智慧指標有什麼用,解決了什麼問題
它提供了許多強大的抽象來幫助程式設計師管理記憶體和併發。其中一些抽象包括智慧指標和內部可變性型別,它們可以幫助你更安全、更高效地管理記憶體,例如Box<T>
用於在堆上分配值。Rc<T>
是一種引用計數型別,可以實現資料的多重所有權。RefCell<T>
提供內部可變性,可用於實現對同一資料的多個可變引用
它們在標準庫中定義,可以用來更靈活地管理記憶體,智慧指標的一個特點就是實現了Drop和Deref這兩個trait。其中Drop trait中提供了drop方法,在析構時會去呼叫。Deref trait提供了自動解引用的能力,讓我們在使用智慧指標的時候不需要再手動解引用了
Rust有哪些常用智慧指標
Box<T>
是最簡單的智慧指標,它允許你在堆上分配值並在離開作用域時自動釋放記憶體。Rc<T>
和Arc<T>
是引用計數型別,它們允許多個指標指向同一個值。當最後一個指標離開作用域時,值將被釋放。Rc<T>
不是執行緒安全的,而Arc<T>
是執行緒安全的。
內部可變性型別允許你在不可變引用的情況下修改內部值。Rust中有幾種內部可變性型別,包括Cell<T>
,RefCell<T>
和UnsafeCell<T>
。
Cell<T>
是一個內部可變性型別,它允許你在不可變引用的情況下修改內部值。Cell<T>
只能用於Copy
型別,因為它透過複製值來實現內部可變性。RefCell<T>
也是一個內部可變性型別,它允許你在不可變引用的情況下修改內部值。與Cell<T>
不同,RefCell<T>
可以用於非Copy
型別。它透過借用檢查來確保執行時的安全性。UnsafeCell<T>
是一個底層的內部可變性型別,它允許你在不可變引用的情況下修改內部值。與Cell<T>
和RefCell<T>
不同,UnsafeCell<T>
不提供任何執行時檢查來確保安全性。因此,使用UnsafeCell<T>
可能會導致未定義行為。
此外,Rust還提供了一種弱引用型別Weak<T>
,它可以與Rc<T>
或Arc<T>
一起使用來建立迴圈引用。Weak<T>
不會增加引用計數,因此它不會阻止值被釋放。
Box<T>
Box<T>
是最簡單的智慧指標,它允許你在堆上分配值並在離開作用域時自動釋放記憶體。
Box<T>
通常用於以下情況:
- 當你有一個型別,但不確定它的大小時,可以使用
Box<T>
來在堆上分配記憶體。例如,遞迴型別通常需要使用Box<T>
來分配記憶體。 - 當你有一個大型資料結構並希望在棧上分配記憶體時,可以使用
Box<T>
來在堆上分配記憶體。這樣可以避免棧溢位的問題。 - 當你希望擁有一個值並只關心它的型別而不是所佔用的記憶體時,可以使用
Box<T>
。例如,當你需要將一個閉包傳遞給函式時,可以使用Box<T>
來儲存閉包。
總之,當你需要在堆上分配記憶體並管理其生命週期時,可以考慮使用Box<T>
。
下面是一個簡單的例子:
fn main() {
let b = Box::new(5);
println!("b = {}", b);
}
複製程式碼
這裡定義了變數 b,其值是一個指向被分配在堆上的值 5 的 Box。這個程式會列印出 b = 5;在這個例子 中,我們可以像資料是儲存在棧上的那樣訪問 box 中的資料。正如任何擁有資料所有權的值那樣,當像 b 這樣的 box 在 main 的末尾離開作用域時,它將被釋放。這個釋放過程作用於 box 本身(位於棧上) 和它所指向的資料(位於堆上)。
但是Box<T>
無法同時在多個地方對同一個值進行引用
enum List {
Cons(i32, Box),
Nil,
}
use crate::List::{Cons, Nil};
fn main() {
let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
let b = Cons(3, Box::new(a));
let c = Cons(4, Box::new(a));
}
複製程式碼
編譯會得出如下錯誤: error[E0382]: use of moved value: a
,因為b和c無法同時擁有a的所有權,這個時候我們要用Rc<T>
Rc<T>
Reference Counted 引用計數
Rc<T>
是一個引用計數型別,它允許多個指標指向同一個值。當最後一個指標離開作用域時,值將被釋放。Rc<T>
不是執行緒安全的,因此不能在多執行緒環境中使用。
Rc<T>
通常用於以下情況:
- 當你希望在多個地方共享資料時,可以使用
Rc<T>
。解決了使用Box<T>
共享資料時出現編譯錯誤 - 當你希望建立一個迴圈引用時,可以使用
Rc<T>
和Weak<T>
來實現。
下面是一個簡單的例子,演示如何使用Rc<T>
來共享資料:
use std::rc::Rc;
fn main() {
let data = Rc::new(vec![1, 2, 3]);
let data1 = data.clone();
let data2 = data.clone();
println!("data: {:?}", data);
println!("data1: {:?}", data1);
println!("data2: {:?}", data2);
}
複製程式碼
這個例子中,我們使用Rc::new
來建立一個新的Rc<T>
例項。然後,我們使用clone
方法來建立兩個新的指標,它們都指向同一個值。由於Rc<T>
實現了引用計數,所以當最後一個指標離開作用域時,值將被釋放。
但是Rc<T>
在多執行緒中容易引發執行緒安全問題,為了解決這個問題,又有了Arc<T>
Arc<T>
Atomically Reference Counted 原子引用計數
Arc<T>
是一個執行緒安全的引用計數型別,它允許多個指標在多個執行緒之間共享同一個值。當最後一個指標離開作用域時,值將被釋放。
Arc<T>
通常用於以下情況:
- 當你希望在多個執行緒之間共享資料時,可以使用
Arc<T>
,是Rc<T>
的多執行緒版本。 - 當你希望線上程之間傳遞資料時,可以使用
Arc<T>
來實現。
下面是一個簡單的例子,演示如何使用Arc<T>
來線上程之間共享資料:
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![1, 2, 3]);
let data1 = data.clone();
let data2 = data.clone();
let handle1 = thread::spawn(move || {
println!("data1: {:?}", data1);
});
let handle2 = thread::spawn(move || {
println!("data2: {:?}", data2);
});
handle1.join().unwrap();
handle2.join().unwrap();
}
複製程式碼
這個例子中,我們使用Arc::new
來建立一個新的Arc<T>
例項。然後,我們使用clone
方法來建立兩個新的指標,它們都指向同一個值。接著,我們線上程中使用這些指標來訪問共享資料。由於Arc<T>
實現了執行緒安全的引用計數,所以當最後一個指標離開作用域時,值將被釋放。
Weak<T>
弱引用型別
Weak<T>
是一個弱引用型別,它可以與Rc<T>
或Arc<T>
一起使用來建立迴圈引用。Weak<T>
不會增加引用計數,因此它不會阻止值被釋放。
當你希望建立一個迴圈引用時,可以使用Rc<T>
或Arc<T>
和Weak<T>
來實現。
Weak<T>
通常用於以下情況:
-
當你希望觀察一個值而不擁有它時,可以使用
Weak<T>
來實現。由於Weak<T>
不會增加引用計數,所以它不會影響值的生命週期。
下面是一個簡單的例子,演示如何使用Rc<T>
和Weak<T>
來建立一個迴圈引用:
use std::rc::{Rc, Weak};
struct Node {
value: i32,
next: Option<Rc<Node>>,
prev: Option<Weak<Node>>,
}
fn main() {
let first = Rc::new(Node { value: 1, next: None, prev: None });
let second = Rc::new(Node { value: 2, next: None, prev: Some(Rc::downgrade(&first)) });
first.next = Some(second.clone());
}
複製程式碼
這個例子中,我們定義了一個Node
結構體,它包含一個值、一個指向下一個節點的指標和一個指向前一個節點的弱引用。然後,我們建立了兩個節點first
和second
,並使用Rc::downgrade
方法來建立一個弱引用。最後,我們將兩個節點連線起來,形成一個迴圈引用。
需要注意的是,由於Weak<T>
不會增加引用計數,所以它不會阻止值被釋放。當你需要訪問弱引用指向的值時,可以使用upgrade
方法來獲取一個臨時的強引用。如果值已經被釋放,則upgrade
方法會返回None
。
UnsafeCell<T>
UnsafeCell<T>
是一個底層的內部可變性型別,它允許你在不可變引用的情況下修改內部值。與Cell<T>
和RefCell<T>
不同,UnsafeCell<T>
不提供任何執行時檢查來確保安全性。因此,使用UnsafeCell<T>
可能會導致未定義行為。
由於UnsafeCell<T>
是一個底層型別,它通常不直接用於應用程式程式碼。相反,它被用作其他內部可變性型別(如Cell<T>
和RefCell<T>
)的基礎。
下面是一個簡單的例子,演示如何使用UnsafeCell<T>
來修改內部值:
use std::cell::UnsafeCell;
fn main() {
let x = UnsafeCell::new(1);
let y = &x;
let z = &x;
unsafe {
*x.get() = 2;
*y.get() = 3;
*z.get() = 4;
}
println!("x: {}", unsafe { *x.get() });
}
複製程式碼
這個例子中,我們使用UnsafeCell::new
來建立一個新的UnsafeCell<T>
例項。然後,我們建立了兩個不可變引用y
和z
,它們都指向同一個值。接著,在一個unsafe
塊中,我們使用get
方法來獲取一個裸指標,並使用它來修改內部值。由於UnsafeCell<T>
實現了內部可變性,所以我們可以在不可變引用的情況下修改內部值。
需要注意的是,由於UnsafeCell<T>
不提供任何執行時檢查來確保安全性,所以使用它可能會導致未定義行為。因此,在大多數情況下,你應該使用其他內部可變性型別(如Cell<T>
和RefCell<T>
),而不是直接使用UnsafeCell<T>
。
Cell<T>
Cell<T>
是一個內部可變性型別,它允許你在不可變引用的情況下修改內部值。Cell<T>
只能用於Copy
型別,因為它透過複製值來實現內部可變性。
Cell<T>
通常用於以下情況:
- 當你需要在不可變引用的情況下修改內部值時,可以使用
Cell<T>
來實現內部可變性。 - 當你需要在結構體中包含一個可變欄位時,可以使用
Cell<T>
來實現。 下面是一個簡單的例子,演示如何使用Cell<T>
來修改內部值:
use std::cell::Cell;
fn main() {
let x = Cell::new(1);
let y = &x;
let z = &x;
x.set(2);
y.set(3);
z.set(4);
println!("x: {}", x.get());
}
複製程式碼
這個例子中,我們使用Cell::new
來建立一個新的Cell<T>
例項。然後,我們建立了兩個不可變引用y
和z
,它們都指向同一個值。接著,我們使用set
方法來修改內部值。由於Cell<T>
實現了內部可變性,所以我們可以在不可變引用的情況下修改內部值。
需要注意的是,由於Cell<T>
透過複製值來實現內部可變性,所以它只能用於Copy
型別。如果你需要在不可變引用的情況下修改非Copy
型別的值,可以考慮使用RefCell<T>
。
RefCell<T>
RefCell<T>
是一個內部可變性型別,它允許你在不可變引用的情況下修改內部值。與Cell<T>
不同,RefCell<T>
可以用於非Copy
型別。
RefCell<T>
透過借用檢查來確保執行時的安全性。當你嘗試獲取一個可變引用時,RefCell<T>
會檢查是否已經有其他可變引用或不可變引用。如果有,則會發生執行時錯誤。
RefCell<T>
通常用於以下情況:
-
當你需要在不可變引用的情況下修改內部值時,可以使用
RefCell<T>
來實現內部可變性。 -
當你需要在結構體中包含一個可變欄位時,可以使用
RefCell<T>
來實現。
下面是一個簡單的例子,演示如何使用RefCell<T>
來修改內部值:
use std::cell::RefCell;
fn main() {
let x = RefCell::new(vec![1, 2, 3]);
let y = &x;
let z = &x;
x.borrow_mut().push(4);
y.borrow_mut().push(5);
z.borrow_mut().push(6);
println!("x: {:?}", x.borrow());
}
複製程式碼
這個例子中,我們使用RefCell::new
來建立一個新的RefCell<T>
例項。然後,我們建立了兩個不可變引用y
和z
,它們都指向同一個值。接著,我們使用borrow_mut
方法來獲取一個可變引用,並使用它來修改內部值。由於RefCell<T>
實現了內部可變性,所以我們可以在不可變引用的情況下修改內部值。
需要注意的是,由於RefCell<T>
透過借用檢查來確保執行時的安全性,所以當你嘗試獲取一個可變引用時,如果已經有其他可變引用或不可變引用,則會發生執行時錯誤。from劉金,轉載請註明原文連結。感謝!