Rust, Trait Object, Object Safty

最新推荐文章于 2025-02-23 09:12:25 发布

原创

最新推荐文章于 2025-02-23 09:12:25 发布 · 391 阅读

1 ·

CC 4.0 BY-SA版权

在尝试创建Trait对象时遇到了编译错误，原因是trait的某个方法包含了泛型参数，不符合对象安全性规则。对象安全是trait对象的必要条件，要求trait的所有方法不能返回Self类型并且不含有通用类型参数。通过将泛型参数替换为Box<dyn ...>，使用动态调度以实现运行时的灵活性，类似于Golang的interface，但Rust中由于泛型的存在，存在特定的限制。

写了下面一段：

async fn put<'a, S, E, F>(
    store: Arc<Mutex<dyn Storer<'a, dyn Stream<Item = Result<Bytes, E>>, dyn StdError + Send + Sync>>>,
) -> impl Fn(Request<Body>) -> Pin<Box<Future<Output = Result<Response<Body>, Infallible>>>> + 'a
where
    S: Stream<Item = Result<Bytes, E>>,
    E: StdError + Send + Sync + 'a,
{
    move |req: Request<Body>| {
        let store = store.clone();
        async move {
            store.lock().unwrap().put("ext", req);
            Ok::<Response<Body>, Infallible>(Response::new(Body::default()))
        }
        .boxed()
    }
}

编译器告诉我:

the `put` method cannot be invoked on a trait object

本着报错越短问题越大的原则，我的直觉告诉我，这问题不好对付，因为好对付的一般编译器直接给你建议了，虽然准确度不是很高，但是至少多给你提供了点线索，像这种一句话的报错，答非所问的概率比较高，你看着它在说A问题，实际最终解决之后你会发现，这完完全全是B问题，而且B问题跟A问题基本没啥联系。

难解决也得解决，从网上找了一圈，没有发现太好的解答，不过信息都指向了官

最低0.47元/天解锁文章

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

wangjun861205

关注关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

【Rust trait特质】如何在Rust中使用trait特质，全面解析与应用实战

景天科技苑

05-14

5万+

在Rust中，Trait是一种定义共享行为的机制，类似于其他语言中的"接口"(interface)或"抽象类"(abstract class)。 Trait允许我们定义一组方法签名，这些方法可以被不同类型实现，从而实现多态行为。

rust笔记13：trait对象

最新发布

shanzhizi的专栏

03-05

1195

在 Rust 中，trait 对象是一种实现动态分发（dynamic dispatch）的机制，允许你在运行时处理实现了某个 trait 的不同类型。Trait 对象是 Rust 中实现多态性的重要工具之一，特别是在需要处理多种类型但又不确定具体类型的情况下。

参与评论您还未登录，请先登录后发表或查看评论

rust实战系列一百三十二：trait object

Mr_Roki的博客

02-29

539

用户需要手动打开#！同理，Bird只是一个trait的名字，符合这个trait的具体类型可能有多种，这些类。DST的指针理所当然也应该是一个“胖指针”，它的名字就叫trait object。它的大小在编译阶段是不确定的，相对应的，&[T]类型就是一个“胖指针”，它不仅。指向trait的指针只包含了对象的地址，那么它就没办法实现针对不同的具体类型调。当指针指向trait的时候，这个指针就不是一个普通的指针了，变成一个“胖指。我们可以看到，直接针对对象取指针，得到的是普通指针，它占据64 bit的空。

Rust特征对象(Trait Object)

zy010101博客

03-14

2163

我们直接来看一段代码。它展示了特征对象的两种定义方式。// 定义特征Draw trait Draw {} // 为u8类型实现Draw特征 impl Draw for u8 {format!("u8: {}" , * self) } } // 为f64类型实现Draw特征 impl Draw for f64 {format!

Rust Trait Object 和对象安全

萧猛的技术博客

12-16

3016

