目前为止最抽象的吧

反复入门几次就不懵逼了...

昨天一遍,今天一遍,不懵逼了😉

+1,一脸懵逼

其实就是多态,如果不用dyn就是静态多态,在编译期参数的类型编译成不同的函数,一个类型一个函数。如果用了dyn就是运行时多态,通过查输入对象的vtable获取对应的方法

重点太多啦 :)

这个dyn到底是什么啊......

这个dyn到底是什么啊......

dynamic, 动态的

谢谢🙏

fn draw3(x: &impl Draw) {
 x.draw();
}
fn main() {
 draw3(&1.1f64);
 draw3(&8u8);
}

这里是可以静态分发的,我的理解是,在一个流程里类型推导有歧义的话,才一定要用动态分发,就像 returns_summarizable 那样

在你说的这个例子里 自然是可以用泛型来做静态分发的
请回头考虑文章中开始提出动态分发时的举例是用作返回值的场景

如果你的Box里面装的是一个trait object呢?这就是动态分发了。

你的例子用静态分发没问题.
这里主要要看 Screen::components 的类型是怎么定义的.

一开始的需求就是:

1. 对象集合类型/个数 并不能事先明确地知道
2. 这个组件可能是三方实现的. (自定义组件)
3. 需要循环 draw

然后, 即便如此, 这种场景就不能做到静态分发吗? 是的,因为在编译器是不可能知道 componets 是怎么收集起来的. 那类型就不可能猜的出来了

泛型+特征约束是静态分发的,特征对象是动态分发的。两个应用的场景不同。

可以把代码转换成使用Where约束:
fn add(a : T, b : T ) -> T
Where T: Add<T,Output=T>
这样比较好理解

放弃了1年之后再回来看了一遍 看懂了

我的理解是<T: Add<T, Output=T>>的意思是泛型T实现Add特征,并且T和T进行add操作返回值也是T。<T, Output=T>相当于对T: Add进行进一步说明Add的参数和返回值是什么。

尝试自己写了一个trait,感觉这里可能是这样的, 不过我也没求证过 Add 内的具体实现,希望有懂的大佬👻

// @note: 类似的Add特征
trait PAdd {
 type OutputPAdd;
 fn add(self, rhs: Self) -> Self::OutputPAdd;
}
#[derive(Debug, Clone)]
struct Point3d<T: std::ops::Add> {
 x: T,
 y: T,
 z: T,
}
// @note: 应该解读为为 泛型 Point3d<T> 实现 PAdd 特征,
// 而 T 这个类型要满足 std::ops::Add 特征
impl<T> PAdd for Point3d<T>
where
 T: std::ops::Add<T, Output = T>, 
 // 这里的Output就是Add这个特征里面定义的一个type
 // 类似PAdd的type
{
 type OutputPAdd = Point3d<T>;
 fn add(self, rhs: Point3d<T>) -> Self::OutputPAdd {
 Point3d {
 x: self.x + rhs.x,
 y: self.y + rhs.y,
 z: self.z + rhs.z,
 }
 }
}
fn main()
{
 let p1 = Point3d {
 x: 1.1f32,
 y: 1.1,
 z: 1.1,
 };
 let p2 = p1.clone();
 // 由于 + 本身是 std::opts::Add 特征的 add 函数实现,
 // 而我们实现的是 PAdd 特征,所以这里只能显式调用
 let p3 = p1.add(p2);
 dbg!(p3);
}

看一下Add的官方文档就懂了,trait Add实现其实很简单:

pub trait Add<Rhs = Self> {
 type Output;
 // Required method
 fn add(self, rhs: Rhs) -> Self::Output;
}

trait Add唯一的作用就是加法运算符 + 。下面是使用泛型实现 Add 特征的相同 Point 结构的示例:

use std::ops::Add;
#[derive(Debug, Copy, Clone, PartialEq)]
struct Point<T> {
 x: T,
 y: T,
}
// Notice that the implementation uses the associated type `Output`.
// 注意,实现使用了关联类型`Output`。
impl<T: Add<Output = T>> Add for Point<T> {
 type Output = Self;
 fn add(self, other: Self) -> Self::Output {
 Self {
 x: self.x + other.x,
 y: self.y + other.y,
 }
 }
}
assert_eq!(Point { x: 1, y: 0 } + Point { x: 2, y: 3 },
 Point { x: 3, y: 3 });

