Rust进阶[part1]_智能指针概述&box指针

智能指针概述

在Rust中，智能指针是一类特殊的数据结构，它们不仅像普通指针一样可以引用数据，还带有额外的元数据和功能。与普通指针不同，智能指针通常使用结构体实现，并且会实现 Deref 和 Drop 等特定的trait，以提供更强大的功能和更安全的内存管理。

智能指针在Rust编程中扮演着重要的角色，它们能够帮助开发者处理复杂的内存管理场景，确保程序的安全性和性能。例如，在处理动态大小的数据、递归数据结构或者需要自定义资源释放逻辑时，智能指针就显得尤为重要。

Box指针

内存分配到堆上

在Rust中，栈内存的分配和释放是自动且高效的，但栈空间是有限的。对于一些大型的数据结构或者需要在运行时动态确定大小的数据，将其存储在栈上可能会导致栈溢出。这时，我们可以使用 Box 指针将数据分配到堆上。

Box 是Rust标准库中最基本的智能指针之一，它允许我们在堆上分配内存，并将数据存储在其中。通过 Box 指针，我们可以在栈上存储一个指向堆上数据的引用，从而实现对堆上数据的访问。

以下是一个简单的示例，展示了如何使用 Box 将一个整数分配到堆上：

fn main() {
    let boxed_int = Box::new(42);
    println!("The value inside the box is: {}", *boxed_int);
}

在这个示例中，Box::new(42) 创建了一个 Box 指针，它指向堆上存储的整数 42。

通过解引用运算符 *，我们可以访问堆上的数据。

允许处理动态大小类型（DST）

Rust中的动态大小类型（DST）是指在编译时无法确定大小的数据类型，例如切片（[T]）和特征对象（dyn Trait）。

由于栈上的内存分配需要在编译时确定大小，因此无法直接将DST存储在栈上。而 Box 指针可以用于存储DST，因为它会在堆上分配内存，从而避免了栈上内存分配的限制。

以下是一个使用 Box 存储切片的示例：

fn main() {
    let slice: &[i32] = &[1, 2, 3];
    let boxed_slice: Box<[i32]> = Box::from(slice);
    println!("The boxed slice contains: {:?}", boxed_slice);
}

在这个示例中，我们首先创建了一个切片 slice，然后使用 Box::from 方法将其转换为 Box<[i32]> 类型，从而将切片存储在堆上。

// 允许处理动态大小类型，比如结构体和元组
let boxed_tuple = Box::new((String::from("hello"), 5));
println!("Boxed tuple: {:?}", boxed_tuple);

递归数据结构

递归数据结构是指包含自身类型的成员的结构体或枚举。由于递归数据结构的大小在编译时无法确定，因此无法直接将其存储在栈上。Box 指针可以用于解决这个问题，通过在递归数据结构中使用 Box 指针，我们可以将递归成员存储在堆上，从而避免栈溢出的问题。

以下是一个使用 Box 实现链表节点的示例：

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

fn main() {
    let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
    println!("The list is: {:?}", list);
}

在这个示例中，List 枚举表示一个链表，其中 Cons 变体包含一个整数和一个指向另一个 List 节点的 Box 指针。通过使用 Box 指针，我们可以创建一个递归的链表结构。

类型擦除

类型擦除是指在编译时隐藏具体的类型信息，只保留类型的共性。在Rust中，我们可以使用 Box<dyn Trait> 来实现类型擦除。Box<dyn Trait> 是一个特征对象，它可以存储任何实现了指定特征的类型的值。

以下是一个使用 Box<dyn Trait> 实现类型擦除的示例：

trait Draw {
    fn draw(&self);
}

struct Circle;
impl Draw for Circle {
    fn draw(&self) {
        println!("Drawing a circle");
    }
}

struct Square;
impl Draw for Square {
    fn draw(&self) {
        println!("Drawing a square");
    }
}

fn main() {
    let shapes: Vec<Box<dyn Draw>> = vec![
        Box::new(Circle),
        Box::new(Square),
    ];

    for shape in shapes {
        shape.draw();
    }
}

在这个示例中，我们定义了一个 Draw 特征，并为 Circle 和 Square 结构体实现了该特征。然后，我们创建了一个 Vec<Box<dyn Draw>> 类型的向量，其中存储了 Circle 和 Square 的实例。通过使用 Box<dyn Draw>，我们实现了类型擦除，使得向量可以存储不同类型的形状。

内存管理和性能优化

Box 指针在内存管理方面具有重要的作用。当 Box 指针离开作用域时，Rust会自动调用其 Drop 实现，从而释放堆上分配的内存。这种自动内存管理机制确保了内存的安全性，避免了内存泄漏的问题。