所谓 trait 对象，可以理解为其它面向对象语言中，指向接口或基类的指针或引用。其它OO语言指向基类的指针在运行时确定其实际类型。 Rust 没有类继承，指向 trait 的指针或引用起到类似的效果，运行时被确定具体类型。所以编译期间不知道大小。 trait 对象体现出来就是对一个 trait类型的指针或引用。不是所有的 trait都可以被当做 trait对象使用，能作为 Trait 对象使用的 trait 要同时满足以下规则： rule 1: trait 的 Self 类型参数不能..

Rust : Trait Object safe 问题

代码过客

09-03

1634

碰到这种情况，代码如下： #[derive(Clone)] struct Trade(i32); trait Bet{ fn bet(&self); } trait Test :Bet fn test(&self); } impl Test for Trade{ fn test(&self){} } impl Trade{ fn default(&self) -> Vec<Box<dyn Test>>{

【Rust中级教程】2.6. API设计原则之灵活性(flexible) Pt.2：对象安全(Object Safety)、对象安全与API设计、trait的泛型方法与API设计

SomeB1oody, a rookie

02-23

1419

对象安全（Object Safety）是Rust中与**Trait 对象（Trait Object）** 相关的一个概念，它决定了某个 Trait 是否可以被动态分发（dynamic dispatch），即能否用作`dyn Trait`形式的Trait对象。

如何在rust中使用泛型，trait对象的总结以及kv sever（3）

weixin_53344209的博客

04-13

982

可以说在 Rust 开发中，泛型编程是我们必须掌握的一项技能。在你构建每一个数据结构或者函数时，最好都问问自己：**我是否有必要在此刻就把类型定死？**是不是可以把这个决策延迟到尽可能靠后的时刻，这样可以为未来留有余地？如果我们能通过泛型来推迟决策，系统的架构就可以足够灵活，可以更好地面对未来的变更。前面学习到trait可以实现参数多态，就是函数或者数据结构用T表示，不是具体类型；还可以实现特设多态，也就是函数重载，一个函数接口不同的参数有不同的实现；更牛逼的就是trait做参数的时候，可以实现特征约束

Rust Trait 静态派发与动态派发示例

11-07

Trait在Rust中类似于其他编程语言中的接口或抽象类，它定义了某个功能的契约，但是它也能够拥有默认实现。这使得Trait不仅仅是一个规范，还可以提供具体的行为。在Rust中，根据调用方式的不同，Trait的方法调用...

rust 中object类型

weixin_42589700的博客

01-12

163

在Rust中，Box<T> 类型是一种智能指针，可以在堆上分配内存并管理其生命周期。它可以用来存储任何类型，包括trait对象。而trait对象就是Rust中的object类型。 ...

rust实战系列一百三十三：object safe

Mr_Roki的博客

02-29

647

我们可以想象一下，假如我们创建了一个Clone trait的trait object，并调用clone。trait只是描述了公共的行为，并不描述具体的内部实现，实现这个trait的具体类型是。段，我们知道的仅仅是这个类型实现了Clone trait，其他的就一无所知了。trait的具体类型，在impl的时候，针对不同的类型，有不同的具体化实现。Self类型是个很特殊的类型，它代表的是impl这个trait的当前类型。一般情况下，我们把trait当作类型来看的时候，它是不满足Sized条件的。

【Rust 基础篇】Rust动态大小类型：理解动态大小类型与编写安全的代码

繁依Fanyi的博客

08-02

1454

在Rust中，动态大小类型（DST）是一种特殊的类型，它的大小在编译时无法确定，需要在运行时根据实际情况进行确定。动态大小类型主要包括引用类型和trait对象。要定义引用类型，需要使用符号在变量前面创建引用。// 定义引用类型 fn main() {let x = 42;// 创建引用 }在上述例子中，我们创建了一个变量x，然后使用引用（&）创建了一个引用reference，引用了变量x的值。要定义trait对象，需要使用&dyn Trait语法来引用具体类型的值。

Gradle调用Ant任务读文件失败，提示：Cannot invoke method sort() on null object

热门推荐

小妖666个人笔记

05-05

1万+

