basic/crate-module/module

[giscus[bot]]

basic/crate-module/module

https://course.rs/basic/crate-module/module.html

[yujun1214]

“而结构体的应用场景比较复杂，其中的字段也往往部分在 A 处被使用，部分在 B 处被使用，因此无法确定成员的可见性，那索性就设置为全部不可见，将选择权交给程序员。”，如果结构体的成员默认是私有的话，下面的代码应该通不过编译才对，但是实际上是可以通过编译的。
fn main() {

pub struct Point {
    x: u32,
    y: u32,
}

let mut p = Point {
    x: 1,
    y: 2,
};

p.x = 4;
println!("x: {}, y: {}, x * y: {} ", p.x, p.y, p.x * p.y);

}

[zmh1994]

你这代码都没有模块啊

[jyutjyu]

这里是同一作用域啊。当然可以访问。类似java的类，在同一类中，都可以随意访问。

[yujun1214]

我搞错了，我以为原文的意思是结构体内的成员默认是private的，其实应该是结构体成员对于其他模块来说默认是private的。

[MTDickens]

补充一点，结构体成员对于自身和子模块可以视作永远是 public 的，对于其他模块来说默认是private的。

[scp3125]

比如A是父模块，B、C是A的子模块
A能引用B、C里面的函数，B、C也能引用A的，B和C之间也可以互相引用，感觉写不好，会出循环依赖
请问rust这种模块设计优势表现在什么地方，又如何避免依赖混乱的问题？

[qxxiao]

默认A也不能访问BC私有的啊，子模块肯定能访问父模块的内容；BC之间也只能访问互相pub的，而且访问控制限制也不是依赖关系吧，更不会出现循环依赖。。。

[scp3125]

默认A也不能访问BC私有的啊，子模块肯定能访问父模块的内容；BC之间也只能访问互相pub的，而且访问控制限制也不是依赖关系吧，更不会出现循环依赖。。。

就是跨模块互相调用，更容易出现循环依赖吧，A调用了B，B调用C...在不知哪个模块里的F，又调用了A

[qxxiao]

嗯循环依赖还是有的，同一个crate内的模块循环调用更多是没有组织好模块吧，crate之间的循环依赖可能需要升级版本。

[Kev1n3zz]

应该说A不能访问B、C的私有项就是为了避免循环依赖吧。

[jinliming2]

关于模块的可见性，我之前遇到过一个问题，就是私有的内容一般来说就是不需要用户了解使用的，用户只需要使用 pub 内容即可。
但有时，由于包有些地方不满足需求，想要针对自己的需求改动部分实现，而其余的内部逻辑代码完全可以复用，那么这个时候是不是就只能把人家的整个包代码全复制过来，然后只改动几行代码的实现？感觉很不优雅……

举个例子：假设有一个包，公开函数是接受两个地名，然后返回两个地名之间的直线距离。具体实现是：公开函数接受两个地名，然后调用一个私有函数将两个地名转换为经纬度，然后调用另一个私有函数计算两个经纬度之间的距离。
现在我想使用这个包，但是想直接提供两个经纬度，发现它没有公开这个私有函数……

这个例子虽说计算经纬度的距离挺通用的，也许可以抽取成一个独立的包来使用，但实际场景下，可能就不一定了。

所以有没有某种 unsafe 的可能，突破可见性限制去调用另一个模块的私有功能呢？类似于其他语言中的利用反射来调用其他对象上的私有方法？

[lonexw]

如果用的是开源项目，简单 fork 一下项目，改一个自己可以用的版本就可以啦，如果在不 fork 修改的情况下就需要一些 unsafe 的黑科技啦（前提是必须能使用源代码哈）。

[lonexw]

以你这个场景为例，简单实现代码：

pub mod map {
    pub fn calc_distance(_start_place: &str, _end_place: &str) -> f32 {
        // TODO 转换地名为经纬度

        // 方便演示就不传参数啦
        inner_calc_distance()
    }

