rust pub mod

在 Rust 编程语言中，`pub mod`是一个用于模块导出的声明，表示当前模块的内容对外可见（public）。当你在模块前加上`pub`关键字，该模块就可以被其他的 crate 使用，无论它们是在同个仓库还是不同的仓库。

`mod`关键字本身创建了一个新的模块，而`pub mod`则告诉 Rust 编译器将这个模块作为一个公共接口公开给其他外部模块引用。例如：

// file: mod.rs
pub mod utils; // 这里定义了一个名为 `utils` 的公共模块

// file: utils.rs (在 utils 模块内)
pub fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

在这个例子中，`mod.rs` 文件中的 `pub mod utils` 声明使得外部可以导入并使用 `greet` 函数。其他 crate 可以通过`use`关键字导入 `utils` 并调用它的函数：

// external crate
use my_project::utils;

fn main() {
    let message = utils::greet("World"); // 能够正常工作
    println!("{}", message);
}

相关问题

rust 如何调用python

Rust可以调用Python的方法有很多种，下面介绍两种常见的方法：

1. 使用Rust的PyO3库

PyO3是一个Rust库，可以用来编写Python扩展模块，也可以在Rust中调用Python。

首先，在Rust项目中添加PyO3的依赖：

[dependencies.pyo3]
version = "0.14.2"
features = ["extension-module"]

然后在Rust代码中调用Python：

use pyo3::prelude::*;

fn main() -> PyResult<()> {
    Python::with_gil(|py| {
        let sys = py.import("sys")?;
        let version: String = sys.get("version")?.extract()?;
        println!("Python version: {}", version);
        Ok(())
    })
}

在这个例子中，我们使用`Python::with_gil`方法来获得Python的全局锁，然后调用Python的方法`sys.get('version')`来获取Python的版本号。

2. 使用Python的C API

Python提供了C语言的API，可以在任何C兼容的语言中调用Python。在Rust中，我们可以使用FFI（Foreign Function Interface）来调用Python的API。

首先，在Rust代码中声明Python的C API：

#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
mod Py {
    #[repr(C)]
    pub struct object;

    impl object {
        #[link_name = "Py_InitModule4_64"]
        pub fn Py_InitModule4_64(
            name: *const u8,
            module_methods: *const (),
            docstring: *const u8,
            _PyObject: *mut Py::object,
            _python_api_version: i32,
        ) -> *const Py::object;

        #[link_name = "PyString_FromString"]
        pub fn PyString_FromString(string: *const u8) -> *const Py::object;

        #[link_name = "PyImport_ImportModule"]
        pub fn PyImport_ImportModule(name: *const u8) -> *const Py::object;

        #[link_name = "PyEval_InitThreads"]
        pub fn PyEval_InitThreads();

        #[link_name = "PyGILState_Ensure"]
        pub fn PyGILState_Ensure() -> *mut Py::object;

        #[link_name = "PyGILState_Release"]
        pub fn PyGILState_Release(state: *mut Py::object);
    }
}

然后在Rust代码中调用Python的API：

use std::ffi::CString;

fn main() {
    unsafe {
        Py::Py_Initialize();
        let name = CString::new("sys").unwrap().as_ptr();
        let sys_module = Py::PyImport_ImportModule(name);
        let version_str = CString::new("version").unwrap().as_ptr();
        let sys_dict = Py::PyModule_GetDict(sys_module);
        let version_obj = Py::PyDict_GetItemString(sys_dict, version_str);
        let version_ptr = Py::PyString_AsString(version_obj);
        let version = CStr::from_ptr(version_ptr).to_str().unwrap();
        println!("Python version: {}", version);
        Py::Py_Finalize();
    }
}

在这个例子中，我们使用了Python API中的几个函数，如`Py_Initialize`、`PyImport_ImportModule`、`PyModule_GetDict`、`PyDict_GetItemString`、`PyString_AsString`等。

注意，使用Python的C API需要注意内存管理问题，比如要手动调用`Py_IncRef`和`Py_DecRef`来管理Python对象的引用计数。因此，如果使用Python的C API，建议使用Safe Python库来进行更方便的内存管理。

rust如何实现单例模式

可以使用 Rust 的模块系统来实现单例模式。具体实现方式是，在一个模块中定义一个私有的静态变量，然后提供一个公共的函数来获取该变量的引用。这样，每次调用该函数时都会返回同一个实例。例如：

mod singleton {
    struct MySingleton {
        // ...
    }

    // 私有静态变量
    static mut INSTANCE: Option<MySingleton> = None;

    // 公共函数
    pub fn get_instance() -> &'static MySingleton {
        unsafe {
            INSTANCE.get_or_insert_with(|| MySingleton { /* ... */ })
        }
    }
}

fn main() {
    let instance1 = singleton::get_instance();
    let instance2 = singleton::get_instance();
    assert_eq!(instance1 as *const _, instance2 as *const _);
}