Rust基础-代码布局

实现一个加法操作

简单做法

# cargo new samples
.
├── Cargo.toml
└── src
    └── main.rs

然后再main.rs中实现加法操作：
cargo new samples

fn add(a: i32, b: i32) -> i32 {
    a + b
}
fn main() {
    println!("2 + 3 = {}", add(2, 3));
}

组织代码到特定模块

通常我们希望将函数单独组织。创建一个functions.rs，将函数调用代码存放在其中，文件布局为：

.
├── Cargo.lock
├── Cargo.toml
└── src
    ├── functions.rs
    └── main.rs

其中functions.rs内容：

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

其中pub关键字用来表示当前module下函数add使公有的，能被父模块引用。这样编译main.rs的时候编译器发现定义了mod functions。于是functions被添加到函数命名空间。在main中能访问functions这个module下的add函数，main.rs内容：

mod functions;
fn main() {
    println!("2 + 3 = {}", crate::functions::add(2, 3));
}

如C++一样类似，如果#include 之后我们使用的时候需要std::vector，如果想直接使用vector，需要use namespace std;rust中类似，我们可以同样的方法直接使用函数，此操作在rust中被称为shortcut。

mod functions;
use crate::functions::add;
fn main() {
    println!("2 + 3 = {}", add(2, 3));
}

在上面的case中，编译器按照crate编译，此时我们创建的是一个bin，所以需要编译src/main.rs，然后读取到main.rs的第一行，直到当前定义了一个子模块functions，编译器将查找functions模块，然后再src目录下找到了functions.rs，其中main.rs通过use crate::functions::add创建了对函数add的引用，这样就可以在main.rs中直接使用add。

进一步组织

有时候我们的函数可能会非常多，所以我们需要将特定的函数放在目录下单独管理：

.
├── Cargo.lock
├── Cargo.toml
└── src
    ├── algorithm
    │   ├── functions.rs
    │   └── mod.rs
    └── main.rs

functions.rs的代码如上例，没有任何变化，但是我们需要添加一个新的文件mod.rs。

pub mod functions;

main.rs代码：

mod algorithm;
use crate::algorithm::functions::add;
fn main() {
    println!("2 + 3 = {}", add(2, 3));
}

在这个case中和上面类似，编译器知道mod algorithm之后需要找到对应的模块，然后发现了algorithm目录，然后遭到algorithm下的mod.rs，发现他声明了functions模块，然后再去在当前目录（algorithm）查找functions.rs。

prelude

有时候我们使用不同的子模块，不同的子模块对外的访问性还不相同，我们可以单独定义模块的访问性：

src/
├── algorithm
│   ├── functions.rs
│   └── mod.rs
├── datastruct
│   ├── core.rs
│   └── mod.rs
└── main.rs

在上面的case中我们添加了子模块datastruct其中core.rs中实现了两个结构体Basic和Core。其中Basic可以被外部访问，Core不可以：

struct Core {}
pub struct Basic {}
impl Basic {
    pub fn info(&self) {
        println!("定义为公有，方便外部访问!");
    }
}
impl Core {
    fn info(&self) {
        println!("定义为私有，禁止外部访问!");
    }
}

datastruct/mod.rs

mod core;
pub use self::core::Basic;

这两行代码中第一个表明core是一个私有模块，无法通过crate::datastruct::core访问，但是我们在第二行定义了Basic对外可以访问。于是main.rs可以这样访问对应的Basic。

mod algorithm;
mod datastruct;
use crate::algorithm::functions::add;
use crate::datastruct::Basic; # 没有crate::datastruct::core::Basic
fn main() {
    println!("a + b = {}", add(2, 3));
    let mut b = Basic {};
    b.info();
}

或者使用use重命名特定的模块对象：

mod algorithm;
mod datastruct;
mod prelude {
    pub use crate::datastruct::Basic;
}//定义对特定模块的访问
use crate::prelude::*;
use crate::algorithm::functions::add;
fn main() {
    println!("a + b = {}", add(2, 3));
    let mut b = Basic {};
    b.info();
}