Rust智能指针

作者: 黑天鹅学院 | 来源:发表于2021-07-31 18:09 被阅读0次

Rust for cpp devs - 智能指针
rust中的智能指针Box
Rust智能指针
【RUST_BASIC】Rust 智能指针
Rust标准库
[Rust]指针
Rust入坑指南：智能指针
目录
C/C++转Rust的项目实践总结 1-5
Rust编程语言-15-智能指针

智能指针

在C/C++中，堆内存的申请和释放都由程序员自己管理，自C++11起，引入了智能指针来协助管理内存。对于编译器来说，智能指针实际上是一个栈对象，并非指针类型，在栈对象的生命周期即将结束时，通过析构函数释放由它管理的堆内存，典型用法比如shared_ptr、unique_ptr。

在Rust中，由于每一个对象均有其对应的所有权，所以当出现对象共享时，就会有可能出现所有权竞争问题了，为了解决这些问题，Rust引入了智能指针的概念。由于Rust禁止了共享指针访问，在共享访问的场景，使用智能指针可以在编译阶段就可以跟踪对象的所有权，从而在安全的基础上提供了编程的便利性。

智能指针是Rust中一种特殊的数据结构，与普通指针主要目的是借用对象的值不同，智能指针通常拥有对象的所有权。

简单示例如下：

fn main() {
    let x: i32 = 2021;
    let y = Box::new(x);

    assert_eq!(2021, x);
    assert_eq!(2021, *y);
}

y通过Box封装了一个i32的变量，y是一个栈上的指针，这个指针的生命周期与所有权遵循常规变量。

另一个常见的智能指针是Rc：

use std::rc::Rc;
fn main() {
    let x = Rc::new("hello, world");
    println!("{:?}", x.chars());
}

Rc指针封装了一个字符串，并且封装之后，可以将x视为一个字符串进行操作。

Rc的实现源码如下：

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> Deref for Rc<T> {
    type Target = T;

    #[inline(always)]
    fn deref(&self) -> &T {
        &self.inner().value
    }
}

从Rc源码可以看出，Rc并没有实现字符串相关的方法，但是通过deref方法直接使用了其包裹对象的方法，使得智能指针在使用时被自动解引用，像是不存在一样。

Deref

实现自动解引用的关键是Deref，如果一个类型T实现了Deref，则该类型T的引用或者智能指针在应用的时候会被自动转换为类型U，这个特性被称为强制隐式转换。

Deref的内部实现源码如下：

#[lang = "deref"]
#[stable(feature = "rust1", since = "1.0.0")]
pub trait Deref {
    /// The resulting type after dereferencing.
    #[stable(feature = "rust1", since = "1.0.0")]
    type Target: ?Sized;

    /// Dereferences the value.
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    fn deref(&self) -> &Self::Target;
}

#[lang = "deref_mut"]
#[stable(feature = "rust1", since = "1.0.0")]
pub trait DerefMut: Deref {
    /// Mutably dereferences the value.
    #[stable(feature = "rust1", since = "1.0.0")]
    fn deref_mut(&mut self) -> &mut Self::Target;
}

DerefMut和Deref类似，区别是返回可变引用。

在明确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 boxprint(name: &str) {
    println!("Hello {}", name);
}

fn main() {
    let x = 2021;
    let y = MyBox::new(x);

    assert_eq!(2021, x);
    assert_eq!(2021, *y);

    let m = MyBox::new(String::from("Rust"));
    boxprint(&m);
}

Drop

智能指针可以通过实现Drop来自动执行清理工作，Drop内部实现如下：

#[lang = "drop"]
#[stable(feature = "rust1", since = "1.0.0")]
pub trait Drop {
    #[stable(feature = "rust1", since = "1.0.0")]
    fn drop(&mut self);
}

示例如下：

use std::ops::Drop;

#[derive(Debug)]
struct S(i32);

impl Drop for S {
    fn drop(&mut self) {
        println!("drop {}", self.0);
    }
}

fn main() {
    let x = S(2018);
    println!("create x: {:?}", x);
    {
        let y = S(2021);
        println!("create y: {:?}", y);
    }
}

结合Deref与Drop，就可以实现更加复杂的智能指针了。