    fn inner_calc_distance() -> f32 {
        println!("Call inner private function!");

        0.0
    }
}

我们用下面的黑科技去直接调用包的内部私有函数：

fn main() {
    unsafe {
        std::mem::transmute::<usize, fn()>(
            // 这里就是魔法 🪄 发生的地方
            (map::calc_distance("北极", "南极") as usize) + 4314503456
        );
    }
}

# 程序运行打印结果：
Running `target/debug/call-private-method`
Call inner private function!

是不是很好奇，transmute 的解释，看一下作者的文章：类型转换, 但是这串数字 4314503456 是什么鬼 🐢，解释一下：

1. 我们首先将公开的方法 calc_distance 转换成了 usize 类型；
2. 然后加上这串神秘数字，函数在内存中调用这个内部函数的位置；
3. 再通过 std::mem::transmute 将得到的数字转换为函数执行；

逻辑不复杂，但是这串数字怎么获取？我们需要临时修改一下包的代码，把内部方法先改为 pub , 再用 dbg! 宏打印计算结果就可以拿到（参数变化也会影响内存位置的结果）：

    pub fn inner_calc_distance() -> f32 {
        println!("Call inner private function!");

        0.0
    }

fn main() {
    dbg!((map::inner_calc_distance as usize) - (map::calc_distance("北极", "南极") as usize));
}

最后，这种技巧临时 hack 可以，项目慎用。

[yoyoLooming]

这不是个library吗? 为什么可以运行

[TsGanT]

使用 cargo test, 来测试就行了

[niT-Tin]

关于结构体和枚举可见性的一点建议
原文：

• 将结构体设置为 pub，但它的所有字段依然是私有的
• 将枚举设置为 pub，它的所有字段也将对外可见
  这里枚举使用“字段”是不是不太妥当，感觉会让人把枚举和结构体混为一谈，也会增加这个两点的记忆成本，
  英文原文： if we make an enum public, all of its variants are then public
  原文使用的是variants，结构体的字段使用的是field，建议将二者区分出来，这样更利于理解
  (以上为个人建议)

[qinmz]

使用 cargo test, 来测试就行了

[Wyatex]

直译应该叫变体

[syclsp]

pub mod front_of_house {
pub mod hosting {
pub fn add_to_waitlist() {}
}

mod front_of_house;

pub use crate::front_of_house::front_of_house::hosting; // 我需要写成这样才没有语法错误， rustc 1.64.0

[Ryu2u]

因为第一个front_of_house表示为文件名，你可以试试把文件名改了，第一个front_of_house也会变

[zbsir-happy]

在上面的例子中
mod front_of_house {
mod hosting {
fn add_to_waitlist() {}
}
}

pub fn eat_at_restaurant() {
// 绝对路径
crate::front_of_house::hosting::add_to_waitlist();

// 相对路径
front_of_house::hosting::add_to_waitlist();

}

为什么eat_at_restaurant这个函数前要加pub，而front_of_house前面不用加

[doraemonkeys]

怎么感觉这章比生命周期啥的还难，例子我都跑不起来😭

[Ghy0202]

我是win环境，版本是rustc 1.70.0 (90c541806 2023-05-31)，包这边必须mod.rs不然vscode里面rust-analysis标红🥲

[caaaaaat6]

我的rustc 1.72.1 (d5c2e9c34 2023-09-13)，vscode里用rust-analysis用新版本的方法不飘红。是不是你的和front_of_house目录同级的front_of_house.rs里没有写下面这两行？

// in front_of_house.rs
pub mod hosting;
pub mod serving;

[rucat125]

https://www.cnblogs.com/fire-cat/p/17578600.html
这是我自己总结的关于分文件规划模块的随笔，大家帮忙看看有没有什么不对和遗漏的。
水平有限，多多包涵😊

[MTDickens]

写得很好，这样我就不用自己去实验了 : )

[CamaroW]

Good

[zhanglintc]

crate root翻译成箱根好了...

[happyfeetw]

旅游胜地是吧