在性能方面，由于 Box 指针涉及到堆上的内存分配和释放，因此会比栈上的内存分配和释放稍微慢一些。但是，对于需要动态分配内存或者处理动态大小类型的场景，使用 Box 指针是必要的。在实际编程中，我们应该根据具体的需求和性能要求来选择合适的内存分配方式。

box的优缺点

优点

• 动态内存分配：允许在运行时动态分配内存，处理大型数据结构和动态大小类型。
• 递归数据结构支持：可以用于实现递归数据结构，避免栈溢出的问题。
• 类型擦除：支持类型擦除，使得代码更加灵活和可复用。
• 自动内存管理：Rust的所有权系统确保了 Box 指针离开作用域时，堆上的内存会被自动释放，避免了内存泄漏。

缺点

• 性能开销：堆上的内存分配和释放比栈上的内存分配和释放稍微慢一些，可能会影响性能。
• 额外的间接访问：使用 Box 指针需要通过指针进行间接访问，可能会增加一定的开销。

Drop Trait

Drop trait 用于自定义当值离开作用域时执行的代码，通常用于释放资源，例如内存、文件句柄、网络连接等。当一个实现了 Drop trait 的值离开作用域时，Rust会自动调用其 drop 方法。

以下是一个简单的示例，展示了如何实现 Drop trait：

struct CustomSmartPointer {
    data: String,
}

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

fn main() {
    let c = CustomSmartPointer { data: String::from("my stuff") };
    let d = CustomSmartPointer { data: String::from("other stuff") };
    println!("CustomSmartPointers created.");
}

在这个示例中，我们定义了一个 CustomSmartPointer 结构体，并为其实现了 Drop trait。当 c 和 d 离开作用域时，Rust会自动调用它们的 drop 方法，打印出相应的信息。

Deref Trait

Deref trait 用于重载解引用运算符（*），允许我们自定义指针类型的解引用行为。通过实现 Deref trait，我们可以让自定义的智能指针像普通指针一样使用解引用运算符。

Deref trait 定义了一个 deref 方法，该方法返回一个指向内部数据的引用。

以下是一个简单的示例，展示了如何实现 Deref trait：

use std::ops::Deref;

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) -> &Self::Target {
        &self.0
    }
}

