橘子味的心

    • 二十五岁时我们都一样愚蠢、多愁善感，喜欢故弄玄虚，可如果不那样的话，五十岁时也就不会如此明智。

    标题：Rust模块

    模块是一个名称空间，包含函数或其类型的定义。 模块是函数，结构，特征，impl块等项的集合。 默认情况下，模块的修饰符是私有的，但可以使用pub关键字使用public修饰符覆盖它。

    以下是模块中使用的关键字：

    • mod关键字：mod关键字声明新模块。
    • pub关键字：默认情况下，所有函数，类型，模块和常量都具有私有可见性修饰符。 pub关键字使可见性修饰符成为公共，因此，它们可在命名空间外部访问。
    • use关键字：use关键字用于将模块导入本地范围。

    模块定义

    模块由mod关键字定义。

    模块的语法：

    1. mod module_name  
    2. // body inside the module.
    3. Rust

    模块可以通过三种方式分类：

    1.单个模块： 当模块出现在单个文件中时称为单个模块。

    通过下面一个例子来理解这一点：

    1. mod a  
    2. {  
    3.      pub fn single_module()  
    4.     {  
    5.       println!("Single module");  
    6.     }  
    7. }  
    8. fn main()  
    9. {  
    10.   a::single_module();  
    11. }
    12. Rust

    执行上面示例代码，得到以下结果 - 

    1. Single module
    2. Shell

    在上面的示例中，定义了一个模块 - a，并且块中定义的每个代码都在命名空间a内。 可以使用模块名称后跟命名空间然后使用函数名称来调用模块a中的函数。

    也可以使用单独的文件来执行上面的示例：

    1. mod module;  
    2. fn main()  
    3. {  
    4.   module::single_module();  
    5. }
    6. Rust
    1. pub fn single_module()  
    2. {  
    3.     println!("Single module");  
    4. }
    5. Rust

    执行上面示例代码，得到以下结果 - 

    1. Single module
    2. Shell

    在上面两个例子中，检查mod X是用大括号还是在一个名为X.rs或X/mod.rs的单独文件中定义的。

    2.子模块： 在单个文件中，可以有多个模块。假设库名称是 - language，它由两个模块组成，即C和Cplus。

    下面给出了language库的层次结构：

    通过下面一个例子来理解：

    1. mod c  
    2. {  
    3.   pub fn c()  
    4.   {  
    5.     println!("C is a structured programming language");  
    6.   }  
    7. }  
    8. mod cplus  
    9. {  
    10.  pub fn cplus()  
    11.  {  
    12.     println!("C++ is an object-oriented programming language");  
    13.  }  
    14. }  
    15. fn main()  
    16. {  
    17.   c::c();  
    18.   cplus::cplus();  
    19. }
    20. Rust

    执行上面示例代码，得到以下结果：

    1. C is a structured programming language
    2. C++ is an object-oriented programming language
    3. Shell

    在上面的例子中，程序由两个模块组成，即c和cplus，它们各自的函数通过使用c::c()和cplus::cplus()来调用。

    3.嵌套模块： 嵌套模块是由模块内部的模块组成的模块，当相关模块组合在一起时它们非常有用。

    通过下面一个例子来理解这一点：

    1. mod a  
    2. {  
    3.  pub fn a()  
    4.  {  
    5.    println!("a module");  
    6.  }  
    7.  pub mod b  
    8.  {  
    9.    pub fn a()  
    10.    {  
    11.      println!("b module");  
    12.    }  
    13.  }  
    14. }  
    15. fn main()  
    16. {  
    17.  a::a();  
    18.  a::b::b();  
    19. }
    20. Rust

    执行上面示例代码，得到以下结果 - 

    1. a module
    2. b module
    3. Shell

    在上面的例子中，程序由两个模块组成，即a和b，其中b是a的内部模块。 这两个模块都包含具有相同名称但功能不同。 这两个函数分别使用a::a()和a::b::b()来调用。 它们都不会相互冲突，因为它们属于不同的名称空间。


    目录

    分类

    © 2020-2025 橘子味的心

  • 黔ICP备17008247号-2
  • 贵公网安备52022102000140