一、Rust 智能指針詳解

智能指針是Rust中管理內(nèi)存和所有權(quán)的核心工具，通過封裝指針并添加元數(shù)據(jù)（如引用計數(shù)）來實現(xiàn)安全的內(nèi)存管理。以下是主要類型及其原理、使用場景和示例：

1、Box<T>：堆內(nèi)存分配

• 原理：在堆上分配內(nèi)存，棧中存儲指向堆的指針。所有權(quán)唯一，離開作用域時自動釋放內(nèi)存。
• 使用場景：
  • 編譯時未知大小的類型（如遞歸類型）
  • 轉(zhuǎn)移大數(shù)據(jù)所有權(quán)避免拷貝
  • 特質(zhì)對象（Trait Object）的動態(tài)分發(fā)
• 示例：

  fn main() {
      let b = Box::new(5); // 在堆上存儲整數(shù)5
      println!("b = {}", b); // 輸出: b = 5
  } // 離開作用域，堆內(nèi)存自動釋放
  

2、Rc<T>：引用計數(shù)指針

• 原理：通過引用計數(shù)跟蹤值的所有者數(shù)量。當(dāng)計數(shù)歸零時自動釋放內(nèi)存。僅適用于單線程。
• 使用場景：多個部分只讀共享數(shù)據(jù)（如圖結(jié)構(gòu)、共享配置）。
• 示例：

  use std::rc::Rc;
  fn main() {
      let a = Rc::new(10);
      let b = Rc::clone(&a); // 引用計數(shù)+1
      println!("Count: {}", Rc::strong_count(&a)); // 輸出: Count: 2
  } // 離開作用域，計數(shù)歸零，內(nèi)存釋放
  

3、RefCell<T>：內(nèi)部可變性

• 原理：在運行時檢查借用規(guī)則（而非編譯時），允許通過不可變引用修改內(nèi)部數(shù)據(jù)。使用borrow()和borrow_mut()訪問。
• 使用場景：需要修改只讀共享數(shù)據(jù)時（如緩存更新）。
• 示例：

  use std::cell::RefCell;
  fn main() {
      let c = RefCell::new(42);
      *c.borrow_mut() += 1; // 運行時借用檢查
      println!("c = {}", c.borrow()); // 輸出: c = 43
  }
  

4、Arc<T>：原子引用計數(shù)

• 原理：類似Rc<T>，但使用原子操作保證線程安全。性能略低于Rc。
• 使用場景：多線程共享數(shù)據(jù)（需配合Mutex）。
• 示例：

  use std::sync::Arc;
  use std::thread;
  fn main() {
      let val = Arc::new(100);
      let handle = thread::spawn(move || {
          println!("Thread: {}", val); // 安全共享
      });
      handle.join().unwrap();
  }
  

5、Mutex<T>與RwLock<T>：線程同步

• Mutex<T>：互斥鎖，一次僅允許一個線程訪問數(shù)據(jù)。

  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; // 修改受保護(hù)數(shù)據(jù)
          });
          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(); // 多個讀取并發(fā)
      let r2 = lock.read().unwrap();
  }
  {
      let mut w = lock.write().unwrap(); // 獨占寫入
      *w += 1;
  }
  

6、Weak<T>：解決循環(huán)引用

• 原理：Weak 是 Rc 的非擁有智能指針，它不增加引用計數(shù)。
• 使用場景：用于解決循環(huán)引用問題
• 示例：

  use std::rc::{Rc, Weak};
  use std::cell::RefCell;
  
  // 定義節(jié)點結(jié)構(gòu)
  struct Node {
      value: i32,
      parent: RefCell<Weak<Node>>, // 使用 Weak 避免循環(huán)引用
      children: RefCell<Vec<Rc<Node>>>, // 子節(jié)點使用 Rc
  }
  
  fn main() {
      // 創(chuàng)建葉子節(jié)點
      let leaf = Rc::new(Node {
          value: 3,
          parent: RefCell::new(Weak::new()),
          children: RefCell::new(vec![]),
      });
  
      // 創(chuàng)建分支節(jié)點，并設(shè)置 leaf 為其子節(jié)點
      let branch = Rc::new(Node {
          value: 5,
          parent: RefCell::new(Weak::new()),
          children: RefCell::new(vec![Rc::clone(&leaf)]),
      });
  
      // 設(shè)置 leaf 的父節(jié)點為 branch（使用 downgrade 創(chuàng)建弱引用）
      *leaf.parent.borrow_mut() = Rc::downgrade(&branch);
  
      // 嘗試升級 leaf 的父節(jié)點
      if let Some(parent) = leaf.parent.borrow().upgrade() {
          println!("Leaf 的父節(jié)點值: {}", parent.value); // 輸出: Leaf 的父節(jié)點值: 5
      } else {
          println!("父節(jié)點已被釋放");
      }
  
      // 當(dāng) branch 被丟棄時，leaf 的 parent 升級會失敗
  }
  
  

