一文解惑 Rust 中的智能指针，你需要知道什么时候使用指针！！

傻梦兽
338 阅读10分钟

大家好，我是梦兽。一个 WEB 全栈开发和 Rust 爱好者。如果你对 Rust 非常感兴趣，可以关注梦兽编程公众号获取群，进入和梦兽一起交流。

Rust 引入了智能指针作为一种强大的内存管理特性。与 C++ 等语言中的传统指针不同，Rust 的智能指针不仅仅是内存地址；它们是数据结构，不仅包含指向数据的指针，还包含额外的元数据和功能。

本文深入探讨 Rust 中的智能指针，通过广泛的代码示例展示其用法，并以创建自定义智能指针的例子作为结尾。

让我们开始吧！🦀

要深入了解 Rust 中的智能指针，至关重要的是要区分它们与常规引用的区别。智能指针是不仅管理内存资源，而且还具有额外元数据和功能的数据结构。它们与常规引用在所有权、功能和应用场景上有所不同。

与常规引用的区别

  • 所有权和控制：Rust 中的常规引用借用数据；它们并不拥有数据。意味着引用所指向的数据在被使用期间不能被释放。智能指针拥有它们所指向的数据。当智能指针超出作用域时，它负责清理它所管理的数据。
  • 元数据和功能：智能指针不仅仅包含内存地址。它们可以包含元数据（例如 Rc<T> 中的引用计数），并提供额外的功能（例如 RefCell<T> 中的可变性控制）。
  • 解引用行为：智能指针使用 Deref 和 DerefMut 特质来解引用到它们的数据，而常规引用是天然支持解引用的。
  • 自定义析构逻辑：在智能指针中实现 Drop 特质允许在智能指针超出作用域时执行自定义逻辑，从而能够管理除了内存之外的其他资源，比如文件句柄或网络套接字。

深入探讨：Box<T>

Box<T> 是 Rust 中最简单的智能指针类型。它在堆上分配空间，并将对该空间的所有权交给 Box。当 Box 超出作用域时，其析构函数会被调用，堆上的内存会被释放。

使用场景

接下来的部分将详细介绍 Box<T> 的具体使用场景

fn main() {
    let heap_data = Box::new(10); // 在堆上分配一个整数
    println!("Heap data: {}", heap_data);
} // `heap_data` 超出作用域后，其占用的内存被释放

深入探讨：Rc<T>Rc<T>，

即引用计数的缩写，允许多个所有者共享堆上的同一份数据。每个 Rc<T> 的克隆都会增加引用计数。只有当最后一个指向该数据的 Rc<T> 被丢弃时，数据才会被清理。

引用计数机制

接下来的部分将详细解释 Rc<T> 的引用计数机制。

use std::rc::Rc;

fn main() {
    let data = Rc::new(5);
    let other_data = data.clone(); // 增加引用计数
    // data 和 other_data 都指向同一块内存"。
    println!("Data: {}", data);
    println!("Other Data: {}", other_data);
} // 引用计数在此处降为零，相应的内存被释放。

深入探讨：RefCell<T>RefCell<T>

提供了“内部可变性”：一种即使 RefCell<T> 本身是不可变的情况下也能修改其所持有数据的方法。它在运行时而非编译时强制执行 Rust 的借用规则。

运行时的借用规则

接下来的部分将详细解释 RefCell<T> 如何在运行时执行借用规则。

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(5);
    {
        let mut data_borrow = data.borrow_mut();
        *data_borrow += 1;
    } // `data_borrow` 超出作用域，借用结束
    println!("Data: {}", data.borrow());
}

自定义智能指针

创建自定义智能指针涉及对所有权的理解以及 Deref 和 Drop 特质的使用。

示例：MySmartPointer<T>

接下来的部分将详细介绍如何创建一个名为 MySmartPointer<T> 的自定义智能指针。

use std::ops::{Deref, DerefMut};

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
    }
}

impl<T> DerefMut for MySmartPointer<T> {
    fn deref_mut(&mut self) -> &mut T {
        &mut self.0
    }
}

impl<T> Drop for MySmartPointer<T> {
    fn drop(&mut self) {
        println!("Dropping MySmartPointer");
    }
}

fn main() {
    let my_pointer = MySmartPointer::new(5);
    println!("Value: {}", *my_pointer);
}

在这个例子中，MySmartPointer 行为类似于一个智能指针，管理其数据的所有权并提供解引用功能。Drop 特质的实现允许执行自定义的清理逻辑。

在 Rust 中使用智能指针是一个基于对其能力的理解和你的具体应用场景需求的决定。以下是一些指导原则，帮助你判断何时应该使用它们，何时不应该使用它们。

