Rust 组织管理

Rust 提供了强大的模块系统来组织代码。本章节将介绍 Rust 中的模块系统和包管理。

模块系统

模块定义

使用 mod 关键字定义模块：

// src/main.rs
mod utils {
    pub fn add(a: i32, b: i32) -> i32 {
        a + b
    }
    
    pub fn subtract(a: i32, b: i32) -> i32 {
        a - b
    }
}

fn main() {
    println!("2 + 3 = {}", utils::add(2, 3));
    println!("5 - 2 = {}", utils::subtract(5, 2));
}

模块文件

可以将模块放在单独的文件中：

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

// src/utils.rs
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}

// src/main.rs
mod utils;

fn main() {
    println!("2 + 3 = {}", utils::add(2, 3));
    println!("5 - 2 = {}", utils::subtract(5, 2));
}

嵌套模块

可以创建嵌套模块：

src/
├── main.rs
└── utils/
    ├── mod.rs
    ├── math.rs
    └── string.rs

// src/utils/mod.rs
pub mod math;
pub mod string;

// src/utils/math.rs
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}

// src/utils/string.rs
pub fn capitalize(s: &str) -> String {
    let mut result = String::new();
    let mut first = true;
    for c in s.chars() {
        if first {
            result.push(c.to_uppercase().next().unwrap());
            first = false;
        } else {
            result.push(c);
        }
    }
    result
}

// src/main.rs
mod utils;

fn main() {
    println!("2 + 3 = {}", utils::math::add(2, 3));
    println!("Capitalized: {}", utils::string::capitalize("hello world"));
}

可见性

Rust 使用 pub 关键字来控制模块成员的可见性：

• private：默认，只能在当前模块及其子模块中访问
• pub：可以在任何地方访问
• pub(crate)：只能在当前 crate 中访问
• pub(super)：只能在父模块中访问

mod outer {
    pub fn public_function() {
        println!("This is a public function");
        private_function();
    }
    
    fn private_function() {
        println!("This is a private function");
    }
    
    pub mod inner {
        pub fn public_function() {
            println!("This is a public function in inner module");
            // 可以访问父模块的私有函数
            super::private_function();
        }
    }
}

fn main() {
    outer::public_function();
    outer::inner::public_function();
    // outer::private_function(); // 错误：private_function 是私有的
}

包管理

Cargo 项目结构

一个典型的 Cargo 项目结构：

project/
├── Cargo.toml
├── Cargo.lock
└── src/
    ├── main.rs      # 二进制项目的入口
    └── lib.rs       # 库项目的入口

依赖管理

在 Cargo.toml 文件中管理依赖：

[package]
name = "my-project"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = "1.0"
rand = "0.8"

工作空间

使用工作空间来管理多个相关的包：

workspace/
├── Cargo.toml
├── package1/
│   ├── Cargo.toml
│   └── src/
└── package2/
    ├── Cargo.toml
    └── src/

# workspace/Cargo.toml
[workspace]
members = [
    "package1",
    "package2",
]

路径

Rust 中有两种路径：

1. 绝对路径：从 crate 根开始，使用 crate:: 前缀
2. 相对路径：从当前模块开始，使用 self::、super:: 或直接使用模块名

mod utils {
    pub mod math {
        pub fn add(a: i32, b: i32) -> i32 {
            a + b
        }
    }
}

fn main() {
    // 绝对路径
    println!("2 + 3 = {}", crate::utils::math::add(2, 3));
    
    // 相对路径
    println!("2 + 3 = {}", utils::math::add(2, 3));
}

use 语句

使用 use 语句来简化路径：

mod utils {
    pub mod math {
        pub fn add(a: i32, b: i32) -> i32 {
            a + b
        }
        
        pub fn subtract(a: i32, b: i32) -> i32 {
            a - b
        }
    }
}

// 导入整个模块
use crate::utils::math;

// 导入特定函数
use crate::utils::math::add;

fn main() {
    println!("2 + 3 = {}", add(2, 3));
    println!("5 - 2 = {}", math::subtract(5, 2));
}

总结

• 模块系统：使用 mod 关键字定义模块
• 模块文件：可以将模块放在单独的文件中
• 嵌套模块：可以创建嵌套的模块结构
• 可见性：使用 pub 关键字控制可见性
• 包管理：使用 Cargo 管理依赖和工作空间
• 路径：使用绝对路径或相对路径引用模块
• use 语句：使用 use 语句简化路径

Rust 的模块系统提供了一种清晰、灵活的方式来组织代码。通过本章节的学习，你应该已经掌握了 Rust 中的模块系统和包管理。