Rust权威指南之智能指针

最新推荐文章于 2025-07-08 10:34:31 发布
最新推荐文章于 2025-07-08 10:34:31 发布
阅读量1.4k 收藏 4
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Rust编程基础 文章标签： 智能指针 弱引用 强引用 读书笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhflyl/article/details/128260599

一. 简述

Rust中最常用的指针就是我们在第四章学习过的引用过。引用使用&符号表示的，会借用它所指向的值。智能指针则是一些数据结构，它们的行为类似于指针但拥有额外的元数据和附加功能。智能指针不是Rust所独有的。Rust标准库中不同的人智能指针提供了比引用更为强大的功能。

二. Box

Box是最为简单直接的一种智能指针，它的类型被写作Box<T>。Box使我们可以将数据存储在堆上，并在栈中保留一个指向堆数据的指针。

Box除了将它们的数据存储在堆上而不是栈上，Box没有任何其他的性能开销。

2.1. 使用场景

Box常常被用于下面的场景中：

  • 当我们拥有一个无法在编译时确定大小的类型，但是又想在一个要求固定尺寸的上下文环境中使用这个类型的值时；
  • 当我们需要传递大量数据的所有权，但是又不希望产生大量数据的复制行为时；
  • 当我们希望拥有一个实现了指定trait的类型值，但又不关心具体的类型时；

2.2. 存储数据

我们先看一下Box如何在堆上存储数据，下面的例子中定义了一个持有Box的值的变量data，它指向了堆上的值5。

let data= Box::new(5);
println!("box => {}", data); // box => 5

Box和其他任何拥有所有权的值一样，Box会在离开自己的作用域时被释放。Box被释放的东西除了有存储在栈上的指针，还有它指向的堆数据。

2.3. 存储递归数据

Rust必须在编译时知道每一种类型占据的空间大小，但有一种被称作递归的类型却无法在编译时确定大小。如下：

enum List {
    Cons(i32, List),
    Nil,
}

此时编译器会报如下错误：recursive type List has infinite size。如果你有其他的语言的编程基础的话，这就是一种比较常见的递归结构。但是由于Rust在编译时需要知道一种类型占据空间的大小，但是此时递归结构就无法确定类型的大小了。此时我们就可以通过Box修复这个问题，因为Box是大小可确定的。

#[derive(Debug)]
enum List {
    Cons(i32, Box<List>),
    Nil,
}
#[test]
fn box_cons() {
    let list = Cons(1,
        Box::new(Cons(2,
            Box::new(Cons(3,
                Box::new(Nil)
            ))
        ))
    );
    println!("{:?}", list); // Cons(1, Cons(2, Cons(3, Nil)))
}

三. Deref和Drop

上面的Box属于智能指针，是因为它实现了Deref，并允许我们将Box的值当作引用来对待。当一个Box值离开作用域时，因为它实现了Drop，所以Box指向堆数据会自动的被清理释放掉。

3.1. Deref将智能指针视作常规引用

实现Deref使我们可以自定义解引用运算符*的行为（这一符号也也同时被用作乘法运算符和通配符）。通过实现Deref，我们可以将智能指针视作常规引用来进行处理。

常规引用就是一种类型的指针。我们可以理解为一个箭头，它会指向存储在别处的某个值，下面看一个通过解引用运算符跟踪数据的值：

#[test]
fn deref_test() {
    let x = 5; // 变量x存储了i32的值5
    let y = &x; // 变量y中存储了x的引用
    assert_eq!(5, x);
    assert_eq!(5, *y); // 这里*y来跟踪引用并跳转到它指向的值（也就是解引用）
    assert_eq!(5, y); // ERROR 由于数值和引用是两种不同的类型
}

接着我们看一下Box的解引用，此时解引用运算符能够正常工作。

#[test]
fn deref_box_test() {
    let x = 5;
    let y = Box::new(x); // 变量y设置为了一个指向x值的装箱指针，而不是一个指向x值的引用
    assert_eq!(5, x);
    assert_eq!(5, *y); // 此处我们就可以使用解引用运算符来跟踪装箱指针，正如我们跟踪引用一样
}