7、組合模式

• Rc<RefCell<T>>：單線程內(nèi)共享可變數(shù)據(jù)。

  let shared_data = Rc::new(RefCell::new(vec![1, 2]));
  shared_data.borrow_mut().push(3); // 修改共享數(shù)據(jù)
  

• Arc<Mutex<T>>：多線程共享可變數(shù)據(jù)（最常見組合）。

  let data = Arc::new(Mutex::new(0));
  // 多線程修改數(shù)據(jù)（見上文Mutex示例）
  

8、對比總結(jié)

二、Rust 智能指針示例

以下是一個復(fù)雜的 Rust 智能指針示例，結(jié)合了 Rc、RefCell 和自定義智能指針，模擬圖形渲染場景中的資源管理：

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

// 自定義智能指針：帶引用計數(shù)的紋理資源
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 get_id(&self) -> u32 {
        self.0.id
    }
}

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

// 場景節(jié)點：支持父子關(guān)系
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() {
    // 創(chuàng)建共享紋理資源
    let shared_texture = TextureHandle::new(Texture::new(101, 1024));
    
    // 創(chuàng)建場景節(jié)點
    let root = SceneNode::new("Root");
    let camera = SceneNode::new("Camera");
    let mesh1 = SceneNode::new("Mesh1");
    let mesh2 = SceneNode::new("Mesh2");
    
    // 設(shè)置紋理
    {
        let mut root_mut = root.borrow_mut();
        root_mut.set_texture(shared_texture);
    }
    
    // 構(gòu)建場景層級
    SceneNode::add_child(&root, &camera);
    SceneNode::add_child(&root, &mesh1);
    SceneNode::add_child(&mesh1, &mesh2);
    
    // 打印場景樹
    root.borrow().print_tree(0);
    
    // 驗證引用計數(shù)
    println!("\nReference counts:");
    println!("Root strong: {}", Rc::strong_count(&root));
    println!("Root weak: {}", Rc::weak_count(&root));
}

示例解析：

1. 自定義智能指針 TextureHandle

   • 包裝 Rc<Texture> 實現(xiàn)資源共享
   • 實現(xiàn) Deref 獲得透明訪問
   • 提供資源 ID 訪問方法

2. 場景圖管理 SceneNode

   • 使用 Rc<RefCell<SceneNode>> 實現(xiàn)共享所有權(quán)和內(nèi)部可變性
   • 子節(jié)點列表：RefCell<Vec<Rc<...>>> 實現(xiàn)運行時可變借用
   • 父節(jié)點：RefCell<Weak<...>> 避免循環(huán)引用

3. 資源共享機(jī)制

   • 紋理資源通過 TextureHandle 共享
   • 節(jié)點樹通過 Rc 共享所有權(quán)
   • 使用 Weak 引用打破循環(huán)依賴

4. 輸出示例：

Root
Texture ID: 101
  Camera
  Mesh1
    Mesh2

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

關(guān)鍵特性：

1. 內(nèi)存安全：自動管理資源釋放
2. 內(nèi)部可變性：通過 RefCell 修改不可變引用
3. 循環(huán)引用防護(hù)：Weak 指針避免內(nèi)存泄漏
4. 透明訪問：通過 Deref 實現(xiàn)直接訪問
5. 運行時借用檢查：RefCell 在運行時驗證借用規(guī)則

到此這篇關(guān)于Rust 智能指針的使用詳解的文章就介紹到這了,更多相關(guān)Rust 智能指針內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！