31. 智能指针

  • 理解智能指针与普通引用的区别。
  • 掌握 Box<T>、Rc<T>、RefCell<T>、Arc<T>、Mutex<T> 的使用场景。
  • 理解内部可变性(interior mutability)和运行时借用检查。
  • 学会在递归数据结构和共享状态中选择合适的智能指针。

智能指针(smart pointer)是拥有额外元数据和能力的指针类型。它们通常拥有所指向数据的所有权,并通过实现 Deref 和 Drop trait 来提供自动解引用和清理功能。

常见智能指针:

  • Box<T>:堆分配,单一所有权。
  • Rc<T>:引用计数,共享所有权(单线程)。
  • RefCell<T>:运行时借用检查,提供内部可变性。
  • Arc<T>:原子引用计数,共享所有权(多线程)。
  • Mutex<T> / RwLock<T>:互斥锁,保护共享数据。

Box<T> 是最简单的智能指针,用于在堆上分配数据:

snippet.rust
let b = Box::new(5);
println!("{}", b);                   // 5

Box 常用于:

  1. 递归类型,如链表或树节点。
  2. 大对象,避免栈拷贝。
snippet.rust
enum List {
    Cons(i32, Box<List>),
    Nil,
}
 
use List::{Cons, Nil};
 
let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));

Rc<T> 通过引用计数实现共享所有权,适用于单线程场景:

snippet.rust
use std::rc::Rc;
 
let data = Rc::new(String::from("shared"));
let data2 = Rc::clone(&data);
let data3 = Rc::clone(&data);
 
println!("count: {}", Rc::strong_count(&data)); // 3
println!("{}", data2);
`Rc::clone` 只增加引用计数,不克隆数据本身。

## 31.4 RefCell<T>

RefCell<T> 提供运行时借用检查,允许在不可变引用情况下修改内部数据:

snippet.rust
use std::cell::RefCell;
 
let cell = RefCell::new(5);
 
{
    let mut borrow = cell.borrow_mut();
    *borrow += 1;
}
 
println!("{}", cell.borrow());        // 6
如果违反借用规则,会在运行时 panic,而不是编译时报错。

## 31.5 Rc<RefCell<T» 组合

Rc 和 RefCell 经常组合使用,实现多所有者且可变的数据:

snippet.rust
use std::rc::Rc;
use std::cell::RefCell;
 
let shared = Rc::new(RefCell::new(Vec::new()));
 
let shared1 = Rc::clone(&shared);
shared1.borrow_mut().push(1);
 
let shared2 = Rc::clone(&shared);
shared2.borrow_mut().push(2);
 
println!("{:?}", shared.borrow());  // [1, 2]

在多线程中,使用 Arc<T>(原子引用计数)替代 Rc<T>,用 Mutex<T> 保护可变数据:

snippet.rust
use std::sync::{Arc, Mutex};
use std::thread;
 
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
 
for _ in 0..10 {
    let counter = Arc::clone(&counter);
    let handle = thread::spawn(move || {
        let mut num = counter.lock().unwrap();
        *num += 1;
    });
    handles.push(handle);
}
 
for handle in handles {
    handle.join().unwrap();
}
 
println!("Result: {}", *counter.lock().unwrap()); // 10
场景 推荐类型 说明
—————-——
堆分配递归类型 Box<T> 单一所有权
单线程共享所有权 Rc<T> 引用计数
运行时内部可变性 RefCell<T> 单线程
多线程共享所有权 Arc<T> 原子引用计数
多线程共享可变数据 Arc<Mutex<T>> 线程安全
智能指针 所有权 可变性 线程安全
Box<T> 单一 可变 是
Rc<T> 共享 不可变 否
RefCell<T> 单一 运行时可变 否
Arc<T> 共享 不可变 是
Mutex<T> 共享 加锁可变 是
  1. 为什么不能直接用 Rc<T> 在多线程中共享数据?
  2. RefCell<T> 的借用检查与编译时借用检查有什么区别?
  3. 使用 Box<T> 实现一个递归结构(如二叉树),并编写一个遍历函数。

该主题尚不存在

您访问的页面并不存在。如果允许,您可以使用创建该页面按钮来创建它。

  • rust/智能指针.1786550226.txt.gz
  • 最后更改: 2026/08/12 23:57
  • 由 张叶安