此时解引用运算符可以使用是因为Box实现了Deref，标准库中的Deref要求我们现实一个deref方法，该方法会借用self并返回一个指向内部数据的引用。在没有Deref的情形下，编译器只能对&形式的常规引用执行解引用操作。deref方法使编译器可以从任何实现了Deref的类型中获取值，并能够调用deref方法来获取一个可以进行解引用操作的引用。上面例子中的*y会被Rust隐式地展开为：

*(y.deref())

Rust使用*运算符来替代deref方法和另一个朴素的解引用操作，这样我们就不用考虑是否需要调用deref方法了。

3.1.1. 自定义智能指针

下面我们实现一个自己的智能指针，实现deref方法，该方法会借用self并返回一个指向内部数据的引用。

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 // 在deref的方法体中填入&self.0，这意味着deref会返回一个指向值的引用，进而允许调用者通过*运算符访问值
    }
}
3.1.2. 函数和方法的隐式解引用转换

解引用转换是Rust为函数和方法的参数提供了一个种便携特性。当某个类型T实现了Deref，它能够将T的引用转换为T经过Deref操作后生成的引用。当我们将某个特定类型的值引用作为参数传递给函数或方法，但是传入的类型与参数类型不一致时，解引用转换就会自动发生。例子：

fn hello(name: &str) {
    println!("Hello, {}", name);
}

#[test]
fn test_hello() {
    let m = MyBox::new(String::from("Rust"));
    hello(&m); //  @1  Hello, Rust
    // hello(&(*m)[..]));  @2  没有解引用就需要这样写了
}

借助于解引用转换特性，我们这里可以将字符串切片作为参数传入hello函数，也可以将MyBox<String>值的引用传入hello函数。将参数&m传入hello函数，而&m正是一个指向MyBox<String>值的引用。因为MyBox实现了Deref，所有Rust可以通过deref来将&MyBox<String>转换为&String，标准库为String提供的Deref实现会返回字符串切片，所以Rust可以继续调用deref来将&String转换为&str，并最终与hello函数的定义相匹配。

如果Rust没有实现解引用转换功能，必须编写@1这样，首先*m将MyBox进行解引用得到String，然后通过&和[..]来获取包含整个String的字符串切片以匹配hello函数签名。整个过程代码编写非常不友好。

3.1.3. 解引用转换和可变性

使用Deref能够重载不可变引用的*运算符。与之类似，使用DerefMut能够重载可变引用的*运算符。Rust会在类型与trait满足一下三种情形时执行解引用转换：

  • 当T: Deref<Target=U>时，允许&T转换为&U；
  • 当T: DerefMut<Target=U>时，允许&mut T转换为&mut U；
  • 当T: Deref<Target=U>时，允许将&mut T转化为&U；

前两种情形除可变性之外是完全相同的。其中，情形一意味着，如果T实现了类型U的Deref，那么&T就可以直接转换为&U。情形二意味着，同样的解引用转换过程会作用于可变引用。

情形三则意味着，Rust会将一个可变引用自动转换为一个不可变的引用。但是这个过程中不可变引用永远不可能转换为可变引用。

3.2. Drop清理运行时代码

下面我们在介绍一个对于智能指针十分重要的trait就是Drop，它允许我们在变量离开作用域的时候执行某些自定义操作。我们可以为任意类型实现一个Drop，它常常被用来释放诸如文件、网络连接等资源。几乎每一种智能指针都会用到Drop。下面我们看一个例子：

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data: {}", self.data);
    }
}

#[test]
fn drop_test() {
    let a = CustomSmartPointer { data: String::from("hello") };
    let c = CustomSmartPointer { data: String::from("world") };
    println!("CustomSmartPointer Created");
}

当我们类型实例离开作用域时运行的逻辑都可以放在drop函数体内，Rust会自动调用我们在drop方法中放置的代码来打印出最终的信息，而无需显示地调用drop方法。编译执行输出：

CustomSmartPointer Created
Dropping CustomSmartPointer with data: world
Dropping CustomSmartPointer with data: hello

Rust在实例离开作用域时自动调用了我们编写的drop代码。因为变量的丢弃顺序与创建顺序相反，所有c在a之前被丢弃。

在Rust中我们是无法直接禁用自动drop功能，因为Drop存在就是为了完成自动释放的逻辑。但是我们倒是常常会碰到需要提前清理一个值的情形，例如使用智能指针来管理锁时，我们就需要强制运行drop方法来提前释放锁。此时我们就可以调用标准库中std::mem::drop函数来提前清理某个值。例子：

