rc<T>，引用计数智能指针 -- Rust教程|Rust中文文档|Rust编程|Rust官方文档

`rc<T>`，引用计数智能指针

在大多数情况下，所有权是明确的：您确切地知道哪个变量拥有给定的值。但是，在某些情况下，单个值可能具有多个所有者。例如，在图形数据结构中，多个边可能会指向同一节点，并且该节点在概念上由所有边拥有指向它。除非节点没有任何 edges 指向它，因此没有所有者。

您必须使用 Rust type 显式启用多个所有权，该类型是引用计数的缩写。类型跟踪对值的引用数以确定该值仍在使用中。如果对某个值的引用为零，则值可以清理而不会使任何引用无效。Rc<T>Rc<T>

想象一下家庭活动室里的电视。当一个人进来看电视时，他们打开了它。其他人可以进入房间看电视。当最后一个人们离开房间，他们关掉了电视，因为它不再被使用。如果有人在其他人仍在观看电视时关闭电视，就会有其余电视观众的哗然！Rc<T>

当我们想在堆上为要读取程序的多个部分，并且我们在编译时无法确定哪个部分将最后完成对数据的使用。如果我们知道哪个部分会完成最后，我们可以将这部分设为数据的所有者，而 Normal 所有权在编译时强制执行的规则将生效。Rc<T>

请注意，这仅适用于单线程方案。当我们讨论并发性，我们将介绍如何在多线程程序。Rc<T>

让我们回到示例 15-5 中的 cons 列表示例。回想一下，我们定义了它使用 .这一次，我们将创建两个共享所有权的列表第三个列表。从概念上讲，这类似于图 15-3：Box<T>

图 15-3：两个列表 b 和 c，共享第三个列表

我们将创建包含 5 个和 10 个的列表。然后我们再制作两个 lists：以 3 开头，以 4 开头。然后，这两个 and 列表将继续到包含 5 和 10 的第一个列表。在其他 words，则两个列表将共享包含 5 和 10 的第一个列表。abcbca

尝试使用我们的 with 定义来实现这个场景是行不通的，如示例 15-17 所示：ListBox<T>

文件名： src/main.rs

enum List {
    Cons(i32, Box<List>),
    Nil,
}

use crate::List::{Cons, Nil};

fn main() {
    let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
    let b = Cons(3, Box::new(a));
    let c = Cons(4, Box::new(a));
}

示例 15-17：证明我们不允许拥有两个使用 Box<T> 的列表，试图共享第三个列表的所有权

当我们编译此代码时，我们收到此错误：

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0382]: use of moved value: `a`
  --> src/main.rs:11:30
   |
9  |     let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
   |         - move occurs because `a` has type `List`, which does not implement the `Copy` trait
10 |     let b = Cons(3, Box::new(a));
   |                              - value moved here
11 |     let c = Cons(4, Box::new(a));
   |                              ^ value used here after move

For more information about this error, try `rustc --explain E0382`.
error: could not compile `cons-list` (bin "cons-list") due to 1 previous error

变体拥有它们持有的数据，因此当我们创建列表时，将移动到并拥有 .然后，当我们尝试再次使用 when 正在创建，我们不允许这样做，因为已被移动。Consbabbaaca

我们可以将的定义更改为 hold 引用，但随后我们必须指定生命周期参数。通过指定生命周期参数，我们将指定列表中的每个元素都将位于至少与整个列表一样长。元素和列表就是这种情况在示例 15-17 中，但并非在每个场景中。Cons

相反，我们将的定义更改为 use 来代替，如示例 15-18 所示。现在，每个变体都将包含一个值以及指向 .当我们创建时，而不是采用的所有权，我们将克隆持有的，从而将引用数量从 1 增加到 2，并 LET 并共享该 .我们还会在 creating ，将引用数量从 2 个增加到 3 个。每次我们调用，将 WILL 中数据的引用计数 increase，除非对它。ListRc<T>Box<T>ConsRc<T>ListbaRc<List>aabRc<List>acRc::cloneRc<List>

文件名： src/main.rs

enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::rc::Rc;

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

示例 15-18：使用 Rc<T 的 List 定义>

我们需要添加一个语句以纳入范围，因为它不是在序曲中。在中，我们创建包含 5 和 10 的列表并将其存储在新 .然后，当我们创建 and 时，我们调用函数并将对 in 的引用作为论点。useRc<T>mainRc<List>abcRc::cloneRc<List>a

我们本可以调用而不是，但 Rust 的 convention 在这种情况下使用。的实现不会像大多数类型那样对所有数据进行深层复制” do 的实现。对的调用仅递增 reference count 的 Count，这不会花费太多时间。数据的深层副本可以采用很多时间。通过使用 for reference counting，我们可以直观地区分深拷贝类型的克隆和以下类型的克隆增加引用计数。在代码中，我们只需要考虑深拷贝克隆，并且可以忽略对 .a.clone()Rc::clone(&a)Rc::cloneRc::clonecloneRc::cloneRc::cloneRc::clone

克隆 `Rc<T>` 会增加引用计数

让我们更改示例 15-18 中的工作示例，以便我们可以看到参考计数会发生变化，因为我们创建和删除对 in 的引用。Rc<List>a

在示例 15-19 中，我们将更改它，使其在 list 周围有一个内部作用域; 然后我们可以看到 reference count 在超出范围时如何变化。maincc

文件名： src/main.rs

enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::rc::Rc;

fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    println!("count after creating a = {}", Rc::strong_count(&a));
    let b = Cons(3, Rc::clone(&a));
    println!("count after creating b = {}", Rc::strong_count(&a));
    {
        let c = Cons(4, Rc::clone(&a));
        println!("count after creating c = {}", Rc::strong_count(&a));
    }
    println!("count after c goes out of scope = {}", Rc::strong_count(&a));
}

示例 15-19：打印引用计数

在程序中引用计数发生变化的每个点，我们都会打印 reference count 的 c.这函数被命名，而不是因为还有一个 ;我们将在 “防止参考循环：将 Rc<T> 变成 Weak<T> 一节中看到它的用途。Rc::strong_countstrong_countcountRc<T>weak_countweak_count

此代码打印以下内容：

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.45s
     Running `target/debug/cons-list`
count after creating a = 1
count after creating b = 2
count after creating c = 3
count after c goes out of scope = 2

我们可以看到 in 的初始引用计数为 1;然后每次调用时，计数都会增加 1。当超出范围时，计数减少 1。我们不必调用函数来减少引用计数，就像我们必须调用以增加引用一样 count：特征的实现会减少引用计数当值超出范围时自动进行。Rc<List>aclonecRc::cloneDropRc<T>

在这个例子中，我们看不到的是 when 和 then 超出范围在的末尾，计数为 0，并清理完全。Using 允许单个值具有多个所有者，并且 count 可确保只要任何所有者仍然存在。bamainRc<List>Rc<T>

通过不可变引用，允许您在多个程序的部件仅用于读取。如果允许，您可以有多个可变引用，则可能会违反所讨论的借用规则之一在第 4 章中：对同一位置的多个可变借用会导致数据竞争和不一致。但是能够更改数据非常有用！在下一个部分中，我们将讨论内部可变性模式和类型，你可以将其与 an 结合使用不可变性限制。Rc<T>Rc<T>RefCell<T>Rc<T>

Rust 编程语言

rc<T>，引用计数智能指针

使用 Rc<T> 共享数据

克隆 Rc<T> 会增加引用计数

`rc<T>`，引用计数智能指针

使用 `Rc<T>` 共享数据

克隆 `Rc<T>` 会增加引用计数