IT评测·应用市场-qidao123.com

标题: Rust中的智能指针:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> [打印本页]
作者: 饭宝    时间: 2023-4-20 03:23
标题: Rust中的智能指针:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T>
Rust中的智能指针是什么

智能指针（smart pointers）是一类数据结构，是拥有数据所有权和额外功能的指针。是指针的进一步发展
指针（pointer）是一个包含内存地址的变量的通用概念。这个地址引用，或 ” 指向”（points at）一些其 他数据 。引用以 & 符号为标志并借用了他们所 指向的值。除了引用数据没有任何其他特殊功能。它们也没有任何额外开销，所以在Rust中应用得最多。
智能指针是Rust中一种特殊的数据结构。它与普通指针的本质区别在于普通指针是对值的借用，而智能指针通常拥有对数据的所有权。并且可以实现很多额外的功能。
Rust智能指针有什么用，解决了什么问题

它提供了许多强大的抽象来帮助程序员管理内存和并发。其中一些抽象包括智能指针和内部可变性类型，它们可以帮助你更安全、更高效地管理内存,例如Box 用于在堆上分配值。Rc 是一种引用计数类型，可以实现数据的多重所有权。RefCell 提供内部可变性，可用于实现对同一数据的多个可变引用
它们在标准库中定义，可以用来更灵活地管理内存，智能指针的一个特点就是实现了Drop和Deref这两个trait。其中Drop trait中提供了drop方法，在析构时会去调用。Deref trait提供了自动解引用的能力，让我们在使用智能指针的时候不需要再手动解引用了
Rust有哪些常用智能指针

内部可变性类型允许你在不可变引用的情况下修改内部值。Rust中有几种内部可变性类型，包括Cell，RefCell和UnsafeCell。
此外，Rust还提供了一种弱引用类型Weak，它可以与Rc或Arc一起使用来创建循环引用。Weak不会增加引用计数，因此它不会阻止值被释放。
Box

Box是最简单的智能指针，它允许你在堆上分配值并在离开作用域时自动释放内存。
Box通常用于以下情况：
总之，当你需要在堆上分配内存并管理其生命周期时，可以考虑使用Box。
下面是一个简单的例子：
  1. fn main() {
  2.     let b = Box::new(5);
  3.     println!("b = {}", b);
  4. }
  5. 复制代码
复制代码
这里定义了变量 b，其值是一个指向被分配在堆上的值 5 的 Box。这个程序会打印出 b = 5；在这个例子 中，我们可以像数据是储存在栈上的那样访问 box 中的数据。正如任何拥有数据所有权的值那样，当像 b 这样的 box 在 main 的末尾离开作用域时，它将被释放。这个释放过程作用于 box 本身（位于栈上） 和它所指向的数据（位于堆上）。
但是Box无法同时在多个地方对同一个值进行引用
  1. enum List {
  2. Cons(i32, Box),
  3. Nil,
  4. }
  5. use crate::List::{Cons, Nil};
  6. fn main() {
  7. let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
  8. let b = Cons(3, Box::new(a));
  9. let c = Cons(4, Box::new(a));
  10. }
  11. 复制代码
复制代码
编译会得出如下错误: error[E0382]: use of moved value: a,因为b和c无法同时拥有a的所有权，这个时候我们要用Rc
Rc Reference Counted 引用计数

Rc是一个引用计数类型，它允许多个指针指向同一个值。当最后一个指针离开作用域时，值将被释放。Rc不是线程安全的，因此不能在多线程环境中使用。
Rc通常用于以下情况：
下面是一个简单的例子，演示如何使用Rc来共享数据：
  1. use std::rc::Rc;
  3. fn main() {
  4.     let data = Rc::new(vec![1, 2, 3]);
  5.     let data1 = data.clone();
  6.     let data2 = data.clone();
  7.     println!("data: {:?}", data);
  8.     println!("data1: {:?}", data1);
  9.     println!("data2: {:?}", data2);
  10. }
  11. 复制代码
复制代码
这个例子中，我们使用Rc::new来创建一个新的Rc实例。然后，我们使用clone方法来创建两个新的指针，它们都指向同一个值。由于Rc实现了引用计数，所以当最后一个指针离开作用域时，值将被释放。
但是Rc在多线程中容易引发线程安全问题，为了解决这个问题，又有了Arc
Arc Atomically Reference Counted 原子引用计数

Arc是一个线程安全的引用计数类型，它允许多个指针在多个线程之间共享同一个值。当最后一个指针离开作用域时，值将被释放。
Arc通常用于以下情况：
下面是一个简单的例子，演示如何使用Arc来在线程之间共享数据：
  1. use std::sync::Arc;
  2. use std::thread;
  4. fn main() {
  5.     let data = Arc::new(vec![1, 2, 3]);
  6.     let data1 = data.clone();
  7.     let data2 = data.clone();
  9.     let handle1 = thread::spawn(move || {
  10.         println!("data1: {:?}", data1);
  11.     });
  13.     let handle2 = thread::spawn(move || {
  14.         println!("data2: {:?}", data2);
  15.     });
  17.     handle1.join().unwrap();
  18.     handle2.join().unwrap();
  19. }
  20. 复制代码
复制代码
这个例子中，我们使用Arc::new来创建一个新的Arc实例。然后，我们使用clone方法来创建两个新的指针，它们都指向同一个值。接着，我们在线程中使用这些指针来访问共享数据。由于Arc实现了线程安全的引用计数，所以当最后一个指针离开作用域时，值将被释放。
Weak 弱引用类型