注意：我们是不能手动显示的调用Drop的drop方法。

#[test]
fn drop_test() {
    let a = CustomSmartPointer { data: String::from("hello world") };
    println!("CustomSmartPointer Created");
    drop(a);
    println!("CustomSmartPointer Drop after");
}

编译执行输出如下：说明在值离开作用域调用std::mem::drop来显式地丢弃它。

CustomSmartPointer Created
Dropping CustomSmartPointer with data: hello world // 调用的Drop的drop的方法
CustomSmartPointer Drop after

四. Rc/RefCell/Weak

4.1. 基于引用计数的智能指针Rc<T>

Rust提供了一个名为Rc<T>的类型来支持多重所有权，它名称中的Rc的缩写。Rc<T>类型的实例会在内部维护一个用于记录值引用次数的计数器，从而确认这个值是否仍在使用。如果对一个值的引用次数为零，那么就可以意味着这个值可以安全地清理掉，而不会触发引用失效的问题。

当你希望将堆上的一些数据分享给程序的多个部分同时使用，而无法在编译期确定哪个部分会最后释放这些数据时，我们就可以使用Rc<T>类型。相反地，如果我们能够在编译期确定那一部分会最后释放数据，那么就只需要让这部分代码称为数据的所有者即可，仅仅靠编译期的所有权规则也可以保证程序的正确性。例子：

注意： Rc<T>只能被用于单线程场景中。

use std::rc::Rc;

#[derive(Debug)]
enum List {
    Cons(i32, Rc<List>),
    Nil,
}

#[cfg(test)]
mod tests {
    use std::rc::Rc;
    use crate::List::{Cons, Nil};
    use super::*;

    #[test]
    fn link_test() {
        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));
    }
}

由于Rc<T>没有包含在预导入模块中，需要我们使用use语句将它引入作用域。上面例子调用Rc::clone不会执行数据的深拷贝操作，只会增加引用计数，并且这不会花费太多时间。深拷贝则常常需要花费大量时间来搬用数据。并且我们可以使用Rc::strong_count方法获取引用计数。上面例子输出结果：

count after creating a = 1
count after creating b = 2
count after creating c = 3
count after c goes out of scope = 2

当变量c离开作用域被丢弃时，引用计数为1。Rc<T>的Drop实现会在Rc<T>离开作用域时自动将引用计数减1。

4.2. RefCell<T>和内部可变性模式

内部可变性是Rust的设计模式之一，它允许你在只持有不可变引用的前提下对数据进行修改；通常情况下，类似的行为会被借用规则所禁止。内部可变性模式在它的数据结构中使用了unsafe代码来绕过Rust正常的可变性和借用规则。

在Rust的借用规则是这样的：在任何给定的时间里，要么只能拥有一个可变引用，要么只能拥有任意数量的不可变引用；引用总是有效的。对于一般引用和Box<T>的代码，Rust会在编译阶段强制代码准守这些借用规则。但是对于RefCell<T>的代码，Rust则只会在运行时检查这些规则，并在出现违反借用规则的情况下触发panic来提前终止程序。

将借用规则的检查放在编译期有许多优势：它不仅可以帮助我们在开发阶段尽早的暴露问题，而且不会带来任何运行时开销。

RefCell<T>也只能使用在单线程场景中。强行将它运用于多线程场景会产生编译错误。下面列举上一些Box、Rc或者RefCell选择依据：

  • Rc<T>允许一份数据有多个所有者，而Box<T>和RefCell<T>都只有一个所有者；
  • Box<T>允许在编译时检查的可变或不可变借用，Rc<T>仅允许编译时检查不可变借用，RefCell<T>允许运行时检查的可变和不可变借用；
  • 由于RefCell<T>允许我们在运行时检查可变借用，所以即便RefCell<T>本身是不可变的，我们仍然能够改变其中存储的值
4.2.1. RefCell修改不可变值

下面我们使用RefCell<T>修改不可变值的例子：

