Rust跨Crate实现Trait：无Std核心库的调试输出方案

我要开发一个由核心Crate和应用Crate组成的Rust程序，核心Crate要求不使用std库且禁止堆分配，适配嵌入式系统。核心Crate需要具备调试输出能力，但这个能力必须由应用Crate来实现。

我尝试了几种思路，想请教这些方案是否可行，以及哪种更简洁：

最初Trait定义思路 #

核心Crate（core/lib.rs）：

// Storing the object which implements MyDebug?
// Initialization function?

pub trait MyDebug {
    fn mydebug(text: &str);
}

pub fn custom_function() {
    mydebug("Hello World");
}

应用Crate（application/main.rs）：

use core;

struct DebugObject {
}

impl core::MyDebug for DebugObject {
    fn mydebug(text: &str) {
        // do something
    }
}

fn main() {
   // Some initialization
   DebugObject obj;
   core::initialize_debug(&obj);

   custom_function();
}

每次调用传递调试对象的方案 #

use core;

struct DebugObject {
}

impl core::MyDebug for DebugObject {
    fn mydebug(text: &str) {
        // do something
    }
}

fn main() {
   // Some initialization
   DebugObject obj;

   custom_function(&obj);
}

自己找到的解决方案 #

核心Crate（core/lib.rs）：

#![no_std]

pub trait MyDebug {
    fn debug(&self, text: &str);
}

static mut DEBUG: Option<&'static dyn MyDebug> = None;
static mut DEBUG_INITIALIZED: bool = false;

pub unsafe fn initialize_debug<T: MyDebug>(debugger: &'static T) {
    if !DEBUG_INITIALIZED {
        DEBUG_INITIALIZED = true;
        DEBUG = Some(debugger);
    }
}

fn debug(text: &str) {
    unsafe {
        if let Some(debugger) = DEBUG {
            debugger.debug(text);
        }
    }
}

pub fn function() {
    debug("Test123");
}

应用Crate（main.rs）：

use core;
struct MyStruct {

}

impl core::MyDebug for MyStruct {

    fn debug(&self, text: &str) {
        println!("{}", text);
    }
}

const MY_STATIC_STRUCT: MyStruct = MyStruct {
};

fn main() {
    unsafe {
        core::initialize_debug(&MY_STATIC_STRUCT);
    }

    core::function();
}

1. 最初Trait定义思路 #

这个方案不可行。核心Crate里的custom_function直接调用mydebug函数，但mydebug是Trait的关联函数，没有具体实现，编译器无法找到对应的调用目标；同时你设想的initialize_debug函数在核心Crate中并未定义，无法完成调试对象的注册，逻辑不完整。

2. 每次调用传递调试对象的方案 #

这个方案可行且最简洁安全。只需要把核心Crate的custom_function修改为接收实现MyDebug的引用参数：

// core/lib.rs
pub trait MyDebug {
    fn mydebug(&self, text: &str);
}

pub fn custom_function(debugger: &impl MyDebug) {
    debugger.mydebug("Hello World");
}

应用侧直接传递调试对象即可。这种方案完全不需要unsafe代码，符合Rust安全规范，且无全局状态，在嵌入式系统的多线程/中断场景下更可靠，不会出现竞态问题。唯一的小代价是需要在每个调用调试输出的地方传递对象，但显式传递反而让依赖关系更清晰。

3. 全局静态对象方案 #

这个方案可行但存在安全隐患：使用unsafe操作全局可变静态变量，在有中断或多核心的嵌入式系统中，无保护的全局变量访问可能引发数据竞争，导致未定义行为。另外要求调试对象必须是'static生命周期，灵活性不如传递参数的方案。不过它的优点是调用时无需传参，代码更简洁，适合单线程无中断的场景。

最终推荐 #

如果追求安全、可靠，优先选择每次调用传递调试对象的方案；如果可以接受unsafe代码、系统是单线程无中断场景，且希望调用更简洁，可以选择全局静态对象方案。最初的Trait定义思路逻辑不完整，无法直接使用。

内容的提问来源于stack exchange，提问作者Murmi