Weak是一个弱引用类型，它可以与Rc或Arc一起使用来创建循环引用。Weak不会增加引用计数，因此它不会阻止值被释放。
当你希望创建一个循环引用时，可以使用Rc或Arc和Weak来实现。
Weak通常用于以下情况：
下面是一个简单的例子，演示如何使用Rc和Weak来创建一个循环引用：
  1. use std::rc::{Rc, Weak};
  3. struct Node {
  4.     value: i32,
  5.     next: Option<Rc<Node>>,
  6.     prev: Option<Weak<Node>>,
  7. }
  9. fn main() {
  10.     let first = Rc::new(Node { value: 1, next: None, prev: None });
  11.     let second = Rc::new(Node { value: 2, next: None, prev: Some(Rc::downgrade(&first)) });
  12.     first.next = Some(second.clone());
  13. }
  14. 复制代码
复制代码
这个例子中，我们定义了一个Node结构体，它包含一个值、一个指向下一个节点的指针和一个指向前一个节点的弱引用。然后，我们创建了两个节点first和second，并使用Rc::downgrade方法来创建一个弱引用。最后，我们将两个节点连接起来，形成一个循环引用。
需要注意的是，由于Weak不会增加引用计数，所以它不会阻止值被释放。当你需要访问弱引用指向的值时，可以使用upgrade方法来获取一个临时的强引用。如果值已经被释放，则upgrade方法会返回None。
UnsafeCell

UnsafeCell是一个底层的内部可变性类型，它允许你在不可变引用的情况下修改内部值。与Cell和RefCell不同，UnsafeCell不提供任何运行时检查来确保安全性。因此，使用UnsafeCell可能会导致未定义行为。
由于UnsafeCell是一个底层类型，它通常不直接用于应用程序代码。相反，它被用作其他内部可变性类型（如Cell和RefCell）的基础。
下面是一个简单的例子，演示如何使用UnsafeCell来修改内部值：
  1. use std::cell::UnsafeCell;
  3. fn main() {
  4.     let x = UnsafeCell::new(1);
  5.     let y = &x;
  6.     let z = &x;
  7.     unsafe {
  8.         *x.get() = 2;
  9.         *y.get() = 3;
  10.         *z.get() = 4;
  11.     }
  12.     println!("x: {}", unsafe { *x.get() });
  13. }
  14. 复制代码
复制代码
这个例子中，我们使用UnsafeCell::new来创建一个新的UnsafeCell实例。然后，我们创建了两个不可变引用y和z，它们都指向同一个值。接着，在一个unsafe块中，我们使用get方法来获取一个裸指针，并使用它来修改内部值。由于UnsafeCell实现了内部可变性，所以我们可以在不可变引用的情况下修改内部值。
需要注意的是，由于UnsafeCell不提供任何运行时检查来确保安全性，所以使用它可能会导致未定义行为。因此，在大多数情况下，你应该使用其他内部可变性类型（如Cell和RefCell），而不是直接使用UnsafeCell。
Cell

Cell是一个内部可变性类型，它允许你在不可变引用的情况下修改内部值。Cell只能用于Copy类型，因为它通过复制值来实现内部可变性。
Cell通常用于以下情况：
  1. use std::cell::Cell;
  3. fn main() {
  4.     let x = Cell::new(1);
  5.     let y = &x;
  6.     let z = &x;
  7.     x.set(2);
  8.     y.set(3);
  9.     z.set(4);
  10.     println!("x: {}", x.get());
  11. }
  12. 复制代码
复制代码
这个例子中，我们使用Cell::new来创建一个新的Cell实例。然后，我们创建了两个不可变引用y和z，它们都指向同一个值。接着，我们使用set方法来修改内部值。由于Cell实现了内部可变性，所以我们可以在不可变引用的情况下修改内部值。
需要注意的是，由于Cell通过复制值来实现内部可变性，所以它只能用于Copy类型。如果你需要在不可变引用的情况下修改非Copy类型的值，可以考虑使用RefCell。
RefCell

RefCell是一个内部可变性类型，它允许你在不可变引用的情况下修改内部值。与Cell不同，RefCell可以用于非Copy类型。
RefCell通过借用检查来确保运行时的安全性。当你尝试获取一个可变引用时，RefCell会检查是否已经有其他可变引用或不可变引用。如果有，则会发生运行时错误。
RefCell通常用于以下情况：
下面是一个简单的例子，演示如何使用RefCell来修改内部值：
  1. use std::cell::RefCell;
  3. fn main() {
  4.     let x = RefCell::new(vec![1, 2, 3]);
  5.     let y = &x;
  6.     let z = &x;
  7.     x.borrow_mut().push(4);
  8.     y.borrow_mut().push(5);
  9.     z.borrow_mut().push(6);
  10.     println!("x: {:?}", x.borrow());
  11. }
  12. 复制代码
复制代码
这个例子中，我们使用RefCell::new来创建一个新的RefCell实例。然后，我们创建了两个不可变引用y和z，它们都指向同一个值。接着，我们使用borrow_mut方法来获取一个可变引用，并使用它来修改内部值。由于RefCell实现了内部可变性，所以我们可以在不可变引用的情况下修改内部值。
需要注意的是，由于RefCell通过借用检查来确保运行时的安全性，所以当你尝试获取一个可变引用时，如果已经有其他可变引用或不可变引用，则会发生运行时错误。from刘金，转载请注明原文链接。感谢！

 
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4