相对于传统直接使用内存地址来对应内存数据的指针,智能型指针为一种数据结构,除了拥有基本的指针能对应内存数据的功能外,还可以提供其它不同的信息以及额外的功能。例如我们先前使用过的 Vec 结构体和 String 结构体,就是智能型指针。

在 Rust 编程语言中,有实作 Deref 和 Drop 特性的结构体即为智能型指针。Deref 特性可以使结构体支持「解参考」的动作,也就是能决定当该结构实体搭配 * 解参考语法使用时,所回传的数据。拥有 Drop 特性的结构体,其实体会在离开其所在的 scope 时,在被消灭前运行 drop 方法,用来释放内存中应该也要跟着被释放的数据。

Rust 编程语言的标准函数库提供了许多智能型指针,其中比较基本而且常用的有:

  • Box:可以将数据配置在堆积上。
  • Rc:允许堆积上的同一笔数据有许多拥有者。
  • Ref、RefMut 和 RefCell:能让拥有权借用的规则在运行阶段才发生。

Box

Box 结构体可以允许我们将数据保存在堆积中,而不是堆栈。堆栈空间中只会保存指到堆积空间的指针。除了堆积和堆栈本身的访问性能差异之外,Box 结构体并不会有额外的运算资源花费。遇到以下几种情况,我们应该使用 Box 结构体来保存数据:

1. 数据大小在编译阶段无法确定。
2. 确保庞大的数据不会在拥有权更动时被拷贝,因为拷贝数据会需要大量的时间和内存。
3. 对于我们想要拥有的数值,我们只在乎它实作了哪些特性,而不必知道其真正的类型。

任何类型的数据都可以利用 Box 结构体保存在堆积中,可以使用 Box 结构体提供的 new 方法,透过参数传入一个要存进堆积的值,创建出 Box 结构实体。

举例来说:

fn main() {
    let b = Box::new(5); // Box<i32>

    println!("b = {b}");
}

当程序离开 main 函数的 scope 时,b 变量所保存的 Box 结构实体会被消灭,在其被消灭之前会自动释放掉其 allocating 的堆积空间,因此不会有内存泄漏的问题。以上程序运行结果为:

b = 5

如果设计出一种结构体,其字段也会保存该结构体实体的话,这样的结构体称作「递归类型」(Recursive Type)。如以下程序:

struct RecursiveStruct {
    rs: RecursiveStruct,
}

这个程序会编译错误,因为 Rust 的编译器无法在编译阶段知道这个 RecursiveStruct 结构体究竟有多大。但是如果将 rs 字段的类型改成:

struct RecursiveStruct {
    rs: Box<RecursiveStruct>,
}

如此一来,RecursiveStruct 结构体的 rs 字段会将其它的 RecursiveStruct 结构体保存在堆积上,而 Box 结构体的大小跟其泛型类型没有关联,因此这个 RecursiveStruct 结构体的大小可以在编译阶段被计算出来,不会编译错误。

我们也可以利用 Box 结构体来让函数或是方法回传没有具体类型的闭包。如以下程序:

fn returns_closure() -> Box<dyn Fn(i32) -> i32> {
    Box::new(|x| x + 1)
}

刚才我们有提到 Rust 的智能型指针有实作 Deref 特性,也就是说,Box 结构实体可以直接使用 * 解参考语法来取得其堆积中的数据。举例来说:

fn main() {
    let x = 5;
    let y = Box::new(x);
    let z = x + *y;

    println!("{z}");
}

程序运行结果如下:

10

我们也可以替自己的结构体实作 Deref 特性,使其能够支持 * 解参考语法。程序如下:

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 main() {
    let x = 5;
    let y = MyBox::new(x);
    let z = x + *y;

    println!("{z}");
}

将拥有 Deref 特性的结构实体的参考,传给参数类型不符的函数或是方法时,会发生「Deref Coercion」,编译器会自动调用 deref 方法,将该结构实体的参考转成该结构实体解参考之后的值的参考。

