装箱Trait如何影响传入参数的生命周期？附具体Rust示例

问题代码 #

以下代码在注释掉标记为(*)的行时可以正常编译，但取消注释后，编译器会报错entry生命周期不足（对应代码中标记“here”的位置）：

use std::path::Path;

trait MyTrait<T> {
    fn my_func(&self, t: T);
}

struct MyImpl {}

impl MyTrait<&Path> for MyImpl {
    fn my_func(&self, t: &Path) {
        println!("{:?}", t)
    }
}

struct MyWrapper<T> {
    inner: Box<dyn MyTrait<T>>
}

impl<T> MyWrapper<T> {
    pub fn new(inner: Box<dyn MyTrait<T>> ) -> Self { 
        Self { inner } 
    }
}

impl<T> MyTrait<T> for MyWrapper<T> {
    fn my_func(&self, t: T) {
        self.inner.my_func(t);
    }
}

fn foobar() {
    let the_impl = MyImpl{};        
    //let the_impl = MyWrapper::new(Box::new(the_impl)); // (*) 
    
    for entry in walkdir::WalkDir::new("blah") {
        let entry = entry.unwrap(); 
        let path = entry.path(); // <== here
        the_impl.my_func(path);
    }
}

补充验证 #

正如@Jmb指出，该问题与Path无关，使用&str也会出现相同错误：

impl MyTrait<&str> for MyImpl {
    fn my_func(&self, t: &str) {
        println!("{:?}", t)
    }
}

fn foobar_str() {
    let the_impl = MyImpl{};        
    let the_impl = MyWrapper::new(Box::new(the_impl));
    {
        let s = String::from("blah").clone();
        the_impl.my_func(&s as &str); // <== same error
    }
}

问题原因 #

核心问题在于** trait 对象的隐式生命周期约束**：

• 直接使用MyImpl时，编译器能推导出MyTrait<&Path>中引用的生命周期和传入的path一致（即当前循环迭代的生命周期）。
• 当把MyImpl包装成Box<dyn MyTrait<&Path>>时，Rust会默认将 trait 对象中的引用生命周期推断为'static——因为 trait 对象没有显式声明生命周期参数，编译器无法知道它需要适配临时引用的生命周期。而entry.path()返回的引用仅在当前迭代内有效，无法满足'static要求，因此触发生命周期错误。

解决方案 #

方案1：给Trait添加生命周期参数 #

显式声明Trait的生命周期参数，让trait对象能正确绑定传入引用的生命周期：

use std::path::Path;

// 为Trait添加生命周期参数，约束T的生命周期
trait MyTrait<'a, T: 'a> {
    fn my_func(&self, t: T);
}

struct MyImpl {}

// 实现带生命周期的Trait
impl<'a> MyTrait<'a, &'a Path> for MyImpl {
    fn my_func(&self, t: &'a Path) {
        println!("{:?}", t)
    }
}

// 包装器也带上对应的生命周期参数
struct MyWrapper<'a, T: 'a> {
    inner: Box<dyn MyTrait<'a, T>>
}

impl<'a, T: 'a> MyWrapper<'a, T> {
    pub fn new(inner: Box<dyn MyTrait<'a, T>>) -> Self { 
        Self { inner } 
    }
}

impl<'a, T: 'a> MyTrait<'a, T> for MyWrapper<'a, T> {
    fn my_func(&self, t: T) {
        self.inner.my_func(t);
    }
}

fn foobar() {
    let the_impl = MyImpl{};        
    let the_impl = MyWrapper::new(Box::new(the_impl));

    for entry in walkdir::WalkDir::new("blah") {
        let entry = entry.unwrap(); 
        let path = entry.path();
        the_impl.my_func(path);
    }
}

方案2：用泛型代替Trait对象 #

如果不需要动态分发（即不需要在运行时切换不同的Trait实现），可以把MyWrapper改成泛型结构体，完全避免trait对象带来的生命周期问题：

use std::path::Path;

trait MyTrait<T> {
    fn my_func(&self, t: T);
}

struct MyImpl {}

impl MyTrait<&Path> for MyImpl {
    fn my_func(&self, t: &Path) {
        println!("{:?}", t)
    }
}

// 用泛型参数U代替trait对象
struct MyWrapper<U> {
    inner: U
}

impl<U> MyWrapper<U> {
    pub fn new(inner: U) -> Self { 
        Self { inner } 
    }
}

// 为实现了MyTrait<T>的U，实现MyTrait<T>
impl<T, U: MyTrait<T>> MyTrait<T> for MyWrapper<U> {
    fn my_func(&self, t: T) {
        self.inner.my_func(t);
    }
}

fn foobar() {
    let the_impl = MyImpl{};        
    let the_impl = MyWrapper::new(the_impl);

    for entry in walkdir::WalkDir::new("blah") {
        let entry = entry.unwrap(); 
        let path = entry.path();
        the_impl.my_func(path);
    }
}

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