Rust 智能指针的使用详解

2025-09-25 00:50
文章标签 rust 详解 指针 智能 使用

本文主要是介绍Rust 智能指针的使用详解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《Rust智能指针的使用详解》Rust智能指针是内存管理核心工具,本文就来详细的介绍一下Rust智能指针（Box、Rc、RefCell、Arc、Mutex、RwLock、Weak）的原理与使用场景,...

一、Rust 智能指针详解

智能指针是Rust中管理内存和所有权的核心工具，通过封装指针并添加元数据（如引用计数）来实现安全的内存管理。以下是主要类型及其原理、使用场景和示例：

Rust 智能指针的使用详解

1、Box<T>：堆内存分配

  • 原理：在堆上分配内存，栈中存储指向堆的指针。所有权唯一，离开作用域时自动释放内存。
  • 使用场景：
    • 编译时未知大小的类型（如递归类型）
    • 转移大数据所有权避免拷贝
    • 特质对象（Trait Object）的动态分发
  • 示例：
    fn main() {
    let b = Box::new(5); // 在堆上存储整数5
    println!("b = {}", b); // 输出: b = 5
} // 离开作用域，堆内存自动释放

2、Rc<T>：引用计数指针

  • 原理：通过引用计数跟踪值的所有者数量。当计数归零时自动释放内存。仅适用于单线程。
  • 使用场景：多个部分只读共享数据（如图结构、共享配置）。
  • 示例：
    use std::rc::Rc;
fn main() {
    let a = Rc::new(10);
    let b = Rc::clone(&a); // 引用计数+1
    println!("Count: {}", Rc::strong_count(&a)); // 输出: Count: 2
} // 离开作用域，计数归零，内存释放

3、RefCell<T>：内部可变性

  • 原理：在运行时检查借用规则（而非编译时），允许通过不可变引用修改内部数据。使用borrow()和borrow_mut()访问。
  • 使用场景：需要修改只读共享数据时（如缓存更新）。
  • 示例：
    use std::cell::RefCell;
fn main() {
    let c = RefCell::new(42);
    *c.borrow_mut() += 1; // 运行时借用检查
    println!("c = {}", c.borrow()); // 输出: c = 43
}

4、Arc<T>：原子引用计数

  • 原理：类似Rc<T>，但使用原子操作保证线程安全。性能略低于Rc。
  • 使用场景：多线程共享数据（需配合Mutex）。
  • 示例：
    use std::sync::Arc;
use std::thread;
fn main() {
    let val = Arc::new(100);
    let handle = thread::spawn(move || {
        println!("ThreadChina编程: {}", val); // 安全共享
    });
    handle.join().unwrap();
}

5、Mutex<T>与RwLock<T>：线程同步

  • Mutex<T>：互斥锁，一次仅允许一个线程访问数据。 
    use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    for _ in 0..10 {
        let c = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = c.lock().unwrap();
            *num += 1; // 修改受保护数据
        });
        handles.push(handle);
    }
    for handle in handles { handle.join().unwrap(); }
    println!("Result: {}", *counter.lock().unwrap()); // 输出: Result: 10
}
  • RwLock<T>：读写锁，允许多个读取或单个写入。
    use std::sync::RwLock;
let lock = RwLock::new(5);
{
    let r1 = lock.read().unwrap(); // 多个读取并发
    let r2 = lock.read().unwrap();
}
{
    let mut w = lock.write().unwrap(); // 独占写入
    *w += 1;
}

6、Weak<T>：解决循环引用

  • 原理：Weak 是 Rc 的非拥有智能指针，它不增加引用计数。
  • 使用场景：用于解决循环引用问题
  • 示例：
    use std::rc::{Rc, Weak};
use std::cell::RefCell;

// 定义节点结构
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>, // 使用 Weak 避免循环引用
    children: RefCell<Vec<Rc<Node>>>, // 子节点使用 Rc
}

