第20章智能指针 on 编程那些事儿

01-Box

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust.beatai.org/smart-pointers/box.html

Box

🌟

1
2
3
4
5
6
7


// 让代码工作
fn main() {
 // 创建一个包含整数 5 的新 box `b`
 assert_eq!(*b, 5);

 println!("Success!");
}

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10



// 让代码工作
fn main() {
 let b = Box::new("Hello");
 print_boxed_string(b);
}

fn print_boxed_string(b : _) {
 println!("{}", b);
}

🌟

1
2
3
4
5
6
7
8
9



// 让代码工作
fn main() {
 let b1 = Box::new(5);
 let b2 = b1;
 assert_eq!(_, 5);

 println!("Success!");
}

🌟

1
2
3
4
5
6



// 让代码工作
fn main() {
 // 创建一个包含数组 [1, 2, 3, 4, 5] 的 box `b`
 // 打印 `b` 中的每个整数
}

你可以在这里找到答案（在 solutions 路径下），但请只在需要时使用

02-Deref

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust.beatai.org/smart-pointers/deref.html

Deref

Deref trait 允许我们将智能指针当作常规引用对待。通过实现 Deref，可以让 * 运算符按预期工作。

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// 让代码工作
use std::ops::Deref;

struct MyBox<T>(T);

impl<T> Deref for MyBox<T> {
 type Target = T;
 fn deref(&self) -> &Self::Target {
 &self.0
 }
}

fn main() {
 let x = MyBox(5);
 assert_eq!(*x, 5);
 println!("Success!");
}

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 让代码工作
use std::ops::Deref;

struct MyBox<T>(T);

impl<T> Deref for MyBox<T> {
 type Target = T;
 fn deref(&self) -> &Self::Target {
 &self.0
 }
}

fn hello(name: &str) {
 println!("Hello, {}!", name);
}

fn main() {
 let m = MyBox(String::from("Rust"));
 hello(&m);
 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// 填空
use std::ops::{Deref, DerefMut};

struct MyBox<T>(T);

impl<T> Deref for MyBox<T> {
 type Target = T;
 fn deref(&self) -> &Self::Target {
 &self.0
 }
}

impl<T> DerefMut for MyBox<T> {
 fn deref_mut(&mut self) -> &mut Self::Target {
 &mut self.0
 }
}

fn main() {
 let mut s = MyBox(String::from("hello"));
 s.__.push_str(", world");
 assert_eq!(*s, "hello, world");
 println!("Success!");
}

你可以在这里找到答案（在 solutions 路径下），但请只在需要时使用

03-Drop

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust.beatai.org/smart-pointers/drop.html

Drop

Drop trait 允许我们在值离开作用域时自定义清理逻辑。Rust 会在变量离开作用域时自动调用 drop。

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 让代码工作
struct CustomSmartPointer {
 data: String,
}

impl Drop for CustomSmartPointer {
 fn drop(&mut self) {
 println!("Dropping CustomSmartPointer with data `{}`!", self.data);
 }
}

fn main() {
 let c = CustomSmartPointer {
 data: String::from("my stuff"),
 };
 println!("CustomSmartPointer created.");
 println!("About to leave main.");
 println!("Success!");
}

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// 让代码工作
struct CustomSmartPointer {
 data: String,
}

impl Drop for CustomSmartPointer {
 fn drop(&mut self) {
 println!("Dropping `{}`", self.data);
 }
}

fn main() {
 let c = CustomSmartPointer {
 data: String::from("first"),
 };
 let d = CustomSmartPointer {
 data: String::from("second"),
 };
 println!("Created two pointers.");
 drop(c);
 println!("Dropped first pointer early.");
 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// 填空
struct HasDrop(i32);

impl Drop for HasDrop {
 fn drop(&mut self) {
 println!("Dropped {}", self.0);
 }
}

fn main() {
 let a = HasDrop(1);
 let b = HasDrop(2);
 {
 let c = HasDrop(3);
 println!("inner scope");
 }
 println!("Success!");
}

你可以在这里找到答案（在 solutions 路径下），但请只在需要时使用

04-Rc and Arc

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust.beatai.org/smart-pointers/rc-arc.html

Rc and Arc

Rc<T> 用于单线程下的引用计数；Arc<T> 是线程安全的原子引用计数，常用于多线程共享数据。

05-Cell and RefCell

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust.beatai.org/smart-pointers/cell-refcell.html

Cell and RefCell

Cell<T> 和 RefCell<T> 提供内部可变性：在不可变引用存在时也能修改数据。RefCell 在运行时检查借用规则。

🌟

1
2
3
4
5
6
7
8
9


// 让代码工作
use std::cell::Cell;

fn main() {
 let c = Cell::new(5);
 c.set(10);
 assert_eq!(c.get(), 10);
 println!("Success!");
}

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 让代码工作
use std::cell::RefCell;

fn main() {
 let data = RefCell::new(5);
 {
 let mut r = data.borrow_mut();
 *r += 1;
 }
 assert_eq!(*data.borrow(), 6);
 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// 让代码工作
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug)]
enum List {
 Cons(i32, RefCell<Rc<List>>),
 Nil,
}

use List::{Cons, Nil};

fn main() {
 let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));
 let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a))));

 if let Some(link) = Rc::into_inner(a) {
 if let Cons(_, ref next) = link {
 *next.borrow_mut() = Rc::clone(&b);
 }
 }

 println!("Success!");
}

🌟🌟

1
2
3
4
5
6
7
8
9


// 填空
use std::cell::RefCell;

fn main() {
 let s = RefCell::new(String::from("hello"));
 s.borrow_mut().push_str(", world");
 assert_eq!(s.borrow().as_str(), __);
 println!("Success!");
}

你可以在这里找到答案（在 solutions 路径下），但请只在需要时使用

第20章 智能指针 on 编程那些事儿

01-Box

Box

02-Deref

Deref

03-Drop

Drop

04-Rc and Arc

Rc and Arc

05-Cell and RefCell

Cell and RefCell

第20章智能指针 on 编程那些事儿