// 定义一个约束，其中有一个方法是send
trait Messenger {
    fn send(&self, msg: &str);
}
// 结构体属性包含对应Messenger约束的实现类型引用
struct LimitTracker<'a, T: 'a + Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T> where T: Messenger {
    fn new(messenger: &T, max: usize) -> LimitTracker<T> {
        LimitTracker {
            messenger,
            value: 0,
            max
        }
    }

    fn set_value(&mut self, value: usize) {
        self.value = value;
        let percentage_of_max = self.value as f64 / self.max as f64;
        // 条件判断send不同的值
        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger.send("Urgent Warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger.send("Warning: You've used up over 75% of your quota!");
        }
    }
}

下面我们在单元测试编写具体的Messenger约束的实现：

#[cfg(test)]
mod tests {
    use super::*;
    
    struct MockMessenger {
        sent_message: Vec<String>,
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger { sent_message: vec![] }
        }
    }
    // 实现Messenger,在send方法中添加字符串，这里涉及到需要修改sent_messenger
    impl Messenger for MockMessenger {
        fn send(&self, msg: &str) {
            self.sent_message.push(String::from(msg));
        }
    }

    #[test]
    fn send_message() {
        let messenger = MockMessenger::new();
        let mut tracker = LimitTracker::new(&messenger, 100);
        tracker.set_value(80);
        assert_eq!(messenger.sent_message.len(), 1);
    }
}

上面的例子很明显是无法编译通过的，这时因为我们在Messenger的约束中的send方法中的参数是&self，不可变引用；但是我们在send的具体实现中我们却需要一个可变引用去修改Vec中的数据。此时我们就可以使用RefCell<T>进行修改修复这个问题，实现既不用修改约束的定义还可以实现sent_message属性的修改。

#[cfg(test)]
mod tests {
    use super::*;
    
    struct MockMessenger {
        sent_message: RefCell<Vec<String>>, // @1
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger { sent_message: RefCell::new(vec![]) } // @2
        }
    }
    // 实现Messenger,在send方法中添加字符串，这里涉及到需要修改sent_messenger
    impl Messenger for MockMessenger {
        fn send(&self, msg: &str) {
            self.sent_message.borrow_mut().push(String::from(msg)); // @3
        }
    }

    #[test]
    fn send_message() {
        let messenger = MockMessenger::new();
        let mut tracker = LimitTracker::new(&messenger, 100);
        tracker.set_value(80);
        assert_eq!(messenger.sent_message.borrow().len(), 1); // @4
    }
}

上面代码中我们进行了4处修改，sent_message的类型修改为RefCell<Vec<String>>，在send具体实现中使用borrow_mut方法来获取RefCell<T>内部值的可变引用，此时我们就可以在动态数组中push字符串了。

4.2.2. RefCell详解

Rust中不可变和可变引用分别使用语法&和&mut；对应RefCell<T>而言，我们需要将borrow和borrow_mut方法来实现类似的功能，borrow和borrow_mut两个方法分别返回的是Ref<T>和RefMut<T>两种指针指针，它们都是实现了Deref，所有我们可以将它们当作一般引用来对待。

RefCell<T>会记录当前存在多少个活跃的Ref<T>和RefMut<T>智能指针。每次调用borrow方法，RefCell<T>会将活跃的不可变借用计数加1，并且在任何一个Ref<T>值离开作用域被释放时，不可变借用计数减1。RefCell<T>会基于这一技术来维护和编译器同样的借用检查规则：在任何一个给定的时间里，它只允许你拥有多个不可变借用或一个可变借用。

4.2.3. 实现一个拥有多重所有权的可变数据

将Rc<T>和RefCell<T>结合使用是一种很常见的用法。Rc<T>允许多个所有者持有同一个数据，但是只能提供对数据的不可变访问。如果我们在Rc<T>内存储RefCell<T>，就可以定义处拥有多个所有者且能够对值进行修改。

#[derive(Debug)]
enum List {
    // RefCell可义实现修改列表内数值的功能
    Cons(Rc<RefCell<i32>>, Rc<List>),
    Nil,
}

#[test]
fn link_test() {
    let value = Rc::new(RefCell::new(5));
    let a = Rc::new(
        Cons(
            Rc::clone(&value),
            Rc::new(Nil)
        )
    );
    let b = Rc::new(
        Cons(
            Rc::new(RefCell::new(6)),
            Rc::clone(&a)
        )
    );
    let c = Rc::new(
        Cons(
            Rc::new(RefCell::new(10)),
            Rc::clone(&a)
        )
    );
    // 修改值
    *value.borrow_mut() += 10;
}

