説起rust內存管理，你會想到什麼呢？這部分可以先回想一下c語言的，也許會對你理解rust的標準庫中mem模塊有幫助。

std：：mem 模塊：Rust 標準庫中的該模塊提供低級別內存作和查詢類型及其內存佈局信息的功能這個模塊包含了一些“低級”（low-level）的函數，用於執行編譯器通常不會自動允許的操作。

使用 std::mem 中的函數通常需要謹慎，因為它們中的許多功能都涉及到底層內存操作，有時需要在 unsafe 塊中使用。

以下是 std::mem 模塊中幾個最重要和常用的函數：

1. std::mem::swap()

用於安全地交換兩個變量的值，而不需要進行昂貴的數據拷貝。

  • 作用： 將 &mut X 的值與 &mut Y 的值互換。
  • 示例：
let mut a = String::from("你好");
let mut b = String::from("世界");

println!("交換前：a={}, b={}", a, b);

std::mem::swap(&mut a, &mut b);

println!("交換後：a={}, b={}", a, b);

2. std::mem::replace()

用於替換一個可變引用指向的值，並返回舊的值。這個操作是原子性的。

  • 作用： 把 &mut T 指向的舊值取出，替換為傳入的新值，並返回舊值的所有權。
  • 示例： 當處理 Option 類型並需要取出內部值時非常有用。
let mut name = Some(String::from("Alice"));

// 將 name 中的值替換為 None，並將原來的 Some("Alice") 取出來賦值給 old_name
let old_name = std::mem::replace(&mut name, None);

println!("舊名字：{:?}", old_name); // Some("Alice")
println!("新名字狀態：{:?}", name);     // None

3. std::mem::take()

與 replace 類似，但它是一個更便捷的用於實現特定模式的函數：它用該類型的默認值替換原值，並返回原值。

  • 作用： 如果一個類型實現了 Default trait，take() 可以清空原變量並返回其內容。
  • 示例：
let mut vec = vec![1, 2, 3];

// 使用 take 取出 vec 的所有內容，並將 vec 替換為一個空的默認值 Vec::new()
let taken_vec = std::mem::take(&mut vec);

println!("取出的向量：{:?}", taken_vec); // [1, 2, 3]
println!("原向量：{:?}", vec);         // []

4. std::mem::size_of() 和 std::mem::size_of_val()

用於獲取類型或值在內存中佔用的字節大小（在編譯時確定）。可以參考本文第7節.

  • 作用： 報告類型或值的大小，對於調試內存佈局和優化 FFI（外部函數接口）很有用。
  • 示例：
use std::mem;

println!("i32 的大小（字節）：{}", mem::size_of::<i32>());      // 4
println!("usize 的大小（字節）：{}", mem::size_of::<usize>());    // 取決於架構（4或8）
println!("String 的大小（棧上）：{}", mem::size_of::<String>()); // 24（在64位系統上）

5. std::mem::drop()

用於提前顯式地釋放值所擁有的資源，早於其作用域結束的時間點。

  • 作用： 強制調用值的 Drop trait 實現。
  • 示例： 提前釋放互斥鎖，提高併發性。
let data = String::from("temporary data");
// ... 使用 data ...

std::mem::drop(data); // 立即釋放 data 資源
// 此時 data 已失效

6. std::mem::forget() （需要 unsafe）

這是一個危險但有用的函數。它阻止一個值運行其 Drop trait。

  • 作用： 將值“遺忘”，使其佔用的內存永遠不會被自動清理（直到程序結束），用於實現需要手動管理內存或防止雙重釋放的複雜內存安全抽象。幾乎不在日常代碼中使用。
  • 使用場景： 在複雜的 unsafe FFI 代碼或智能指針實現中。

 7. 與Box組合示例

use std::mem;

#[allow(dead_code)]
#[derive(Debug, Clone, Copy)]
struct Point {
    x: f64,
    y: f64,
}

// 可以通過指定左上角和右下角在空間中的位置來定義矩形
#[allow(dead_code)]
struct Rectangle {
    top_left: Point,
    bottom_right: Point,
}

fn origin() -> Point {
    Point { x: 0.0, y: 0.0 }
}

fn boxed_origin() -> Box<Point> {
    // 在堆上分配這個點，並返回指向它的指針
    Box::new(Point { x: 0.0, y: 0.0 })
}

fn main() {
    // （所有的類型標註都不是必須的）
    // 棧分配的變量
    let point: Point = origin();
    let rectangle: Rectangle = Rectangle {
        top_left: origin(),
        bottom_right: Point { x: 3.0, y: -4.0 }
    };

    // 堆分配的矩形
    let boxed_rectangle: Box<Rectangle> = Box::new(Rectangle {
        top_left: origin(),
        bottom_right: Point { x: 3.0, y: -4.0 },
    });

    // 函數的輸出可以被裝箱
    let boxed_point: Box<Point> = Box::new(origin());

    // 雙重間接引用
    let box_in_a_box: Box<Box<Point>> = Box::new(boxed_origin());

    println!("Point 在棧上佔用 {} 字節",
             mem::size_of_val(&point));
    println!("Rectangle 在棧上佔用 {} 字節",
             mem::size_of_val(&rectangle));

    // box 大小 == 指針大小
    println!("裝箱的 point 在棧上佔用 {} 字節",
             mem::size_of_val(&boxed_point));
    println!("裝箱的 rectangle 在棧上佔用 {} 字節",
             mem::size_of_val(&boxed_rectangle));
    println!("裝箱的 box 在棧上佔用 {} 字節",
             mem::size_of_val(&box_in_a_box));

    // 將 `boxed_point` 中的數據複製到 `unboxed_point`
    let unboxed_point: Point = *boxed_point;
    println!("未裝箱的 point 在棧上佔用 {} 字節",
             mem::size_of_val(&unboxed_point));
}

 

總結

std::mem 模塊是 Rust 提供的一組底層工具箱，它允許你對內存管理進行精細控制。雖然大部分 Rust 編程都在安全抽象下進行，但在需要高效交換數據、處理所有權轉移或進行 FFI 編程時，std::mem 是不可或缺的。 

參考資料：

1.rust智能指針Box

2. Box、棧和堆