Rust中Trait对象方法存储引用至结构体的编译错误及疑问

核心问题：Trait对象调用带默认实现的方法时的Sized约束冲突 #

你遇到的问题本质是Rust中trait默认方法的通用性要求与trait对象（Unsized类型）的限制之间的矛盾：

• 当你在trait中定义不带Self: Sized约束的默认方法时，Rust要求这个方法必须能被所有实现该trait的类型调用，包括Unsized的trait对象本身。
• 但你的to_holder方法实现中，TraitObjectHolder { obj: self }隐含了从&Self到&dyn SomeTrait<Item=Self::Item>的转换——这个转换仅对Sized的具体类型有效，因为trait对象的转换需要依赖具体类型的大小信息生成vtable。当Self是trait对象（Unsized）时，这个转换无法完成，因此编译器强制要求添加Self: Sized约束。
• 一旦添加Self: Sized约束，该方法就只能被具体类型调用，无法再被trait对象调用，这就导致了你的困境。

解决方案：拆分方法，同时支持具体类型和Trait对象 #

方案1：Trait内默认方法（供具体类型）+ 全局函数（供Trait对象） #

保留trait内带Self: Sized约束的默认方法，同时编写一个全局函数专门处理trait对象：

trait SomeTrait {
    type Item;

    // 供具体类型调用，带Sized约束
    fn to_holder(&self) -> TraitObjectHolder<Self::Item>
    where
        Self: Sized,
    {
        TraitObjectHolder { obj: self }
    }
}

struct TraitObjectHolder<'a, T> {
    obj: &'a dyn SomeTrait<Item=T>,
}

struct SomeStruct<T> {
    item: T
}

impl<T> SomeTrait for SomeStruct<T> {
    type Item = T;
}

// 专门处理trait对象的全局函数
fn to_holder<T>(obj: &dyn SomeTrait<Item=T>) -> TraitObjectHolder<T> {
    TraitObjectHolder { obj }
}

fn main() {
    // 具体类型直接调用trait方法
    let some_struct = SomeStruct { item: 0 };
    let holder1 = some_struct.to_holder();

    // trait对象调用全局函数
    let some_struct_trait = &some_struct as &dyn SomeTrait<Item=i32>;
    let holder2 = to_holder(some_struct_trait);
}

方案2：使用扩展Trait为Trait对象添加方法 #

通过定义扩展trait，为&dyn SomeTrait类型实现to_holder方法，这样两种类型都能通过.语法调用：

trait SomeTrait {
    type Item;

    // 供具体类型调用，带Sized约束
    fn to_holder(&self) -> TraitObjectHolder<Self::Item>
    where
        Self: Sized,
    {
        TraitObjectHolder { obj: self }
    }
}

// 扩展trait，专门给trait对象用
trait SomeTraitExt<T> {
    fn to_holder(&self) -> TraitObjectHolder<T>;
}

// 为trait对象的引用实现扩展trait
impl<T> SomeTraitExt<T> for &dyn SomeTrait<Item=T> {
    fn to_holder(&self) -> TraitObjectHolder<T> {
        TraitObjectHolder { obj: self }
    }
}

// 其余结构体定义和实现不变...

fn main() {
    let some_struct = SomeStruct { item: 0 };
    let holder1 = some_struct.to_holder();

    let some_struct_trait = &some_struct as &dyn SomeTrait<Item=i32>;
    let holder2 = some_struct_trait.to_holder(); // 现在可以直接调用
}

为什么非关联函数可以正常运行？ #

非关联函数的参数直接是&dyn SomeTrait<Item=T>，它本身就是trait对象的引用，不需要任何类型转换——你只是把这个引用直接赋值给TraitObjectHolder的字段，因此不存在Sized约束的问题。

针对你的矩阵库场景的适配方案 #

对于Mat trait的row方法，你可以用同样的思路解决：

trait Mat {
    type Item;
    fn rows(&self) -> usize;
    fn cols(&self) -> usize;
    fn get(&self, row: usize, col: usize) -> Option<&Self::Item>;

    // 供具体类型调用的row方法
    fn row(&self, idx: usize) -> Option<SliceMatrix<Self::Item>>
    where
        Self: Sized,
    {
        if idx >= self.rows() {
            return None;
        }
        Some(SliceMatrix {
            mat: self,
            row_idx: idx,
            len: self.cols(),
        })
    }
}

// 扩展trait，支持trait对象调用
trait MatExt<T> {
    fn row(&self, idx: usize) -> Option<SliceMatrix<T>>;
}

impl<T> MatExt<T> for &dyn Mat<Item=T> {
    fn row(&self, idx: usize) -> Option<SliceMatrix<T>> {
        if idx >= self.rows() {
            return None;
        }
        Some(SliceMatrix {
            mat: self,
            row_idx: idx,
            len: self.cols(),
        })
    }
}

struct SliceMatrix<'a, T> {
    mat: &'a dyn Mat<Item=T>,
    row_idx: usize,
    len: usize,
}

// 具体矩阵类型的实现（比如DataMatrix）...

这样无论是DataMatrix等具体类型，还是&dyn Mat trait对象，都能通过.row(idx)方法获取行的SliceMatrix。

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