rust内存管理std::mem模块

说起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、栈和堆