说白了就是需要规定 + 运算之后返回的类型到底是什么,Output是trait Add 中必须明确指定的一项。

这样子就好了
fn returns_summarizable(switch: bool) -> Box{
if b {
Box::new(Post{...})
}else{
Box::new(Weibo{...})
}

}

这样子就好了
fn returns_summarizable(switch: bool) -> Box{
if b {
Box::new(Post{...})
}else{
Box::new(Weibo{...})
}

}

Add trait 里面定义了一个关联类型的泛型,比较特殊,

pub trait Add<Rhs = Self> {
 type Output;
}

所以在声明的时候,也需要声明关联类型的类型。

好的,建议收到

还是有很大区别的,特征trait 就是一种共享行为的抽象。 可以为任何类型,实现! 比java接口灵活多了!,但是,由于孤儿规则。 特化还没实现,也有很多限制! 哎,感觉抽象(继承)就不是很好实现。要不就要写特征宏,把抽象的的一种繁琐,转化为另外一种繁琐!

m1 pro 也不卡,可以冲

哈哈 什么 mi max! 还是我的3090Ti 无敌!!

卡点? m1 max吗? 哈哈,多练练就有感觉了

同....真第一个卡点。

好痛苦

类似虚函数?
声明的类型是父类,实际绑定的是子类
用(表面)父类调用非 final 方法时,会动态派发到子类相同方法执行

+多态

+1,感觉和C++的多态在效果上面很相像

子类可以继承父类的成员变量,trait不能定义成员变量。

不是严格的继承, 顶多算是广度实现,他只是一个维度, 比说说我这个trait 会返回一堆实现struct 、 enum 什么的,我可以用dyn 动态获取其引用,封装起来, 但是获取的实例只能操作方法,不与原生struct、enum有关

Java那个接口 实现也是虚函数表, 封装了一下隐藏了细节
这一章写的烂完了..... 新手别说看蒙了 我老鸟都看蒙了...... 后面反应过来 就这
写的是什么勾八

加了这个能确保你在实现Point的Add特征时,其内部的T是实现了Add特征的。

more graceful way to implement this method

pub fn largest<T>(list: &[T]) -> &T
 where T: Ord {
 list.iter()
 .map(|x| x)
 .max()
 .expect("find largest item failed")
}

你这个太实战了,不适合用来讲解 :D

map 多余了

pub fn largest<T>(list: &[T]) -> &T
 where T: Ord {
 list.iter().max().unwrap()
}

没看明白这里为什么把&item修改为item,能解释一下么?

list.iter()返回的是&T类型,&item时实际是&item与&T匹配,item的类型是T,改成item后item的类型就是&T了,可以复制到vscode中,观察修改前后自动推导的item的类型

再结合习题看本章,有几个疑问

代码 1

trait MyTrait {
 fn f(&self) -> Self;
}
impl MyTrait for u32 {
 fn f(&self) -> u32 { 42 }
}
impl MyTrait for String {
 fn f(&self) -> String { self.clone() }
}
fn my_function(x: impl MyTrait) -> impl MyTrait {
 x.f()
}
fn main() {
 my_function(13_u32);
 my_function(String::from("abc"));
}

Q1:以上代码中 trait MyTrait 为什么可以返回值可以是Self?这不就违背了特征对象的限制么?
A1:猜测原因是在此例中,MyTrait 仅为特征,而非特征对象,特征对象在使用上应当以 Box<dyn MyTrait> 或 dyn MyTrait 形式,本例中未涉及,因此不需要受特征对象的限制。

代码 2

