rust智能指针

July 30, 2022

Vec<T> 以及 String 也是智能指针

`Box<T>` 在堆上分配值

Box<T> 的表现与引用（指针）相仿

指针本身占用的内存大小是确定的，其大小并不会根据其指向的数据量而改变

rust

fn print_type_of<T>(_: T) {
    println!("{}", std::any::type_name::<T>())
}

fn main() {
    let a = &1;
    let b = Box::new(2);
    let c = Box::new(3);
    print_type_of(a); // &i32
    print_type_of(*a); // i32
    print_type_of(b); // alloc::boxed::Box<i32>
    print_type_of(*c); // i32
}

其实现原理主要是重载了解引用运算符 * （std::ops::Deref trait）

rust

pub trait Deref {
    type Target: ?Sized;
    fn deref(&self) -> &Self::Target;
}

参见：https://www.rustwiki.org.cn/zh-CN/std/ops/trait.Deref.html

析构函数 `std::ops::Drop` trait

实现了 Drop 的类型将在被销毁时（主要为变量离开作用域）调用 drop 方法

rust

pub trait Drop {
    fn drop(&mut self);
}

对于离开作用域的情况下，销毁遵循先进后出（栈），即先声明的变量后销毁

编译器将阻止显式调用此 drop 方法，而应通过 std::mem::drop 函数进行间接调用

rust

pub fn drop<T>(_x: T)

`Rc<T>` 引用计数类型（reference counting），其数据可以有多个所有者

rust

fn print_type_of<T>(_: T) {
    println!("{}", std::any::type_name::<T>())
}
use std::rc::Rc;
fn main() {
    let x = ();
    let a = Rc::new(x);
    println!("count={}", Rc::strong_count(&a)); // count=1
    let b = Rc::clone(&a);
    println!("count={}", Rc::strong_count(&a)); // count=2
    let c = Rc::clone(&a);
    println!("count={}", Rc::strong_count(&a)); // count=3

    print_type_of(a); // alloc::rc::Rc<()>
    print_type_of(*b); // ()
    print_type_of(&c); // &alloc::rc::Rc<()>
}

strong_count 方法返回指向此分配的强 (Rc) 指针的数量。

rust

fn main() {
    let x = ();
    let a = Rc::new(x);
    println!("count={}", Rc::strong_count(&a)); // count=1
    {
        let b = Rc::clone(&a);
        println!("count={}", Rc::strong_count(&a)); // count=2
    }// 在这里，指针 b 失效
    let c = Rc::clone(&a);
    println!("count={}", Rc::strong_count(&a)); // count=2
}

`Ref<T>` 和 `RefMut<T>`智能指针，通过 `RefCell<T>` 实现内部可变性

RefCell 允许在在运行时借用，无论数据本身是否可以被借用（或者说，即使本身无法被借用）
运行时意味着如果出错将发生 panic（编译时的错误导致编译不通过）

Ref<T> 和 RefMut<T> 是智能指针，实现了 Deref trait

不过，RefCell 也同样遵循借用规则，即相同作用域中要么只能有一个可变引用，要么只能有多个不可变引用

rust

use std::cell::*;
#[derive(Debug)]
struct Int(i32);
fn main() {
    let x = Int(0);
    let a: RefCell<Int> = RefCell::new(x);
    println!("{:?}", a); // RefCell { value: Int(0) }
    {
        let b: Ref<Int> = a.borrow(); // 不可变地借用
        println!("{:?}", b); // Int(0)
    }
    {
        let mut c: RefMut<Int> = a.borrow_mut(); // 可变地借用，这里因为手动修改所以还添加了 mut
        println!("{:?}", c); // Int(0)
        c.0 = 1; // 本来是无法修改的，通过 RefCell 修改
        println!("{:?}", c); // Int(1)
    }
}

原子引用计数 `Arc<T>`

Rc<T> 非线程安全，Arc<T> 是 Rc<T> 的线程安全版本，适合在多线程环境下使用，API 一致。

互斥器 `Mutex<T>`

在 rust 中，加锁之后无需手动释放，因为当锁离开作用域时就会自动释放。

rust

use std::sync::Mutex;

fn main() {
    let m = Mutex::new(5); // 互斥锁是一个智能指针

    {
        let mut num = m.lock().unwrap(); // 获取锁
        *num = 6;
    }// 释放锁

    println!("m = {:?}", m);
}

在多个线程中使用同一个锁时，还需要使用 Arc<T> 以便在不同的线程中都能取得同一个锁

rust

use std::sync::{Mutex, Arc};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0)); // 通过 Arc 共享该锁
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter); // 每个线程获取 Arc 的克隆
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();

            *num += 1; // Mutex 和 Arc 都是智能指针
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

`Weak<T>` 避免引用循环

引用循环，参见：https://www.rustwiki.org.cn/zh-CN/book/ch15-06-reference-cycles.html

`Cell<T>` 实现内部可变性

参见：https://www.rustwiki.org.cn/zh-CN/std/cell/struct.Cell.html

`UnsafeCell<T>`

参见：https://www.rustwiki.org.cn/zh-CN/std/cell/struct.UnsafeCell.html

`Cow`

参见：https://www.rustwiki.org.cn/zh-CN/alloc/borrow/enum.Cow.html

rust

pub enum Cow<'a, B: ?Sized + 'a>
where
    B: ToOwned,
 {
    Borrowed(&'a B),
    Owned(<B as ToOwned>::Owned),
}

←Back to home