举例来说:

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 print_i32(i: &i32) {
    println!("{}", i);
}

fn main() {
    let x = MyBox::new(5);
    let i = &x;

    print_i32(i);
}

main 函数中的变量 i 所保存的值为 MyBox 结构实体的参考(&MyBox<i32>),在被代入至 print_i32 函数的第一个参数时,会因为 Deref Coercion 而自动被转成数值 5 的参考(&i32),因此可以通过编译。

如果想要让结构实体在解参考之后所取得的值是可变的话,可以替其实作 DerefMut 特性。举例来说:

use std::ops::Deref;
use std::ops::DerefMut;

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

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

fn main() {
    let mut x = MyBox::new(5);
    *x += 2;

    println!("{}", *x);
}

程序运行结果如下:

7

接下来谈谈 Drop 特性吧!Drop 特性可以允许我们决定数据在其所属的 scope 已经要结束时所要进行的动作,例如关闭文件或是切断网络连接等等。Box 结构体的 Drop 特性则是被实作来释放其在堆积中配置的空间。某些编程语言会要求用户得自行在适当的时机点安插释放内存的程序,但是在 Rust 编程语言,我们可以借由实作 Drop 特性,让编译器自动在该资源应该要被消灭的位置添加释放内存的代码,如此一来,我们就不用担心不小心犯错而导致内存泄漏了。

举例来说:

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") };
    let d = CustomSmartPointer { data: String::from("other stuff") };

    println!("CustomSmartPointers created.");
}

程序运行结果为:

CustomSmartPointers created.
Dropping CustomSmartPointer with data `other stuff`!
Dropping CustomSmartPointer with data `my stuff`!

变量 d 存的 CustomSmartPointer 实体会比变量 c 还要早被消灭的原因是:变量 c 比变量 d 还要早被存放至堆栈空间中,因此在清除堆栈空间时,变量 d 会比变量 c 还要早拿出来(先进后出)。

我们也可以利用标准函数库中 std::mem 模块所提供的 drop 函数,让程序在 scope 运行结束前就提早释放资源。举例来说:

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") };
    let d = CustomSmartPointer { data: String::from("other stuff") };

    drop(c);

    println!("CustomSmartPointers created.");
}

程序运行结果为:

Dropping CustomSmartPointer with data `my stuff`!
CustomSmartPointers created.
Dropping CustomSmartPointer with data `other stuff`!

Rc

Rc 结构体是一个基于参考数量的智能型指针,可以适用在值不知道会被哪个或是哪些变量拥有的情况。举例来说,在「图」(graph)的数据结构,可能会同时有多个边(edge)去链接到同一个节点(vertex),每个边都是该节点的拥有者,换句话说,只有当这个节点没有被任何的边链接到的时候(Isolated Vertex),这个节点才可以被消灭。Rc 这个名称为「reference counting」(参考计数)的缩写,Rc 结构体可以追踪堆积中值的参考数量,因此可以知道该值目前究竟是不是还有再被使用,能不能将其消灭并释放出内存了。

简单来说,当我们想要在堆积中存放数据,而这个数据无法在编译阶段时决定好由哪个单独的变量来拥有的话,就可以使用 Rc 结构体。

先用 Box 结构体举个简单的例子:

fn main() {
    let a = String::from("Hello world!");
    let b = Box::new(a);
    let c = Box::new(a);
}

以上程序会编译失败,因为变量 a 会在程序第 3 行的时候被「移动」,所以程序第 4 行就不能再被使用。

如果我们要让变量 a 保存的 String 结构实体,被变量 b 和变量 c 拥有的话,可以使用 Rc 结构体改写成:

use std::rc::Rc;

fn main() {
    let a = String::from("Hello world!");
    let b = Rc::new(a); // Rc<String>
    let c = b.clone(); // or Rc::clone(&b);
}

Rc 结构实体的 clone 方法可以再拷贝一份新的 Rc 结构实体。拷贝之后,String 结构实体就等同于有了两个参考。我们可以使用 Rc 结构体提供的 strong_count 函数,来取得当时参考到同一个值的 Rc 结构实体共有几个。

