Rust 中的声明可见性

在 Rust 编程语言中，声明可见性是一个核心概念，它决定了代码中的项（如函数、结构体、枚举等）在哪些范围内可以被访问。Rust 通过一套严谨的规则来控制这些可见性，以确保代码的安全性和封装性。下面，我们将通过一些例子来详细探讨 Rust 中的声明可见性，特别是模块的可见性和路径的可见性。

默认私有性

在 Rust 中，任何声明的项默认都是私有的。这意味着，除非显式地改变其可见性，否则这些项只能在其被声明的模块内部被访问。这种默认私有性的设计有助于提高代码的安全性，因为它防止了外部代码对内部实现的意外或恶意修改。

使用 pub 关键字

要将一个项声明为公开的，可以在其前面添加 pub 关键字。一旦一个项被声明为 pub，它就可以在其定义模块的外部被访问。例如：

mod my_module {// 私有函数，只能在 my_module 内部访问fn private_function() {println!("This is a private function.");}// 公开函数，可以在 my_module 外部访问pub fn public_function() {println!("This is a public function.");}
}fn main() {// my_module::private_function(); // 错误：私有函数无法在模块外部访问my_module::public_function(); // 正确：公开函数可以在模块外部访问
}

在这个例子中，private_function 是私有的，只能在 my_module 内部调用。尝试在 main 函数中调用它会导致编译错误。而 public_function 是公开的，可以在 my_module 外部被访问。

模块的可见性

模块的可见性也遵循相同的规则。默认情况下，模块是私有的，除非使用 pub mod 来声明。这意味着，如果模块是私有的，即使其内部的项被声明为 pub，外部也无法访问这些项，因为无法访问包含它们的模块。

mod parent_module {// 私有子模块，外部无法直接访问mod private_child_module {pub fn public_function_in_private_module() {println!("This function is public within a private module.");}}// 公开子模块，外部可以访问pub mod public_child_module {pub fn public_function_in_public_module() {println!("This function is public within a public module.");}}
}fn main() {// parent_module::private_child_module::public_function_in_private_module(); // 错误：无法访问私有模块parent_module::public_child_module::public_function_in_public_module(); // 正确：可以访问公开模块中的公开函数
}

在这个例子中，private_child_module 是一个私有模块，因此即使它包含一个公开函数 public_function_in_private_module，该函数也无法在 parent_module 外部被访问。相反，public_child_module 是一个公开模块，因此它的公开函数 public_function_in_public_module 可以在外部被访问。

路径的可见性

除了直接使用 pub 关键字外，Rust 还提供了基于路径的更细粒度的可见性控制。通过使用 pub(in path) 语法，你可以指定一个项只对给定的路径可见。这允许你更精确地控制哪些模块可以访问特定的项。

mod grandparent_module {pub mod parent_module {// 这个函数只对 grandparent_module 内部的模块可见pub(in grandparent_module) fn semi_private_function() {println!("This function is semi-private.");}pub fn public_function() {println!("This function is public.");}}pub mod another_module {pub fn call_semi_private_function() {// 可以调用，因为 another_module 与 parent_module 都在 grandparent_module 内部parent_module::semi_private_function();}}
}fn main() {// grandparent_module::parent_module::semi_private_function(); // 错误：这个函数在 grandparent_module 外部不可见grandparent_module::parent_module::public_function(); // 正确：公开函数可以在任何地方访问grandparent_module::another_module::call_semi_private_function(); // 正确：因为调用发生在 grandparent_module 内部
}

在这个例子中，semi_private_function 函数使用 pub(in grandparent_module) 语法声明，这意味着它只对 grandparent_module 内部的模块可见。因此，尽管 another_module 可以调用它（因为它们都在 grandparent_module 内部），但 main 函数不能（因为它在 grandparent_module 外部）。

通过合理地利用这些可见性规则，你可以确保代码的安全性和封装性，同时提供必要的访问权限给需要它的模块。