fn main() {
    // 创建叶子节点
    let leaf = Rc::new(Node {
        value: 3,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    // 创建分支节点，并设置 leaf 为其子节点
    let branch = Rc::new(Node {
        value: 5,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![Rc::clone(&leaf)]),
    });

    // 设置 leaf 的父节点为 branch（使用 downgrade 创建弱引用）
    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

    // 尝试升级 leaf 的父节点
    if let Some(parent) = leaf.parent.borrow().upgrade() {
        println!("Leaf 的父节点值: {}", parent.value); // 输出: Leaf 的父节点值: 5
    } else {
        println!("父节点已被释放");
    }

    // 当 branch 被丢弃时，leaf 的 parent 升级会失败
}

7、组合模式

  • Rc<RefCell<T>>：单线程内共享可变数据。 
    let shared_data = Rc::new(RefCell::new(vec![1, 2]));
shared_data.borrow_mut().push(3); // 修改共享数据
  • Arc<Mutex<T>>：多线程共享可变数据（最常见组合）。
    let data = Arc::new(Mutex::new(0));
// 多线程修改数据（见上文Mutex示例）

8、对比总结

类型线程安全可变性适用场景
Box<T>❌所有权唯一堆分配、递归类型
Rc<T>❌不可变共享单线程共享只读数据
RefCell<T>❌内部可变单线程运行时借用检查
Arc<T>✅不可变共享多线程共享只读数据
Mutex<T>✅线程安全可变多线程互斥修改数据
RwLock<T>✅读写分离读多写少场景

二、Rust 智能指针示例

以下是一个复杂的 Rust 智能指针示例，结合了 Rc、RefCell 和自定义智能指针，模拟图形渲染场景中的资源管理：

use std::rc::{Rc, Weak};
use std::cell::RefCell;
use std::ops::Deref;

// 自定义智能指针：带引用计数的纹理资源
struct Texture {
    id: u32,
    data: Vec<u8>,
}

impl Texture {
    fn new(id: u32, size: usize) -> Self {
        Texture {
            id,
            data: vec![0; size],
        }
    }
}

// 自定义智能指针：TextureHandle
struct TextureHandle(Rc<Texture>);

impl TextureHandle {
    fn new(texture: Texture) -> Self {
        TextureHandle(Rc::new(texture))
    }
    
    fn phpget_id(&self) -> u32 {
        self.0.id
    }
}

impl Deref for TextureHandle {
    type Target = Texture;
    
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

// 场景节点：支持父子关系
struct SceneNode {
    name: String,
    texture: Option<TextureHandle>,
    children: RefCell<Vec<Rc<RefCell<SceneNode>>>>,
    parent: RefCell<Weak<RefCell<SceneNode>>>,
}

impl SceneNode {
    fn new(name: &str) -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(SceneNode {
            name: name.to_string(),
            texture: None,
            children: RefCell::new(Vec::new()),
            parent: RefCell::new(Weak::new()),
        }))
    }
    
    fn add_child(parent: &Rc<RefCell<SceneNode>>, child: &Rc<RefCell<SceneNode>>) {
        child.borrow_mut().parent.replace(Rc::downgrade(parent));
        parent.borrow_mut().children.borrow_mut().push(Rc::clone(child));
    }
    
    fn set_texture(&mut self, texture: TextureHandle) {
        self.texture = Some(texture);
    }
    
    fn print_tree(&self, depth: usize) {
        let indent = "  ".repeat(depth);
        println!("{}{}", indent, self.name);
        if let Some(tex) = &self.texture {
            println!("{}Texture ID: {}", indent, tex.get_id());
        }
        for child in self.children.borrow().iter() {
            child.borrow().print_tree(depth + 1);
        }
    }
}

fn main() {
    // 创建共享纹理资源
    let shared_texture = TextureHandle::new(Texture::new(101, 1024));
    
    // 创建场景节点
    let root = SceneNode::new("Root");
    let camera = SceneNode::new("Camera");
    let mesh1 = SceneNode::new("Mesh1");
    let mesh2 = SceneNode::new("Mesh2");
    
    // 设置纹理
    {
        let mut root_mut = root.borrow_mut();
        root_mut.set_texture(shared_texture);
    }
    
    // 构建场景层级
    SceneNode::add_child(&root, &camera);
    SceneNode::add_child(&root, &mesh1);
    SceneNode::add_child(&mesh1, &mesh2);
    
    // 打印场景树
    root.borrow().print_tree(0);
    
    // http://www.chinasem.cn验证引用计数
    println!("\nReference counts:");
    println!("Root strong: {}", Rc::strong_count(&root));
    println!("Root weak: {}", Rc::weak_count(&root));
}

示例解析：

  1. 自定义智能指针 phpTextureHandle

    • 包装 Rc<Texture> 实现资源共享
    • 实现 Deref 获得透明访问
    • 提供资源 ID 访问方法

  2. 场景图管理 SceneNode

    • 使用 Rc<RefCell<SceneNode>> 实现共享所有权和内部可变性
    • 子节点列表：RefCell<Vec<Rc<...>>> 实现运行时可变借用
    • 父节点：RefCell<Weak<...>> 避免循环引用

  3. 资源共享机制

    • 纹理资源通过 TextureHandle 共享
    • 节点树通过 Rc 共享所有权
    • 使用 Weak 引用打破循环依赖

  4. 输出示例：

Root
Texture ID: 101
  Camera
  Mesh1
    Mesh2

Reference counts:
Root strong: 1
Root weak: 2
PS G:\Learning\Rust\ttt>

Rust 智能指针的使用详解

关键特性：

  1. 内存安全：自动管理资源释放
  2. 内部可变性：通过 RefCell 修改不可变引用
  3. 循环引用防护：Weak 指针避免内存泄漏
  4. 透明访问：通过 Deref 实现直接访问
  5. 运行时借用检查：RefCell 在运行时验证借用规则