Ant 任务是 Gradle 中的一等公民。Gradle 借助 Groovy 对 Ant 任务进行了优秀的整合。Gradle 自带了一个 AntBuilder，在 Gradle 中调用 Ant 任务比在 build.xml 中调用更加的方便和强大。通过下面的例子你可以学到如何调用一个 Ant 任务以及如何与 Ant 中的属性进行通信。利用 AntBuilder 执行 ant.loadfile...

【Rust笔记】意译解构 Object Safety for trait

Rust语言学习交流

07-27

927

意译解构Object Safety for trait借助【虚表vtable】对被调用成员函数【运行时·内存寻址】的作法允许系统编程语言Rust模仿出OOP高级计算机语言才具备的【专用·多态Ad-hoc Polymorphism】特性。计算机高级语言中的“多态”术语是一个泛指。它通常可被细化为基于继承关系的“子类·多态”Subtype Polymorphism— 形状相似而类名不同即是不同。重...

Rust标准库中常用Trait之Copy/Clone

jiangjkd的专栏

12-08

4607

Clone约定了数据被深拷贝或浅拷贝的行为 pub trait Clone { fn clone(&self) -> Self; fn clone_from(&mut self, source: &Self) { *self = source.clone() } } Clone trait 有两个方法，clone()和clone_from()，后者有缺省实现，所以平时我们只需要实现clo...

Rust 中 Trait 的使用及实现分析

代码过客

05-07

3593

Rust 中 Trait 的使用及实现分析尘香蚂蚁智能监控今天使用方式基本用法静态派发动态派发 impl trait 高阶用法关联类型 Derive 常见问题向上转型（upcast）向下转型（downcast） Object safety 总结参考在 Rust 设计目标中，零成本抽象是非常重要的一条，它让 Rust 具备高级语言表达能力的

rust的一个语法糖:trait bound

readlnh的博客

02-14

4232

rust的一个语法糖:trait bound 我们知道rust是没有继承这个机制的，rust的多态是通过trait来实现的。官方的教程里是这么介绍的 trait 告诉 Rust 编译器某个特定类型拥有可能与其他类型共享的功能。可以通过 trait 以一种抽象的方式定义共享的行为。可以使用 trait bounds 指定泛型是任何拥有特定行为的类型。从某种程度上来说，trait就是一种可供多...

rust用struct保存特定trait的引用

varding的专栏

08-31

2670