pub trait Summary {
 fn summarize(&self) -> String;
}
pub struct Post {
 pub title: String, // 标题
 pub author: String, // 作者
 pub content: String, // 内容
}
impl Summary for Post {
 fn summarize(&self) -> String {
 format!("文章{}, 作者是{}", self.title, self.author)
 }
}
pub struct Weibo {
 pub username: String,
 pub content: String
}
impl Summary for Weibo {
 fn summarize(&self) -> String {
 format!("{}发表了微博{}", self.username, self.content)
 }
}
fn returns_summarizable(switch: bool) -> impl Summary {
 if switch {
 Post {
 title: String::from(
 "Penguins win the Stanley Cup Championship!",
 ),
 author: String::from("Iceburgh"),
 content: String::from(
 "The Pittsburgh Penguins once again are the best \
 hockey team in the NHL.",
 ),
 }
 } else {
 Weibo {
 username: String::from("horse_ebooks"),
 content: String::from(
 "of course, as you probably already know, people",
 ),
 }
 }
}
fn main() {
 let post = Post{title: "Rust语言简介".to_string(),author: "Sunface".to_string(), content: "Rust棒极了!".to_string()};
 let weibo = Weibo{username: "sunface".to_string(),content: "好像微博没Tweet好用".to_string()};
 println!("{}",post.summarize());
 println!("{}",weibo.summarize());
	returns_summarizable(true);
	returns_summarizable(false);
}

Q2:同样代码 2 的 fn returns_summarizable(switch: bool) -> impl Summary; 函数返回值使用了特征约束,代码而会有问题,而代码 1 的 fn my_function(x: impl MyTrait) -> impl MyTrait; 却没问题,这是为什么?
A2: 有人能帮忙解答一下吗?

针对Q1:你回答的没毛病,MyTrait 仅为特征不受特征对象约束
针对Q2:代码2中fn returns_summarizable(switch: bool) -> impl Summary; 函数返回值使用了特征约束,并非特征对象,这其实就是泛型的一个语法糖形式,该签名完整写法如下:
fn returns_summarizable<T:Summary>(switch: bool) -> T;
函数返回值就只能为一种确定类型,所以该函数编译报错

特征对象的限制:
对于,方法没有任何泛型参数(不能有哈?),做如下理解:如果 Trait 中的方法本身是泛型的(例如 fn transform(&self, val: U)),将意味着该方法可能有无限种可能的实例化(每种 U 都是一个不同的方法)。vtable 需要一个固定数量和结构的槽位,无法容纳无限多的方法。

再者,如果方法签名中包含泛型参数 S: Into 这样的绑定,其中 Self 是一个类型参数,编译器就无法确定其具体类型,也就无法在 vtable 中为这个方法提供一个固定的函数指针。

另外需要补充:

1. 如果一个 Trait 包含了不带 self 参数的关联函数,那么这个 Trait 就不能被用来创建特征对象。
   为什么?: 特征对象的核心机制是通过 vtable 来实现运行时方法分发。vtable 是一张函数指针表,这些函数指针都是实例方法(即需要一个 self 参数)。关联函数(静态方法)不操作特定的实例,它们不需要 self 参数。因此,vtable 无法为不带 self 的关联函数提供一个入口,也没有实例可以"调度"。

完整来看:
一个 Trait 如果包含以下任何一种情况,就会被认为不安全,从而不能被用来创建特征对象 (dyn Trait):
方法(Method)返回 Self: fn clone_self(&self) -> Self;

无法知道返回的具体类型和大小。
方法(Method)有 Self 类型参数(除了接收者 self): fn from_self(&self, other: Self);

无法在 vtable 中为这种不确定类型的参数生成调用签名。
方法(Method)是泛型的: fn transform(&self, value: T) -> T;

vtable 需要固定数量的槽位,无法为无限种泛型方法变体提供入口。
(例外:泛型参数被约束为 Sized 或 Copy 时有时是对象安全的,但这个复杂。)
关联函数(Associated Function,即不带 self 参数的方法):

通常,Trait 中的关联函数本身就不能被通过特征对象来调用。 因此,如果 Trait 只有关联函数而没有方法,它就不能被用作特征对象。
尤其当关联函数返回 Self 或接受 Self 参数时:fn new() -> Self; 或 fn default() -> Self;。这更明确地违反了对象安全的原则,因为在编译时无法知道要创建或操作的 Self 具体是什么。

用起来差不多一样。从原理上看Rust的trait和所有权是有关的。