《Rust编程入门》11.1 模块系统：组织与复用代码

January 2, 2025

11.1 模块系统：组织与复用代码

Rust 的模块系统是语言核心设计之一，用于帮助开发者组织代码、复用逻辑，并构建可维护的代码库。通过模块，开发者可以将代码分解成多个逻辑单元，方便调试和管理，同时支持良好的访问控制机制（公有性和私有性）。

11.1.1 模块的基本概念

模块的定义

模块是 Rust 中的一个逻辑单元，用 mod 关键字定义。模块的代码可以嵌套在同一个文件中，也可以拆分到不同的文件。

1
2
3
4
5
6
7
8
9


mod greetings {
    pub fn say_hello() {
        println!("Hello, Rust!");
    }
}

fn main() {
    greetings::say_hello(); // 调用模块中的函数
}

mod greetings 定义了一个名为 greetings 的模块。
模块内的 say_hello 函数使用了 pub 关键字，这使得该函数可以被外部访问。

嵌套模块

模块可以嵌套，形成更复杂的层次结构：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


mod library {
    pub mod books {
        pub fn find_book() {
            println!("Finding a book...");
        }
    }
}

fn main() {
    library::books::find_book(); // 调用嵌套模块中的函数
}

11.1.2 模块文件结构

在 Rust 中，模块可以分为内联模块和文件模块两种形式。

内联模块

模块定义在同一个文件中，代码较小或简单时可以使用。

1
2
3
4
5
6
7
8
9


mod greetings {
    pub fn say_hello() {
        println!("Hello, inline module!");
    }
}

fn main() {
    greetings::say_hello();
}

文件模块

对于较大的代码库，模块可以分布在多个文件中。

创建模块目录结构

目录结构如下：

1
2
3


src/
├── main.rs
└── greetings.rs

在 main.rs 中声明模块

1
2
3
4
5


mod greetings;

fn main() {
    greetings::say_hello();
}

在 greetings.rs 文件中定义模块内容

1
2
3


pub fn say_hello() {
    println!("Hello, file module!");
}

模块的子模块

子模块可以存放在独立的文件中，通过 mod 关键字声明。

目录结构：

1
2
3
4
5


src/
├── main.rs
├── library/
│   ├── mod.rs
│   └── books.rs

main.rs 文件：

1
2
3
4
5


mod library;

fn main() {
    library::books::find_book();
}

library/mod.rs 文件：

1

pub mod books;

library/books.rs 文件：

1
2
3


pub fn find_book() {
    println!("Finding a book...");
}

11.1.3 使用 `use` 关键字简化路径

路径可以通过 use 关键字进行简化，从而提高代码可读性。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


mod library {
    pub mod books {
        pub fn find_book() {
            println!("Finding a book...");
        }
    }
}

use library::books::find_book;

fn main() {
    find_book(); // 调用函数，无需完整路径
}

可以导入整个模块或多个项：

1
2
3
4
5
6


use library::books::{self, find_book};

fn main() {
    books::find_book(); // 使用模块名调用
    find_book();        // 简化路径调用
}

11.1.4 `super` 和 `self` 关键字

self：表示当前模块或作用域。
super：表示父模块。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


mod parent {
    pub mod child {
        pub fn child_fn() {
            super::parent_fn(); // 调用父模块中的函数
        }
    }

    pub fn parent_fn() {
        println!("This is a parent function.");
    }
}

fn main() {
    parent::child::child_fn();
}

11.1.5 常见模块化实践

模块组织建议

按功能分组：将相关功能划分到同一个模块。
避免过深嵌套：模块层次不宜过多，保持合理的文件结构。
封装实现细节：将内部实现标记为私有，仅暴露需要的接口。

公共接口模块

通过一个顶级模块汇总公共接口：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


mod library {
    mod books {
        pub fn find_book() {
            println!("Finding a book...");
        }
    }

    pub use books::find_book; // 暴露公共接口
}

fn main() {
    library::find_book(); // 直接调用暴露的函数
}

使用第三方库

通过 crate 的模块系统，可以轻松复用第三方库中的功能：

1
2
3
4
5
6


use rand::Rng;

fn main() {
    let random_number: i32 = rand::thread_rng().gen_range(1..101);
    println!("Random number: {}", random_number);
}

11.1.6 小结

Rust 的模块系统提供了强大的工具来组织和管理代码：

模块用于逻辑分组，可以嵌套和扩展。
文件模块支持构建清晰的项目结构。
通过 use 和路径管理，简化代码书写和引用。
利用 self 和 super，方便模块间的调用。
良好的模块化设计是构建可维护项目的重要基础。

下一节将探讨包与 crate 的概念，了解 Rust 如何通过包管理实现代码的分发与复用。