You've already forked comprehensive-rust
mirror of
https://github.com/google/comprehensive-rust.git
synced 2025-06-27 11:08:45 +02:00
39 lines
1.4 KiB
Markdown
39 lines
1.4 KiB
Markdown
# `Rc`
|
|
|
|
[`Rc`][1] is a reference-counted shared pointer. Use this when you need to refer
|
|
to the same data from multiple places:
|
|
|
|
```rust,editable
|
|
use std::rc::Rc;
|
|
|
|
fn main() {
|
|
let mut a = Rc::new(10);
|
|
let mut b = Rc::clone(&a);
|
|
|
|
println!("a: {a}");
|
|
println!("b: {b}");
|
|
}
|
|
```
|
|
|
|
* See [`Arc`][2] and [`Mutex`][3] if you are in a multi-threaded context.
|
|
* You can *downgrade* a shared pointer into a [`Weak`][4] pointer to create cycles
|
|
that will get dropped.
|
|
|
|
[1]: https://doc.rust-lang.org/std/rc/struct.Rc.html
|
|
[2]: ../concurrency/shared_state/arc.md
|
|
[3]: https://doc.rust-lang.org/std/sync/struct.Mutex.html
|
|
[4]: https://doc.rust-lang.org/std/rc/struct.Weak.html
|
|
|
|
<details>
|
|
|
|
* `Rc`'s count ensures that its contained value is valid for as long as there are references.
|
|
* `Rc` in Rust is like `std::shared_ptr` in C++.
|
|
* `Rc::clone` is cheap: it creates a pointer to the same allocation and increases the reference count. Does not make a deep clone and can generally be ignored when looking for performance issues in code.
|
|
* `make_mut` actually clones the inner value if necessary ("clone-on-write") and returns a mutable reference.
|
|
* Use `Rc::strong_count` to check the reference count.
|
|
* `Rc::downgrade` gives you a *weakly reference-counted* object to
|
|
create cycles that will be dropped properly (likely in combination with
|
|
`RefCell`, on the next slide).
|
|
|
|
</details>
|