[monsterooo]

在 front_of_house 同级目录里创建一个与模块（目录）同名的 rs 文件 front_of_house.rs，在新版本里，更建议使用这样的命名方式来避免项目中存在大量同名的 mod.rs 文件（ Python 点了个 踩）。

需要更正一下：

在 lib.rs 同级目录里创建一个与模块（目录）同名的 rs 文件 front_of_house.rs，在新版本里，更建议使用这样的命名方式来避免项目中存在大量同名的 mod.rs 文件（ Python 点了个 踩）。

[rucat125]

模块只要不加载就和 lib.rs 没关系
├─src
│ │ dir0.rs
│ │ file.rs
│ │ main.rs
│ │
│ └─dir0
│ │ dir1.rs
│ │ file0.rs
│ │
│ └─dir1
│ file1.rs
目录结构是这样的

[kyoybs]

经过研究发现， mod有两种用法， 一种是后面带大括号的， 是定义mod, 另一种是mod后面跟着一个名字， 是引用mod。

一个rs文件，就是一个天然的mod， 可以在其中定义更小的mod。

引入mod的关键字还是mod， 不像java使用namespace定义，使用import引入。

[CamaroW]

作者是这么说的

需要注意的是，和之前代码中 mod front_of_house{..} 的完整模块不同，现在的代码中，模块的声明和实现是分离的，实现是在单独的 front_of_house.rs 文件中，然后通过 mod front_of_house; 这条声明语句从该文件中把模块内容加载进来。因此我们可以认为，模块 front_of_house 的定义还是在 src/lib.rs 中，只不过模块的具体内容被移动到了 src/front_of_house.rs 文件中。

感觉这个就和特征里写的 fn 差不多，在 trait 里写的 fn 是不带大括号、带分号的声明，实现时就是带大括号的了。

不过感觉你这个理解也可以，把 “定义 + 实现” 和 “引入” 看成两种东西。

[wangmuxi-luchi]

可不可以直接类比为C语言里面的函数声明和函数定义，带大括号的就是定义，不带的就是声明。是不是还可以由C语言的概念类推出来不带大括号的mod可以在多个地方“引用”，而带大括号的定义是唯一的。

[TURING132]

看完可以理解Package, Crate, module的关系。但是没有理解怎么让多个文件组织成一个Crate？

[TURING132]

应该说module可以由一个或多个文件组织起来。存在多个Crate的时候，怎么指定哪些module组成一个Crate呢？还是说只有在Crate root中调用的部分会组成一个Crate？

[lhylyrr]

我的一些疑问：

1. 一个 crate 除了有根文件(src/main.rs & src/lib.rs)，还能有其他文件吗？
2. 放在 src/bin 目录下的其他二进制包有 crate root 吗？如果有，那么树形结构又是长什么样的？
   在线等挺急的，好人一生平安！！！

[rucat125]

建议参考这里 https://course.rs/advance-practice/channels.html

[lhylyrr]

好的，谢谢！！！

[upWooStream]

如果需要将文件夹作为一个模块，我们需要进行显示指定暴露哪些子模块。按照上述的报错信息，我们有两种方法：
在 front_of_house 目录里创建一个 mod.rs，如果你使用的 rustc 版本 1.30 之前，这是唯一的方法。
在 front_of_house 同级目录里创建一个与模块（目录）同名的 rs 文件 front_of_house.rs，在新版本里，更建议使用这样的命名方式来避免项目中存在大量同名的 mod.rs 文件（ Python 点了个 踩）。

这两种方法怎么感觉没有本质的区别，只是将文件夹种的mod.rs文件移动到了上一级目录下，文件名改为和目录名相同。
也没见得有多好，而且我倒觉得使用mod.rs更直观，是我理解的有问题吗？:)

[rucat125]

两种方式没有区别 新的只是可以避免模块多了之后全是mod.rs文件(可以理解成这个团队的强迫症) 最后还是用你喜欢的方式就好

[ytianxia6]