fn main() {
    let x = 5;
    let y = MyBox::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

在这个示例中，我们定义了一个 MyBox 结构体，并为其实现了 Deref trait。通过实现 deref 方法，我们可以使用解引用运算符 * 来访问 MyBox 内部的数据。

练习

1. 创建一个大型数组并将其分配在堆上，然后测量和比较分配在堆和栈上的性能差异。

使用instant::now() ; 以及elapsed()

use std::time::Instant;

const ARRAY_SIZE: usize = 1000000;

fn main() {
    // 测量栈上分配的时间
    let start_stack = Instant::now();
    let _stack_array: [i32; ARRAY_SIZE] = [0; ARRAY_SIZE];
    let stack_duration = start_stack.elapsed();

    // 测量堆上分配的时间
    let start_heap = Instant::now();
    let _heap_array: Box<[i32]> = vec![0; ARRAY_SIZE].into_boxed_slice();
    let heap_duration = start_heap.elapsed();

    println!("Stack allocation time: {:?}", stack_duration);
    println!("Heap allocation time: {:?}", heap_duration);
}

2. 创建一个包含1_000_000个元素的数据，分别将其分配在堆和栈上。使用std::time::Instant来测量分配和访问时间。

use std::time::Instant;

const ELEMENT_COUNT: usize = 1_000_000;

fn main() {
    // 栈上分配
    let start_stack_alloc = Instant::now();
    let stack_data: [i32; ELEMENT_COUNT] = [0; ELEMENT_COUNT];
    let stack_alloc_time = start_stack_alloc.elapsed();

    let start_stack_access = Instant::now();
    for i in 0..ELEMENT_COUNT {
        let _ = stack_data[i];
    }
    let stack_access_time = start_stack_access.elapsed();

    // 堆上分配
    let start_heap_alloc = Instant::now();
    let heap_data: Box<[i32]> = vec![0; ELEMENT_COUNT].into_boxed_slice();
    let heap_alloc_time = start_heap_alloc.elapsed();

    let start_heap_access = Instant::now();
    for i in 0..ELEMENT_COUNT {
        let _ = heap_data[i];
    }
    let heap_access_time = start_heap_access.elapsed();

    println!("Stack allocation time: {:?}", stack_alloc_time);
    println!("Stack access time: {:?}", stack_access_time);
    println!("Heap allocation time: {:?}", heap_alloc_time);
    println!("Heap access time: {:?}", heap_access_time);
}

通过以上练习，我们可以更深入地了解 Box 指针在堆上分配内存的性能特点，以及与栈上分配的差异。

3. 实现一个简单的文件系统模拟

目标

实现一个简单的文件系统模拟，其中包含文件和文件夹的概念。文件夹可以包含文件和其他文件夹。使用 Box 来管理内存，并实现对文件系统的基本操作（如创建文件、创建文件夹、列出文件和文件夹）。

作业要求

1. 定义 FileSystem trait 和 Node 枚举

   • FileSystem trait 包含 create_file、create_folder 和 list_contents 方法。
   • Node 枚举包含 File 和 Folder 变体。

2. 实现 FolderNode 结构体

   • FolderNode 实现 FileSystem trait，包含 name 和 contents 字段。
   • 使用 Box 管理 contents 中的子节点。

3. 实现文件系统的基本操作

   • create_file 方法在文件夹中创建文件。
   • create_folder 方法在文件夹中创建子文件夹。
   • list_contents 方法列出文件夹的所有内容。

4. 测试文件系统的操作

   • 创建根文件夹并添加文件和文件夹。
   • 创建子文件夹并添加文件。
   • 列出文件夹的内容并输出文件系统结构。

提示

• 使用 Box 来管理 Folder 中的子节点。
• 使用递归方法来遍历和列出文件和文件夹的内容。
• 考虑使用 Vec 来存储文件夹的子节点。

/**
 * ---------------文件系统----------------------------
 */
// 节点枚举 用来区分文件夹还是文件，文件夹通过box包装来避免递归类型的大小歧义
// 定义 Node 枚举：包含文件（File）和文件夹（Folder）两种变体
#[derive(Debug)]
enum Node {
    File(String),            // 文件：存储文件名
    Folder(Box<FolderNode>), // 文件夹：存储 FolderNode 的 Box（避免递归结构的大小问题）
}

// 定义 FileSystem trait：包含文件系统的核心操作
trait FileSystem {
    fn create_file(&mut self, name: String); // 在当前文件夹创建文件
    fn create_folder(&mut self, name: String) -> &mut Self; // 在当前文件夹创建子文件夹（返回子文件夹引用以便链式操作）
    fn list_contents(&self, indent: &str); // 列出当前文件夹内容（带缩进，方便展示结构）
}

// 定义 FolderNode 结构体：表示文件夹节点
#[derive(Debug)]
struct FolderNode {
    name: String,        // 文件夹名称
    contents: Vec<Node>, // 存储子节点（文件或文件夹）
}

// 为 FolderNode 实现 FileSystem trait
impl FileSystem for FolderNode {
    // 1. 创建文件：向 contents 添加 File 节点
    fn create_file(&mut self, name: String) {
        self.contents.push(Node::File(name));
    }

    // 2. 创建子文件夹：向 contents 添加 Folder 节点，并返回子文件夹的可变引用
    fn create_folder(&mut self, name: String) -> &mut Self {
        // 新建子文件夹节点
        let new_folder = FolderNode {
            name: name.clone(),
            contents: Vec::new(),
        };
        // 将子文件夹包装为 Box 并加入 contents
        self.contents.push(Node::Folder(Box::new(new_folder)));

        // 找到刚添加的子文件夹并返回其可变引用（通过 last_mut 确保是最后一个元素）
        match self.contents.last_mut() {
            Some(Node::Folder(folder_box)) => &mut **folder_box,
            _ => panic!("创建文件夹失败：逻辑错误"), // 理论上不会触发
        }
    }

    // 3. 列出内容：递归遍历子节点，带缩进展示结构
    fn list_contents(&self, indent: &str) {
        // 打印当前文件夹名称
        println!("{}{}", indent, self.name);
        // 遍历子节点
        for node in &self.contents {
            match node {
                Node::File(file_name) => println!("{}{}", indent, file_name), // 打印文件
                Node::Folder(folder) => folder.list_contents(&format!("{}  ", indent)), // 递归打印子文件夹（增加缩进）
            }
        }
    }
}

// 测试代码：创建文件系统并执行操作
#[test]
fn test_file_system() {
    // 1. 创建根文件夹
    let mut root = FolderNode {
        name: "Root".to_string(),
        contents: Vec::new(),
    };

    // 2. 根文件夹操作：创建文件 + 子文件夹
    root.create_file("file1.txt".to_string()); // 根目录创建文件
    let mut sub1 = root.create_folder("sub1".to_string()); // 根目录创建子文件夹 sub1
    sub1.create_file("subfile1.txt".to_string()); // 在 sub1 中创建文件

    // 3. 子文件夹嵌套操作
    let mut sub2 = root.create_folder("sub2".to_string()); // 根目录创建子文件夹 sub2
    let mut subsub2 = sub2.create_folder("subsub2".to_string()); // 在 sub2 中创建子文件夹 subsub2
    subsub2.create_file("deepfile.txt".to_string()); // 在 subsub2 中创建文件

    // 4. 列出根文件夹内容（从空缩进开始）
    println!("文件系统结构：");
    root.list_contents("");
}