在Rust的标准库中还有其他的一些类型来实现内部可变性，例如与RefCell<T>十分类似的Cell<T>，Cell<T>是通过复制来访问数据，还有后续章节中的Mutex<T>，它被用于实现跨线程情形下的内部可变性模式。

4.3. Weak<T>避免循环引用

Rust提供的内存安全保障是我们很难在程序中意外地制造出永远不会得到的释放的内存空间。但是这也不是不可能的。与数据竞争不同，在编译期彻底防止内存泄漏并不是Rust作出的保证之一，这也意味着内存泄漏在Rust中是一种内存安全行为。

4.3.1. 创建循环引用

我们可以通过使用Rc<T>和RefCell<T>看到Rust是允许内存泄漏的，我们能够创建出相互引用成环状的实例，由于环中每一个指针的引用计数都不会减少到0，所以对应的值也不会被释放丢弃，这就造成了内存泄漏。下面我们演示一个循环引用的例子。

我们先定一个枚举，并发实现一个tail方法用以获取元素：

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

#[derive(Debug)]
enum List {
    Cons(i32, RefCell<Rc<List>>),
    Nil,
}

impl List {
    fn tail(&self) -> Option<&RefCell<Rc<List>>> {
        match self {
            Cons(_, item) => Some(item),
            Nil => None
        }
    }
}

这里的RefCell<Rc<T>>类型，这可以让我们灵活修改Cons变体指向下一个List值。下面看下如何构建一个循环引用的情况（其实很简单，就是相当于环形链表一样）

#[cfg(test)]
mod tests {
    use std::borrow::BorrowMut;
    use super::*;

    #[test]
    fn loop_quote() {
        let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));
        let b = Rc::new(Cons(6, RefCell::new(Rc::clone(&a))));
        let c = Rc::new(Cons(7, RefCell::new(Rc::clone(&b))));
        if let Some(link) = a.tail() {
            *link.borrow_mut() = Rc::clone(&c)
        }
        assert_eq!(2, Rc::strong_count(&a));
        assert_eq!(2, Rc::strong_count(&b));
        assert_eq!(2, Rc::strong_count(&c));
        // println!("{:?}", a.tail()); 这里会因为循环引用发生栈溢出
    }
}

上面的例子我们实现了a、b和c的引用首尾相连的环，当此时因为首尾相连导致引用计数都不会是0，导致内存会永远以引用计数为1的状态保留在堆上。

一般来说解决循环引用的方案需要重新组织数据结构，它会将引用拆分为持有所有权和不持有所有权两种情形。

4.3.2. 使用Weak<T>替换Rc<T>

在上面的学习过程中，我们知道Rc::clone来增加Rc<T>实例的strong_count引用计数，并指出在strong_count为0时才会被清理。此时我们还可以通过Rc::downgrade函数创建出Rc<T>实例中值的弱引用。这个函数会返回一个类型为Weak<T>的智能指针，这一操作会让Rc<T>中的weak_count计数增加1，而不会改变strong_count的状态；并且Rc<T>在执行清理之前不会要求weak_count必须减为0。

强引用可以用来共享Rc<T>实例的所有权，而弱引用则不会表达所有权关系。一旦强引用计数减为0，任何由弱引用组成的循环就会被打破，所有弱引用不会造成循环引用。

注意：由于我们无法确认Weak<T>引用的值是否已经被释放了，所以我们在使用Weak<T>指向的值之前确保它仍然存在。此时我们可以调用Weak<T>实例上的upgrade方法来验证，该函数返回的是一个Option<Rc<T>>。

下面我们看一个创建树状数据结构的例子：

#[derive(Debug)]
struct Node {
    value: i32,
    // 父节点信息，我们这里使用RefCell包裹Weak弱引用，不持有父节点的所有权
    parent: RefCell<Weak<Node>>,
    // 子节点信息，使用RefCell可以修改节点的父子关系
    children: RefCell<Vec<Rc<Node>>>,
}

impl Node {
    fn new(value: i32) -> Self {
        Node {
            value,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(vec![]),
        }
    }
}