模块这里很烦，声明要放在父模块里，实现与分离分开，要添加一个模块，需要添加文件、再去父模块里添加声明。

[reatang]

我来说一下我的理解：

• 工作空间 workspace
  • 集合多个 package 的管理概念
• 包 package
  • package 管理一个到多个carte，也只是一个管理概念
• 单元包 carte
  • 单元包 carte 真实组织代码和代码关系的单元
• 模块 mod
  • 单元包内代码的载体

[goosy]

教程里说“ src/main.rs 和 src/lib.rs 被称为包根(crate root)，……这两个文件的内容形成了一个模块 crate”
我可发现这两个文件的包根似乎不象是同一个。假设我们在cargo.toml 定义了name 为 mycrate

// 在lib.rs文件中，mod定义不用单独文件的方式
pub mod A{
   pub fn my_method(){}
}
A::my_method(); // 能正确引用
crate::A::my_method(); // 能正确引用
user mycrate::A::my_method; // 能正确引用

// 在 main.rs文件中引用 my_method 函数
// use A::my_method(); // 这个报错
// use crate::A::my_method(); // 这个也报错
use mycrate::A::my_method(); // 这个能正确引用

如果 main.rs 和 lib.rs 的包根crate 是同一个的话，怎么解释 main.rs 里无法用 crate::A::my_method？

[restart126]

就学过c++和python，感觉模块这东西好像cmake啊，但能编译是真没见过

[fredlifeup]

感觉自己又变强了。

[Mikachu2333]

写了一个mod试图使用其他语言调用，但是怎么调也都是fail……有大神能告诉我问题出现在哪里吗

库公开地址：https://github.com/Mikachu2333/name_exchanger_rslib

代码逻辑简化如下：

#[no_mangle]
pub extern "C" fn exchange_inputs(input1: String, input2: String) -> String {
    let result_num = process_input::change_name::exchange(input1, input2);
    process_input::show_error::switch_error_msg(result_num)
}

pub(crate) mod process_input {
    pub(crate) mod metadata_get {
        //各种用于获取文件（文件夹）信息的函数
        //例如：是否存在，用户输入路径是否为相对路径，是否存在父子目录关系等等，均为pub

    pub(crate) mod change_name {
        fn make_name(dir: PathBuf, mut other_name: String, ext: String) -> (PathBuf, PathBuf) {
            //函数：获取新文件名
        }
        pub fn exchange(input1:&PathBuf, input2:&PathBuf)->u8{
                //具体执行，用到了metadata_get模块中的所有函数和本change_name模块中的make_name函数
                返回u8表示是否出现错误以及错误的类型
            }
        }

    }
    pub mod show_error {
        pub fn switch_error_msg(num: u8) -> String {
           //美化错误信息
        }
    }
}

#[cfg(test)]
mod tests {
    fn clear_olds(test_path1: &String, test_path2: &String) {
        //创建测试文件
    }
    #[test]
    fn it_works() {
        let test_path1 = String::from("D:\\languagelearning\\Rust\\exchange_name_lib\\file1.ext1");
        let test_path2 = String::from("D:\\languagelearning\\Rust\\exchange_name_lib\\file2.ext2");

        clear_olds(&test_path1, &test_path2);

        let run_result = exchange_inputs(test_path1, test_path2);
        println!("{}", run_result);
    }
}

编译为dll

[target.x86_64-pc-windows-gnu]
rustflags = ["-C","target-feature=+crt-static"]

[lib]
crate-type = ["cdylib"]
name = "name_exchanger_rs"

cpp调用代码如下：

#include<iostream>
#include <windows.h>
using namespace std;

typedef string (*func)(string a, string b);

int main()
{
	//动态加载 dll
	HMODULE hModule = LoadLibraryA("name_exchanger_rs.dll");
	if (!hModule)
	{
		cout << "Error!" << endl;
	}
	func exchange_fn = func(GetProcAddress(hModule, "exchange_inputs"));
	if (exchange_fn != NULL)
	{
		string r = exchange_fn("D:\\Desktop\\file1.ext1", "D:\\Desktop\\file2.ext2");
		cout << r << endl;
	}
	//释放
	FreeLibrary(hModule);
	return 0;
}