到此这篇关于Rust 智能指针的使用详解的文章就介绍到这了,更多相关Rust 智能指针内容请搜索China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程China编程(www.chinasem.cn)！

这篇关于Rust 智能指针的使用详解的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1156015。

相关文章

Java抽象类Abstract Class示例代码详解

Java抽象类Abstract Class示例代码详解

《Java抽象类AbstractClass示例代码详解》Java中的抽象类（AbstractClass）是面向对象编程中的重要概念,它通过abstract关键字声明,用于定义一组相关类的公共行为和属... 目录一、抽象类的定义1. 语法格式2. 核心特征二、抽象类的核心用途1. 定义公共接口2. 提供默认实
阅读更多...
Java中的堆和栈示例详解

Java中的堆和栈示例详解

《Java中的堆和栈示例详解》在Java中,堆（Heap）和栈（Stack）是两种不同的内存区域,本文给大家介绍Java中的堆和栈,结合实例代码给大家介绍的非常详细,感兴趣的朋友一起看看吧... 目录一、前言二、栈（Stack）三、堆（Heap）四、核心区别五、代码示例六、常见问题七、总结一、前言在Jav
阅读更多...
Java Docx4j类库简介及使用示例详解

Java Docx4j类库简介及使用示例详解

《JavaDocx4j类库简介及使用示例详解》Docx4j是一个强大而灵活的Java库,非常适合需要自动化生成、处理、转换MicrosoftOffice文档的服务器端或后端应用,本文给大家介绍Jav... 目录1.简介2.安装与依赖3.基础用法示例3.1 创建一个新 DOCX 并添加内容3.2 读取一个已存
阅读更多...
C#使用iText获取PDF的trailer数据的代码示例

C#使用iText获取PDF的trailer数据的代码示例

《C#使用iText获取PDF的trailer数据的代码示例》开发程序debug的时候,看到了PDF有个trailer数据,挺有意思,于是考虑用代码把它读出来,那么就用到我们常用的iText框架了,所... 目录引言iText 核心概念C# 代码示例步骤 1: 确保已安装 iText步骤 2: C# 代码程
阅读更多...
python pymodbus模块的具体使用

python pymodbus模块的具体使用

《pythonpymodbus模块的具体使用》pymodbus是一个Python实现的Modbus协议库,支持TCP和RTU通信模式,支持读写线圈、离散输入、保持寄存器等数据类型,具有一定的参考价值... 目录一、详解1、 基础概念2、核心功能3、安装与设置4、使用示例5、 高级特性6、注意事项二、代码示例
阅读更多...
一个Java的main方法在JVM中的执行流程示例详解

一个Java的main方法在JVM中的执行流程示例详解

《一个Java的main方法在JVM中的执行流程示例详解》main方法是Java程序的入口点,程序从这里开始执行,：本文主要介绍一个Java的main方法在JVM中执行流程的相关资料,文中通过代码... 目录第一阶段：加载 (Loading)第二阶段：链接 (Linking)第三阶段：初始化 (Initia
阅读更多...
使用Node.js和PostgreSQL构建数据库应用

使用Node.js和PostgreSQL构建数据库应用

《使用Node.js和PostgreSQL构建数据库应用》PostgreSQL是一个功能强大的开源关系型数据库,而Node.js是构建高效网络应用的理想平台,结合这两个技术,我们可以创建出色的数据驱动... 目录初始化项目与安装依赖建立数据库连接执行CRUD操作查询数据插入数据更新数据删除数据完整示例与最佳
阅读更多...
Java 日志中 Marker 的使用示例详解

Java 日志中 Marker 的使用示例详解

《Java日志中Marker的使用示例详解》Marker是SLF4J（以及Logback、Log4j2）提供的一个接口,它本质上是一个命名对象,你可以把它想象成一个可以附加到日志语句上的标签或戳... 目录什么是Marker？为什么使用Markejavascriptr？1. 精细化的过滤2. 触发特定操作3
阅读更多...
Linux五种IO模型的使用解读

Linux五种IO模型的使用解读

《Linux五种IO模型的使用解读》文章系统解析了Linux的五种IO模型（阻塞、非阻塞、IO复用、信号驱动、异步）,重点区分同步与异步IO的本质差异,强调同步由用户发起,异步由内核触发,通过对比各模... 目录1.IO模型简介2.五种IO模型2.1 IO模型分析方法2.2 阻塞IO2.3 非阻塞IO2.4
阅读更多...
Python实现简单封装网络请求的示例详解

Python实现简单封装网络请求的示例详解

《Python实现简单封装网络请求的示例详解》这篇文章主要为大家详细介绍了Python实现简单封装网络请求的相关知识,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录安装依赖核心功能说明1. 类与方法概览2.NetHelper类初始化参数3.ApiResponse类属性与方法使用实
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2