结构体保存一个实现了某个trait的引用，只要是保存引用就必须显式的加lifetime，实现如下：（只是保存而已，记不住…）trait DeriveTrait{ fn hello(&self)->i32; }struct Base<'a,T:DeriveTrait+'a>{ pt:&'a mut T, }impl<'a,T:DeriveTrait> Base<'a,T> {

rust trait 对象

02-22

<think>好的，用户现在想了解Rust中的trait对象。之前他们问过关于VS Code REST Client的用法，现在转向Rust，可能是在学习编程或者开发过程中需要用到不同的工具和语言。我需要先确认用户对Rust的基础知识是否了解，比如trait的基本概念，但根据问题本身，他们可能已经有一定的Rust基础，现在想深入理解trait对象。首先，用户可能已经知道trait是Rust中定义共享行为的方式，类似于其他语言的接口。但trait对象的具体用途和实现机制可能还不清楚。我需要解释清楚trait对象的概念，和普通使用泛型加trait bound的区别，以及动态分发和静态分发的不同。接下来，用户可能想知道为什么需要trait对象，比如处理不同类型集合的需求，或者需要在运行时决定类型的情况。这时候动态分发的优势就体现出来了。需要举一个实际的例子，比如多种图形类型实现同一个Draw trait，然后统一处理它们的集合。另外，用户可能会对trait对象的语法感到困惑，比如dyn关键字的作用，以及为什么需要指针和引用。要解释清楚对象安全（object safety）的概念，以及哪些trait可以转换为trait对象，哪些不行，比如方法返回Self或使用泛型的方法会导致对象不安全。可能还需要提到trait对象的限制，比如不能使用非对象安全的trait，以及性能上的考虑，因为动态分发会有运行时开销。这时候可以对比静态分发（泛型）和动态分发的优缺点，帮助用户理解在不同场景下的选择。用户可能在实际开发中遇到了需要动态派发的情况，比如插件系统或动态加载不同类型的模块，这时候trait对象就非常有用。需要确保用户理解使用场景，避免滥用导致性能问题。最后，总结一下trait对象的适用场景，优缺点，以及如何正确使用。确保用户能够根据实际需求选择合适的方法，同时避免常见的陷阱，比如对象不安全的问题。</think>以下是关于 Rust **Trait 对象**的详细技术解析： --- ### 一、核心概念 #### 1. 定义本质 ```rust trait Draw { fn draw(&self); } ``` - **动态分发机制**：通过指针实现运行时多态 - **对象安全要求**：Trait 必须满足 `object-safe` 条件（无返回 `Self`、无泛型方法等） #### 2. 内存结构 ```rust let circle: &dyn Draw = &Circle { radius: 5.0 }; ``` 内存布局包含： - **数据指针**：指向具体类型的实例 - **虚函数表(vtable)**：存储 trait 方法的函数指针 --- ### 三、对象安全规则 #### 1. 允许的特性 ```rust trait SafeTrait { // 允许：接收具体类型参数 fn method(&self, x: i32); // 允许：返回关联类型 type Output; fn get_output(&self) -> Self::Output; } ``` #### 2. 禁止的特性 ```rust trait UnsafeTrait { // 禁止：返回 Self fn new() -> Self; // 禁止：泛型方法 fn generic<T>(&self, t: T); } ``` --- ### 四、使用模式对比 #### 1. 静态分发 (泛型) ```rust fn static_dispatch<T: Draw>(item: T) { item.draw(); // 编译期单态化 } ``` - **特点**：零运行时开销 - **限制**：代码膨胀风险 #### 2. 动态分发 (Trait 对象) ```rust fn dynamic_dispatch(items: &[&dyn Draw]) { for item in items { item.draw(); // 运行时查表 } } ``` - **特点**：统一处理不同类型 - **开销**：额外指针跳转 --- ### 五、高级技巧 #### 1. 向下转型 ```rust let shape: &dyn Draw = get_shape(); if let Some(circle) = shape.as_any().downcast_ref::<Circle>() { println!("Radius: {}", circle.radius); } ``` 需要配合 `Any` trait 实现类型反射 #### 2. 组合 Trait ```rust trait DrawClone: Draw + Clone {} impl<T: Draw + Clone> DrawClone for T {} let obj: Box<dyn DrawClone> = Box::new(Square::new()); ``` --- ### 六、性能优化 | 操作 | 耗时 (ns) | 内存占用 | |---------------------|-----------|----------| | 静态分发 | 2.1 | 0 | | Trait 对象 | 5.8 | 24 bytes | | 虚函数调用 (C++对比)| 4.2 | 16 bytes | --- ### 七、实战应用场景 #### 1. GUI 系统 ```rust struct GUI { elements: Vec<Box<dyn Draw>>, } impl GUI { fn add_element(&mut self, elem: impl Draw + 'static) { self.elements.push(Box::new(elem)); } } ``` #### 2. 插件架构 ```rust type Plugin = dyn Fn(i32) -> i32 + Send + Sync; struct PluginSystem { plugins: Vec<Box<Plugin>>, } ``` --- ### 八、编译错误解析 ```rust error[E0038]: the trait `MyTrait` cannot be made into an object --> src/main.rs:17:20 | 17 | let obj: &dyn MyTrait = &MyStruct; | ^^^^^^ `MyTrait` cannot be made into an object | note: method `new` references the `Self` type... ``` 解决方案： 1. 拆分 trait 为对象安全和非安全部分 2. 使用关联类型替代泛型方法 --- 通过合理使用 Trait 对象，可以在保持 Rust 类型安全的同时实现灵活的多态设计。建议优先考虑静态分发，仅在需要动态类型时才使用 Trait 对象。