程序如下:

use std::rc::Rc;

fn main() {
    let a = String::from("Hello world!");
    let b = Rc::new(a); // Rc<String>

    println!("{}", Rc::strong_count(&b));

    let c = b.clone();

    println!("{}", Rc::strong_count(&b));

    {
        let d = b.clone();
        println!("{}", Rc::strong_count(&b));
    }

    println!("{}", Rc::strong_count(&b));
}

运行结果为:

1
2
3
2

Rc 结构体无法直接用在可变的数据,需搭配 RefCell 结构体来使用。

Ref、RefMut、RefCell

一般来说,Rust 处理数据时在编译阶段应该要去遵守我们先前介绍的拥有权规则,也就只有使用 mut 关键字的变量才可以取得其可变参考,且该值在一个 scope 下,同时只能有一个可变参考,不能再有其它的参考。

举例来说:

fn main() {
    let mut x = String::from("Hello world!");
    let y = &mut x;
    let z = &x;

    y.push_str(" Rust!");
}

以上程序会编译错误,因为变量 x 已经产生了可变参考给变量 y,而变量 y 在第 6 行还会被使用到,所以第 4 行无法再产生新的参考。

然而我们可以用 RefCell 结构体来改写这个程序,使之通过编译,程序如下:

use std::cell::RefCell;

fn main() {
    let x = String::from("Hello world!");
    let r = RefCell::new(x); // RefCell<String>
    let y = r.borrow_mut();
    let z = r.borrow();
}

RefCell 结构实体的 borrow_mut 方法,可以回传一个新的 RefMut 结构实体,能作为可变参考使用,不必使用 mut 关键字来声明。而 borrow 方法,则可以回传一个新的 Ref 结构实体,能作为不可变参考使用。使用 RefCell 结构实体提供的方法来处理拥有权的规则,是在程序运行阶段才会进行,也因此以上程序可以通过编译,但是当它在运行的时候就会因第 6 行已经产生可变参考给变量 y 使用,所以运行到第 7 行时程序就会发生 panic。

我们也可以让 Rc 结构体参考到 RefCell 结构体,再让 RefCell 结构体去参考实际的值,如此一来 Rc 结构体就有可变参考的特性。程序如下:

use std::cell::RefCell;
use std::rc::Rc;

fn main() {
    let a = String::from("Hello world!");
    let r = RefCell::new(a); // RefCell<String>
    let b = Rc::new(r); // Rc<RefCell<String>>
    let c = b.clone(); // or Rc::clone(&b);

    (*c.borrow_mut()).push_str(" Rust!");

    println!("{}", *c.borrow());
}

内存泄漏

Rc 结构体搭配 RefCell 结构体使用时要小心,若有循环参考的话,就会有内存泄漏的问题。程序如下:

use std::cell::RefCell;
use std::rc::Rc;

enum Node {
    Vertex(i32, Rc<RefCell<Node>>),
    Nil,
}

fn leak_call() {
    let node_nil = Rc::new(RefCell::new(Node::Nil));
    let node_5 = Rc::new(RefCell::new(Node::Vertex(5, node_nil.clone())));
    let node_4 = Rc::new(RefCell::new(Node::Vertex(4, node_5.clone())));
    let node_3 = Rc::new(RefCell::new(Node::Vertex(3, node_4.clone())));
    let node_2 = Rc::new(RefCell::new(Node::Vertex(2, node_3.clone())));
    let node_1 = Rc::new(RefCell::new(Node::Vertex(1, node_2.clone())));
    let mut n = node_5.borrow_mut();

    if let Node::Vertex(_, ref mut nv) = *n {
        *nv = node_1.clone();
    }
}

fn main() {
    loop {
        leak_call();
    }
}

以上程序第 15 行运行完时,leak_call 函数创建出来的 Node 实体在内存中的结构如下:

node_1 -> node_2 -> node_3 -> node_4 -> node_5 -> node_nil

