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

星释2025-11-06 10:23

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

什么是 Deref trait？

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

基本语法

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

rust 复制代码 
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 示例

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

rust 复制代码 
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。

rust 复制代码 
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);
}

实际应用场景

自定义智能指针

rust 复制代码 
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
}

引用计数智能指针

rust 复制代码 
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);
}

内部可变性模式

rust 复制代码 
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 强制转换：

rust 复制代码 
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，它允许我们重载可变解引用运算符：

rust 复制代码 
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; // 使用 DerefMut
    println!("Value: {}", *pointer); // 使用 Deref
}

最佳实践

1. 合理使用 Deref 强制转换

rust 复制代码 
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

rust 复制代码 
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 的类型：

rust 复制代码 
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 强制转换
}

总结

Deref trait 是 Rust 中一个强大而重要的特性，它允许我们：

  1. 创建智能指针类型
  2. 实现自动解引用
  3. 利用 Deref 强制转换编写更灵活的代码
  4. 与标准库类型保持一致的行为

关键要点：

  • Deref trait 允许重载解引用运算符 *
  • Deref 强制转换自动将 &T 转换为 &U（当 T: Deref<Target = U>）
  • 标准库中的 Box<T>、String、Vec<T> 等都实现了 Deref
  • 合理使用 Deref 可以让自定义类型表现得像内置类型一样

通过合理使用 Deref trait，我们可以创建更加直观和易用的智能指针类型。

相关推荐
枫叶林FYL几秒前
【强化学习】2 大规模并行强化学习中的耦合策略优化：受控多样性驱动的样本高效探索
开发语言·php
chao1898442 分钟前
基于MATLAB的音频信号AM调制与解调实现
开发语言·matlab·音视频
雨落在了我的手上5 分钟前
初识java（八）：数组的定义与使用
java·开发语言
贵州晓智信息科技5 分钟前
曼德勃罗集的 Three.js 实现
开发语言·javascript·ecmascript
xiaoshuaishuai86 分钟前
C# CUDA 到 OpenCL 迁移
开发语言·windows·c#
AI科技星6 分钟前
基于平行素数对等腰梯形网格拓扑的完备性证明哥德巴赫猜想1+1
c语言·开发语言·网络·量子计算·agi
聆风吟º7 分钟前
【C标准库】深入理解C语言 isdigit函数详解：判断字符是否为数字
c语言·开发语言·库函数·isdigit
故事和你918 分钟前
洛谷-【图论2-4】连通性问题1
开发语言·数据结构·c++·算法·动态规划·图论
RSCompany10 分钟前
Frida 17 以后 Python API 跑旧版 JS 报 Java is not defined ？一行 import 直接恢复 Frida 16 体验
开发语言·python·逆向·hook·frida·android逆向·frida17
快乐的哈士奇13 分钟前
对话框打字机效果：Vur + Java/Python 实现
java·开发语言·python
热门推荐
01GitHub 镜像站点02Codex 接入 DeepSeek API 完整配置文档03CC-Switch & Claude 基于 Linux 服务器安装使用指南04【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法05几个好用的ip纯净度检测网站06【AI】2026 年具身智能模型和世界模型总结07裂开！ChatGPT 居然开始要手机号验证，附详细解决方法08装上就回不去了：CodeGraph 让 AI 编程效率飙升 92%，它到底做了什么？09codex app每次打开重连5次Reconnecting问题解决10用了半年 OpenRouter，我换到了 Ofox.ai — 两个 AI API 聚合平台的真实对比