fn quote_info<T>(data: &Rc<T>) {
    println!("node => [strong: {}] : [weak: {}]", Rc::strong_count(data), Rc::weak_count(data));
}

接着我们创建几个节点构建一颗简单的树，并查看它的强弱引用数量：

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn weak_quote() {
        let left = Rc::new(Node::new(3));
        quote_info(&left); // node => [strong: 1] : [weak: 0]
        {
            let branch = Rc::new(Node {
                value: 5,
                parent: RefCell::new(Weak::new()),
                children: RefCell::new(vec![Rc::clone(&left)])
            });
            *left.parent.borrow_mut() = Rc::downgrade(&branch);
            quote_info(&branch); // node => [strong: 1] : [weak: 1]
            quote_info(&left); // node => [strong: 2] : [weak: 0]
        }
        quote_info(&left); // node => [strong: 1] : [weak: 0]
    }
}

测试结果很明显，就不做解释了。

理解 Rust 中的智能指针
分享身边生活经验blog
09-30 1022
智能指针是 抽象数据类型 ，在编程中类似于常规 指针 （存储值的内存地址的变量），并具有析构函数和重载运算符等附加功能。它们还包括自动内存管理，以解决内存泄漏等问题。当开发人员将包含动态分配数据的内存与智能指针链接时，它们会被自动取消分配或清理。一些智能指针用例包括：自动解除分配数据和销毁对象检查超出范围的数据或变量减少与使用常规指针相关的错误在取消分配数据后保持程序的效率跟踪程序数据/对象/变量的所有内存地址在程序应用程序中管理网络连接。
Rust权威指南配套手把手笔记
一个字，学
11-25 1420
Rust权威指南配套手把手笔记
Rust学习之智能指针
2301_79967122的博客
05-28 750
在 Rust 中，最常见的指针类型是引用,引用本身指向某个值，不会造成性能上的额外损耗。而智能指针比引用有更复杂的数据结构，包含比引用更多的信息，例如元数据，当前长度，最大可用长度等。引用和智能指针的另一个不同在于前者仅仅是借用了数据，而后者往往可以拥有它们指向的数据。智能指针往往是基于结构体实现，它与我们自定义的结构体最大的区别在于它实现了Deref和DropDeref*TDrop动态字符串String和动态数组可以将值分配到堆上）、Rc（引用计数类型，允许多所有权存在）、Ref和。
【智能指针】一文带你入门Rust 智能指针
分享Java，Rust相关技术
04-25 912
指针是一个包含内存地址的变量的通用概念。Rust中最常见的指针就是引用，使用作为标识，如&a，我们知道这是一个引用，指向a变量所表示的值。Rust中创建一个引用的行为称为借用borrowing那么智能指针又是什么呢？智能指针）是一类数据结构，它们的表现类似指针，但是也拥有额外的元数据和功能。智能指针的概念起源于C++，在C++中智能指针主要用于管理在堆上分配的内存，它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。
Rust——智能指针
JAN6055的博客
07-08 2071
Rust智能指针
rust智能指针
void的博客
09-29 797
Deref隐式转换将实现了Deref的类型的引用转换为另一种类型的引用。一种无法在编译时知道大小的类型是递归类型，其值的一部分可以是自身类型的另一个值。Deref trait使智能指针表现的像引用一样，这样就可以编写既用于引用、又用于智能指针的代码。每次使用 * 时， * 运算符都被替换成先调用deref方法再使用 * 解引用的操作，且只会发生一次，不会无限递归替换 * 操作符，解引用出i32类型的值就停止了。是一个指针，它的大小是确定的，所以将Box作为Cons的成员，这样List的大小就确定了。
Rust学习（七）：智能指针
2301_77286822的博客
11-20 1043
作为一种编程语言，Rust中最常见的指针类型就是引用，而引用只是一种普通指针，除引用数据之外，没有其他功能。为了更方便的处理复杂的结构数据，有必要在开始我们的算法之旅前，介绍Rust中智能指针的概率，当然，这里我们只会简单的介绍一些常用的智能指针，如果大家对此感到困惑，或者是想进一步深入的学习智能指针的设计哲学，建议阅读其Rust学习资料（doge）。智能指针是一种数据结构，其行为类似于指针，含有元数据，在大部分情况下拥有数据的所有权，提供内存管理或绑定等附加功能，如管理文件句柄和网络链接。
Rust参考手册 中文版（带完整目录）
06-13
2. **类型系统**：深入讨论Rust的类型系统，包括静态类型、枚举、结构体、元组、引用和智能指针。Rust的类型系统是其强大安全性的重要组成部分。 3. **函数和闭包**：讲解Rust中的函数定义、参数传递、返回值以及...
Rust从入门到精通
dhsiajsnwos的博客
07-27 818
基于rust2021最新版本；小白从入门到精通rust；推荐使用JetBrains 推出的IDEA工具RustRover。
C++智能指针终极指南：告别内存泄漏，实现安全编程（权威教程）
[C++智能指针终极指南：告别内存泄漏，实现安全编程（权威教程）](https://i0.hdslb.com/bfs/article/banner/ed39fa707dbc026398b15cd5ed09ef5c2e87935b.png) # 摘要 本文全面探讨了C++中智能指针的概念、核心原理...
深入浅出 Rust：2018 年权威编程指南
4. **智能指针**：如`Box`、`Rc`（引用计数）和`Arc`（原子引用计数），它们提供了垃圾回收机制的类似功能，但仍然保持了Rust的内存安全。 5. **结构体与枚举**：Rust中的自定义数据结构，包括结构体（记录）和枚举...
Rust 智能指针（一）
weixin_30381793的博客
03-30 270
Rust 智能指针（一） 1.Box<T> Box<T>是指向堆中的指针。 fn main() { let box = Box::new(3); println!("{}", box); } 在出了指针的作用域之后，指针和它指向的对象都将被释放。 在本例中，box将在main函数之后被释放。 由于Box<T>的大小是确定的(size类型...
Rust笔记之智能指针
陈某狗
11-15 886
Rust笔记之智能指针 一、定义 指针: 是一个包含内存地址的变量的通用概念。(Rust中最常见的指针就是引用&T） 智能指针：是一类数据结构，它们的表现类似指针，但也有额外的元数据和功能。 二、智能指针的类型 1. Box <T>    (1) box允许你将一个值放在堆上而不是栈上，留在栈上的则是指向堆数据的指针。   &n...
Rust 智能指针深入浅出
最新发布
萧曳丶
07-08 745
《Rust智能指针全面解析》摘要： Rust智能指针是管理内存的高级工具，兼具指针功能和额外管理能力。主要类型包括：Box<T>用于单一所有权堆分配；Rc<T>实现单线程引用计数共享；RefCell<T>提供内部可变性；Arc<T>支持线程安全共享；Mutex<T>确保线程间安全修改。智能指针通过Deref和Drop trait实现解引用和资源清理，可组合使用（如Rc<RefCell<T>>或Arc<Mutex<
Rust 程序设计语言学习——智能指针
洪伟的专栏
07-28 855
智能指针（smart pointers）是一类数据结构，它们的表现类似指针，但是也拥有额外的元数据和功能。智能指针的概念并不为 Rust 所独有；其起源于 C++ 并存在于其他语言中。Rust 标准库中定义了多种不同的智能指针，它们提供了多于引用的额外功能。
rust学习-智能指针
wangkai6666的博客
07-22 1243
rust智能指针学习
Rust自定义智能指针
weixin_30379531的博客
08-31 193
深了，真深了。 use std::ops::Deref; struct MyBox<T>(T); impl<T> MyBox<T> { fn new(x: T) -> MyBox<T> { MyBox(x) } } impl<T> Deref fo...
Rust入门（十一）：智能指针
weixin_46463785的博客
01-10 670
介绍了rust几种常见的只能指针
Rust中的Rc--引用计数智能指针
weixin_30379531的博客
08-31 757
大部分情况下所有权是非常明确的：可以准确的知道哪个变量拥有某个值。然而，有些情况单个值可能会有多个所有者。例如，在图数据结构中，多个边可能指向相同的结点，而这个结点从概念上讲为所有指向它的边所拥有。结点直到没有任何边指向它之前都不应该被清理。 为了启用多所有权，Rust 有一个叫做Rc<T>的类型。其名称为引用计数（reference counting）的缩写。引用计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值