当前位置：首页 > news >正文

Rust 练习册 4：Deref trait 与智能指针

news 2025/11/6 15:02:48

在 Rust 中，Deref trait 是一个非常重要的特性，它允许我们自定义解引用运算符（*）的行为。通过实现 Deref trait，我们可以创建智能指针类型，让它们在使用时表现得像常规引用一样。今天我们就来深入学习 Deref trait 的使用方法和工作原理。

什么是 Deref trait？

Deref trait 允许我们重载解引用运算符（*），它可以让智能指针类型表现得像常规引用一样。当我们实现 Deref trait 时，就可以编写能够与引用和智能指针一起工作的代码。

基本语法

实现 Deref trait 需要定义关联类型 Target 和 deref 方法：

use std::ops::Deref;struct MySmartPointer<T>(T);impl<T> MySmartPointer<T> {fn new(x: T) -> MySmartPointer<T> {MySmartPointer(x)}
}impl<T> Deref for MySmartPointer<T> {type Target = T;fn deref(&self) -> &T {&self.0}
}

在这个例子中，我们定义了一个简单的智能指针 MySmartPointer<T>，它包装了一个值。通过实现 Deref trait，我们可以像使用普通引用一样使用这个智能指针。

项目中的 Deref 示例

让我们来看一个来自项目中的实际示例：

use std::ops::Deref;struct MySmartPointer<T>(T);impl<T> MySmartPointer<T> {fn new(x: T) -> MySmartPointer<T> {MySmartPointer(x)}
}impl<T> Deref for MySmartPointer<T> {type Target = T;fn deref(&self) -> &T {&self.0}
}struct User {name: &'static str,
}impl User {fn name(&self) {println!("{:?}", self.name);}
}#[test]
fn it_works() {let u = User { name: "Alex" };let y = MySmartPointer::new(u);assert_eq!("Alex", y.name);
}

在这个例子中，我们定义了一个 MySmartPointer<T> 智能指针和一个 User 结构体。通过实现 Deref trait，我们可以直接通过 y.name 访问 User 的字段，而不需要先解引用智能指针。

Deref 强制转换（Deref Coercion）

Deref trait 最强大的特性之一是 Deref 强制转换。当一个类型 T 实现了 Deref<Target = U> 时，Rust 会自动将 &T 转换为 &U。

use std::ops::Deref;struct MyString {data: Vec<char>,
}impl MyString {fn new(s: &str) -> MyString {MyString {data: s.chars().collect(),}}
}impl Deref for MyString {type Target = [char];fn deref(&self) -> &[char] {&self.data}
}fn print_slice(slice: &[char]) {for c in slice {print!("{}", c);}println!();
}fn deref_coercion_example() {let my_string = MyString::new("hello");// 由于 Deref 强制转换，&MyString 自动转换为 &[char]print_slice(&my_string);
}

实际应用场景

自定义智能指针

use std::ops::Deref;struct MyBox<T>(T);impl<T> MyBox<T> {fn new(x: T) -> MyBox<T> {MyBox(x)}
}impl<T> Deref for MyBox<T> {type Target = T;fn deref(&self) -> &T {&self.0}
}fn hello(name: &str) {println!("Hello, {}!", name);
}fn smart_pointer_example() {let m = MyBox::new(String::from("Rust"));hello(&m); // Deref 强制转换：&MyBox<String> -> &String -> &str
}

引用计数智能指针

use std::ops::Deref;
use std::rc::Rc;fn reference_counted_example() {let rc_value = Rc::new(5);let rc_clone = Rc::clone(&rc_value);// Rc<T> 实现了 Deref，所以可以直接使用println!("Value: {}", *rc_value);println!("Clone value: {}", *rc_clone);// 也可以像使用引用一样传递fn print_value(x: &i32) {println!("Value is: {}", x);}print_value(&rc_value);print_value(&rc_clone);
}

内部可变性模式

use std::ops::Deref;
use std::cell::RefCell;
use std::rc::Rc;struct MyRef<T>(Rc<RefCell<T>>);impl<T> MyRef<T> {fn new(value: T) -> MyRef<T> {MyRef(Rc::new(RefCell::new(value)))}
}impl<T> Deref for MyRef<T> {type Target = RefCell<T>;fn deref(&self) -> &RefCell<T> {&self.0}
}fn interior_mutability_example() {let my_ref = MyRef::new(5);*my_ref.borrow_mut() = 10;println!("Value: {}", my_ref.borrow());
}

Deref 与函数调用

当类型实现了 Deref trait 时，Rust 会自动进行 Deref 强制转换：

use std::ops::Deref;struct Wrapper<T>(T);impl<T> Wrapper<T> {fn new(value: T) -> Wrapper<T> {Wrapper(value)}
}impl<T> Deref for Wrapper<T> {type Target = T;fn deref(&self) -> &T {&self.0}
}fn takes_i32(x: &i32) {println!("Value: {}", x);
}fn deref_function_example() {let wrapped = Wrapper::new(42);// 以下调用都是等价的：takes_i32(&wrapped);        // 自动 Deref 强制转换takes_i32(&*wrapped);       // 显式解引用后再借用takes_i32(wrapped.deref()); // 直接调用 deref 方法
}

DerefMut trait

除了 Deref trait，还有 DerefMut trait，它允许我们重载可变解引用运算符：

use std::ops::{Deref, DerefMut};struct MyMutablePointer<T>(T);impl<T> MyMutablePointer<T> {fn new(value: T) -> MyMutablePointer<T> {MyMutablePointer(value)}
}impl<T> Deref for MyMutablePointer<T> {type Target = T;fn deref(&self) -> &T {&self.0}
}impl<T> DerefMut for MyMutablePointer<T> {fn deref_mut(&mut self) -> &mut T {&mut self.0}
}fn mutable_deref_example() {let mut pointer = MyMutablePointer::new(5);*pointer = 10; // 使用 DerefMutprintln!("Value: {}", *pointer); // 使用 Deref
}

最佳实践

1. 合理使用 Deref 强制转换

use std::ops::Deref;struct MyString(String);impl Deref for MyString {type Target = str;fn deref(&self) -> &str {&self.0}
}// 好的做法：利用 Deref 强制转换
fn process_str(s: &str) {println!("Processing: {}", s);
}fn good_practice_example() {let my_string = MyString(String::from("Hello"));process_str(&my_string); // 自动转换
}

2. 避免过度使用 Deref

use std::ops::Deref;// 避免：创建行为与引用差异很大的类型却实现 Deref
struct Counter {count: i32,
}impl Deref for Counter {type Target = i32;fn deref(&self) -> &i32 {&self.count}
}// 这样可能会令人困惑，因为 Counter 不应该像 i32 一样使用

与标准库类型的比较

让我们看看标准库中的一些实现了 Deref 的类型：

use std::ops::Deref;fn standard_library_examples() {// Box<T> 实现了 Deref<Target = T>let boxed = Box::new(5);println!("Boxed value: {}", *boxed);// String 实现了 Deref<Target = str>let string = String::from("hello");let slice: &str = &string; // Deref 强制转换// Vec<T> 实现了 Deref<Target = [T]>let vec = vec![1, 2, 3];let slice: &[i32] = &vec; // Deref 强制转换
}