何时使用智能指针

  • 堆分配：当你需要将数据存储在堆上而不是栈上时，可以使用 Box<T>。这对于大型数据结构特别有用，或者当你需要为递归类型指定固定大小时。
  • 动态多态：利用 Box<T> 实现动态调度。如果你有一个特质，并希望存储实现了该特质的不同类型，Box<dyn Trait> 将是你的首选。
  • 共享所有权：当数据需要被多个所有者访问时，可以选择 Rc<T> 或者线程安全版本 Arc<T>。这些智能指针对于图状数据结构非常有用，或者当你需要在程序的不同部分之间共享数据而没有明确的单一所有者时。
  • 内部可变性：当你需要即使在数据被不可变借用时仍能修改它时，可以选择 RefCell<T> 或者用于多线程场景下的 Mutex<T> / RwLock<T>。这在实现诸如观察者模式时特别有用，或者当你知道可以安全地放宽借用约束时，以绕过借用规则。
  • 自定义智能指针：当标准库中的智能指针无法满足你的特定需求时，例如专门的内存管理策略、非标准资源管理（如文件句柄或网络连接），或者自定义的引用计数逻辑，可以创建自己的智能指针。

何时不应使用智能指针

  • 栈分配足够的情况：对于小量或短期存在的数据，如果它们可以高效地存储在栈上，则应避免使用智能指针。在这种情况下，堆分配和指针间接寻址的开销是不必要的。
  • 性能关键部分：在对性能敏感的代码中，Rc<T> 和 Arc<T> 中的引用计数开销以及 RefCell<T> 的运行时借用检查可能会带来负面影响。在这种情形下，使用常规引用或其他 Rust 特性如生命周期可能更为合适。
  • 独占所有权：如果你的数据有明确的单一所有者，并且不需要堆分配，那么应坚持使用常规引用或所有权。在这种情况下使用 Box<T> 会增加不必要的开销。
  • 并发环境：避免在并发环境中使用 Rc<T> 和 RefCell<T>，因为它们不是线程安全的。在多线程环境下，应优先使用 Arc<T>、Mutex<T> 或 RwLock<T>。
  • 简单的借用情况：对于那些借用规则易于遵循的简单借用场景，常规引用更为适合。过度使用 RefCell<T> 或其他智能指针可能会使代码复杂化并引入不必要的运行时检查。

性能影响

  • 堆分配：智能指针通常涉及到堆分配（如 Box<T>、Rc<T> 和 Arc<T>）。由于管理堆内存的开销，堆分配通常比栈分配慢。这可能会影响性能，尤其是在频繁进行分配和释放的情形下。
  • 间接寻址和解引用：智能指针增加了间接寻址的层次。访问数据需要解引用指针，这可能不如直接访问栈上的数据那样高效，特别是在性能关键部分的代码中频繁进行解引用操作时。
  • 引用计数：Rc<T> 和 Arc<T> 通过引用计数来管理共享所有权。增加和减少引用计数涉及到原子操作，尤其是在 Arc<T> 中，因为它是线程安全的。这些操作可能会增加开销，特别是在多线程环境中，因为原子操作的成本更高。
  • 运行时借用检查：RefCell<T> 和类似的类型在运行时执行借用检查。这会增加开销，因为它需要运行时检查来强制执行借用规则，与常规引用在编译时进行检查的方式不同。

可读性影响

  • 所有权和生命周期的清晰性：智能指针可以使所有权和生命周期变得明确，这对提高可读性是有益的。例如，看到 Box<T> 或 Rc<T> 明确指示了堆分配和所有权的细节。
  • 代码复杂性：另一方面，过度使用智能指针或不当使用智能指针可能会导致代码难以跟踪。例如，嵌套的智能指针（如 Rc<RefCell<T>>）或解引用后的智能指针上深层的方法调用链会降低可读性。
  • 显式的生命周期管理：资源的显式管理（比如显式丢弃智能指针或引用计数）可能会使代码变得更加冗长且难以阅读，与自动栈分配和释放相比。
  • 简洁性与明确性的平衡：虽然智能指针可以使某些模式变得更简洁（如共享所有权），但与使用简单引用相比，它们也可能导致代码更加冗长。找到简洁性和明确性之间的正确平衡对于维持可读性至关重要。

平衡性能与可读性

  • 审慎使用智能指针：当智能指针的好处（如共享所有权或堆分配）是必要的时候才使用它们。对于简单的借用情况或栈分配足以应对的情况，避免使用智能指针。
  • 性能剖析：如果性能是一个关注点，对你的应用进行性能剖析以理解智能指针的影响。在某些情况下，智能指针带来的开销可能与整体性能相比微不足道，而在其他情况下，它可能是瓶颈。
  • 重构以提高可读性：如果智能指针使你的代码过于复杂或难以阅读，考虑进行重构。有时候分解复杂的函数或重构数据结构可以减少对复杂智能指针使用的需要。
  • 文档和注释：在智能指针的使用不立即明显的情况下，注释和文档可以帮助维持可读性。解释为什么使用某种类型的智能指针是非常有价值的，有助于未来的维护。

结束语

感谢阅读！感谢您的时间，并希望您觉得这篇文章有价值。在您的下一个 JavaScript 项目中尝试使用柯里化，并在下面的评论中告诉我它如何改善了您的编码体验！

创建和维护这个博客以及相关的库带来了十分庞大的工作量，即便我十分热爱它们，仍然需要你们的支持。或者转发文章。通过赞助我，可以让我有能投入更多时间与精力在创造新内容，开发新功能上。赞助我最好的办法是微信公众号看看广告。

本文使用 markdown.com.cn 排版

avatar
文章
阅读
粉丝