程序第 19 行,我们在 leak_call 函数结束前,将 node_5 的下一个节点设为 node_1,产生循环,使得 Rc 结构体所记的参考数量永远不会为 0,因此在 leak_call 函数结束运行之后,堆积中的数据依然不会被释放,这个就是内存泄漏啦!我们在 main 函数的部份,用无穷循环重复地调用 leak_call 函数,以便观察运行时内存泄漏的情形。这支程序在运行的时候会随时间流逝占用愈来愈多的内存,最终将会因为内存不足而结束运行。

强参考和弱参考

Rc 结构体属于强参考(strong reference),使用 Rc 结构实体的 clone 方法会拷贝出新的强参考,同时也会让 Rc 结构体的 strong_count 函数的回传结果增加,而被参考到的值只有在强参考的数量为 0 时才会被消灭释放。另外还有一种参考相对于强参考,称为弱参考(weak reference)。增加弱参考的数量并不会使得强参考数量增加,换句话说在刚才内存泄漏的例子中,我们可以将原本强参考的部份适当地改为弱参考,这样即便有循环参考,也不会导致内存泄漏。

我们可以透过 Rc 结构体提供的 downgrade 函数来产生 Weak 结构实体,作为弱参考使用。将内存泄漏的程序改写如下:

use std::cell::RefCell;
use std::rc::Rc;
use std::rc::Weak;

enum Node {
    Vertex(i32, Weak<RefCell<Node>>),
    Nil,
}

fn leak_call() {
    let node_nil = Rc::new(RefCell::new(Node::Nil));
    let node_5 = Rc::new(RefCell::new(Node::Vertex(5, Rc::downgrade(&node_nil))));
    let node_4 = Rc::new(RefCell::new(Node::Vertex(4, Rc::downgrade(&node_5))));
    let node_3 = Rc::new(RefCell::new(Node::Vertex(3, Rc::downgrade(&node_4))));
    let node_2 = Rc::new(RefCell::new(Node::Vertex(2, Rc::downgrade(&node_3))));
    let node_1 = Rc::new(RefCell::new(Node::Vertex(1, Rc::downgrade(&node_2))));

    let mut n = node_5.borrow_mut();

    if let Node::Vertex(_, ref mut nv) = *n {
        *nv = Rc::downgrade(&node_1);
    }
}

fn main() {
    loop {
        leak_call();
    }
}

改写后的 leak_call 函数,就不再有内存泄漏的问题了!

使用 Rc 结构体的 weak_count 函数,可以取得弱参考的数量。举例来说:

use std::rc::Rc;

fn main() {
    let a = String::from("Hello world!");
    let b = Rc::new(a);

    println!("{}", Rc::strong_count(&b)); // 1
    println!("{}", Rc::weak_count(&b)); // 0

    let c = Rc::downgrade(&b);

    println!("{}", Rc::strong_count(&b)); // 1
    println!("{}", Rc::weak_count(&b)); // 1

    {
        let d = Rc::downgrade(&b);

        println!("{}", Rc::strong_count(&b)); // 1
        println!("{}", Rc::weak_count(&b)); // 2
    }

    println!("{}", Rc::strong_count(&b)); // 1
    println!("{}", Rc::weak_count(&b)); // 1
}

结论

这个章节我们学到了如何使用 Box 结构体和 Rc 结构体这两种智能型指针来将数据保存到堆积中,前者是在确定数据的拥有者只有一个的情况下使用,本身即可作为可变参考使用;后者则是在数据会有很多个拥有者的情况下使用,本身不能作为可变参考使用,但可以搭配 RefCell 结构体来让 Rust 的拥有权规则在运行阶段才生效。RefCell 结构实体的 borrow 和 borrow_mut 方法分别可以产生 Ref 结构体和 RefMut 结构体这两种功能单纯的智能型指针的实体,分别作为不可变参考或可变参考来使用。

在下一个章节中,我们会学习如何用 Rust 编程语言开发能并发(concurrency)与并行(parallelism)运行的程序。

下一章:并发与并行。