[DylanJinx]

如果在lib.rs中只用use crate::front_of_house::hosting;而没有前面的pub关键字，这样做的效果是将hosting模块引入到lib.rs的私有作用域中。这意味着你可以在lib.rs文件内部通过hosting::add_to_waitlist()的方式直接访问add_to_waitlist函数，而不需要使用完整的路径。

然而，因为没有使用pub关键字来重新导出hosting模块，hosting模块及其内容对于使用你的crate的外部代码是不可见的。外部用户需要使用完整的路径my_crate::front_of_house::hosting::add_to_waitlist();来访问add_to_waitlist函数。

[DylanJinx]

两种方法下的目录结构：

方法1：使用 mod.rs

如果你选择在front_of_house文件夹内创建一个mod.rs文件来定义模块，目录结构将如下所示：

src/
│
├── lib.rs                 // crate根文件
│
└── front_of_house/        // 模块目录
    ├── mod.rs             // 定义front_of_house模块及其子模块
    └── hosting.rs         // hosting子模块

在这个结构中：

• lib.rs中有一行mod front_of_house;，这指示Rust查找名为front_of_house的模块。
• front_of_house/mod.rs包含对子模块的定义，如pub mod hosting;，这告诉Rusthosting模块在hosting.rs文件中定义。

方法2：使用与目录同名的 .rs 文件

如果你选择在front_of_house目录同级下创建一个与目录同名的.rs文件来定义模块，目录结构将如下所示：

src/
│
├── lib.rs                 // crate根文件
│
├── front_of_house.rs      // 定义front_of_house模块及其子模块
│
└── front_of_house/        // 模块目录
    └── hosting.rs         // hosting子模块

在这个结构中：

• lib.rs中有一行mod front_of_house;，这指示Rust查找名为front_of_house的模块。
• front_of_house.rs包含对子模块的定义，如pub mod hosting;，这告诉Rusthosting模块在front_of_house/hosting.rs文件中定义。

两种方法都可以有效地组织和管理复杂的模块结构，选择哪一种主要取决于个人或团队的偏好。新版本的Rust趋向于推荐使用第二种方法，因为这样可以避免多个mod.rs文件，使得项目结构更清晰。

[ZzzzHeJ]

请问在下面这个例子中，为什么要在pub use crate::front_of_house::hosting;前使用mod front_of_house;呢这个原理是什么呀？

mod front_of_house;

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
}

[ZzzzHeJ]

是不是mod是负责引入模块代码，类似include 而use类似引入命名空间，类似using？

[CamaroW]

帮你问了下 GPT：https://chatgpt.com/share/67d5a2d8-d538-8005-b45e-ef503f94dd22

大概就是 mod front_of_house; 是用来声明的，如果没有这行，那根本用不了任何 front_of_house 里的模块和函数。use 只是加一个地址快捷方式，让你不用每次用 add_to_waitlist() 函数都得要写 crate::front_of_house::hosting::add_to_waitlist()。：）

[GaoLe996]

感觉这个项目组织，不如JAVA的包结构让人容易理解

[xwlcn]

多目录mod感觉很鸡肋，要想把某个目录当作mod还需要建一个同名rs文件来声明其子mod，目录结构本身就体现了mod的层级结构，结果还需要在父mod的rs文件里面声明一下子mod。java的包结构一点没学，就学了C/C++的定义与声明，用前必须先声明（注意是声明，不是use关键字）- -!

[xwlcn]

好吧，想了下和java的包还是有区别的，因为rust可以以文件名来当作mod名，而java包必须是目录，所以不能一概而论，只不过java的包结构更清晰容易理解，module虽然和java的包结构很相似，但其定义语法（可以在rs文件里嵌套声明定义）决定了不能像java那样简单直接用目录来当作module。