Rust 模块的用法

在 Rust 中，模块（mod） 是组织代码的核心机制，用于管理作用域、隐私性和代码结构。以下是关于 Rust 模块系统的详细说明：

1. 模块基础

定义模块

使用 mod 关键字声明模块，模块可以嵌套：

// src/lib.rs 或 src/main.rs
mod my_module {
    fn private_function() {
        println!("这是私有函数");
    }

    pub fn public_function() {
        println!("这是公开函数");
    }

    mod nested_module {
        pub fn nested_function() {
            println!("嵌套模块中的函数");
        }
    }
}

访问模块内容

• 同一文件内：直接通过模块路径访问。
• 子模块：默认私有，需用 pub 暴露。
• 父模块：子模块可以访问父模块的私有项（Rust 的特殊规则）。

fn main() {
    my_module::public_function(); // 正确
    // my_module::private_function(); // 错误：私有函数
    // my_module::nested_module::nested_function(); // 错误：嵌套模块未公开
}

2. 模块文件结构

Rust 默认从以下文件加载模块：

1. 单文件模块：直接在 src/lib.rs 或 src/main.rs 中定义。
2. 多文件模块：
   • 声明模块：mod my_module;（无 {}）。
   • 文件位置：
     • my_module.rs（同级目录）。
     • my_module/mod.rs（旧版风格，Rust 2018 后不推荐）。

示例：多文件模块

src/
├── lib.rs
└── my_module/
    ├── mod.rs      // 模块根
    └── nested.rs   // 子模块

src/lib.rs:

mod my_module; // 声明模块（自动查找 my_module/mod.rs）

src/my_module/mod.rs:

pub mod nested; // 声明子模块（自动查找 nested.rs）

pub fn public_function() {
    println!("my_module::public_function");
}

src/my_module/nested.rs:

pub fn nested_function() {
    println!("nested_module::nested_function");
}

使用方式:

use my_module::nested::nested_function;

fn main() {
    my_module::public_function();
    nested_function();
}

3. 路径与可见性

路径规则

• 绝对路径：从 crate 根开始（crate::my_module）。
• 相对路径：从当前模块开始（super:: 或 self::）。

mod my_module {
    pub fn public_func() {
        println!("public_func");
    }
}

fn main() {
    // 绝对路径
    crate::my_module::public_func();

    // 相对路径（假设在另一个模块中）
    // super::my_module::public_func();
}

可见性控制

• pub：公开项（对外部可见）。
• 默认私有：仅在当前模块或子模块中可用。
• 特殊规则：子模块可以访问父模块的私有项（反之不行）。

4. use 关键字

用于简化路径：

use my_module::public_function;
// 或重命名
use my_module::public_function as my_func;

fn main() {
    public_function(); // 直接调用
    my_func();         // 使用别名
}

常见用法

• 引入多个项：

  use std::{collections::HashMap, fmt::Result};
  

• 引入所有公开项（慎用）：

  use std::collections::*;
  

5. 模块与 super 和 self

• self：当前模块（类似 this）。
• super：父模块（类似 ../）。

mod parent {
    pub mod child {
        pub fn function() {
            println!("child::function");
        }
    }

    pub fn call_child() {
        self::child::function(); // 等价于 child::function()
        super::main();          // 访问根模块的 main（需在子模块中）
    }
}

6. 模块与工作空间

在大型项目中，模块可以跨文件甚至跨 crate 组织：

• 同一 crate：通过 mod 和文件结构管理。
• 外部 crate：在 Cargo.toml 中声明依赖，用 extern crate（Rust 2018 后通常省略）。

总结

最佳实践

1. 按功能划分模块（如 mod network; mod parser;）。
2. 避免过度嵌套（通常不超过 3 层）。
3. 使用 pub use 重新导出常用项（简化用户路径）。

通过模块系统，Rust 可以高效管理代码规模，同时保持严格的访问控制。