实现Rust Trait类型 那么该类型的引用也实现了tr

如果你在一个类型上实现了一个trait，然后引用了这个类型，那么类型的引用也实现了这个trait吗？

有一段时间我是这么想的！但实际上并不是，有时候Rust为你做的事情可能会混淆幕后真正发生的事情。

为了演示，让我从一个名为Speaker的trait和一个实现该trait的空struct开始：

///定义一个trait，有一个speak方法。
traitSpeaker{
fnspeak(&self);
}

/// BasicSpeaker是一个空结构体，只是为了实现Speaker。
structBasicSpeaker;

///BasicSpeakers实现speak方法
implSpeakerforBasicSpeaker{
fnspeak(&self){
println!("Hello!");
}
}

//创建BasicSpeaker结构体
letspeaker=BasicSpeaker;
//调用在BasicSpeaker上定义的speak方法
speaker.speak();

确实如此，它就会输出“Hello!”。

如果我引用了一个BasicSpeaker，我仍然可以对它调用speak，因为Rust会自动解除对变量的引用。所以下面的代码也可以工作：

//定义一个BasicSpeaker的引用
letspeaker_ref:&BasicSpeaker=&speaker;
//通过引用调用在BasicSpeaker上定义的speak方法
speaker_ref.speak();

这可能会让你认为BasicSpeaker实现了Speaker，引用&BasicSpeaker也实现了Speaker。也许是Rust的魔法？

让我们更具体地测试一下，定义一个接受impl Speaker类型形参的函数。

fnspeak_to(s:implSpeaker){
s.speak();
}

fnmain(){
//创建BasicSpeaker结构体
letspeaker=BasicSpeaker;
//将speaker传递给新函数
speak_to(speaker);
}

这是可行的，因为BasicSpeaker实现了Speaker特性。

让我们尝试同样的事情，但这次是传递BasicSpeaker的引用：

//定义一个BasicSpeaker的引用
letspeaker_ref:&BasicSpeaker=&speaker;
//将引用传递给'speak_to'
speak_to(speaker_ref);

error[E0277]:thetraitbound`&BasicSpeaker:Speaker`isnotsatisfied
-->src/main.rs:31:14
|
31|speak_to(speaker_ref);
|--------^^^^^^^^^^^thetrait`Speaker`isnotimplementedfor`&BasicSpeaker`
||
|requiredbyaboundintroducedbythiscall
|
=help:thetrait`Speaker`isimplementedfor`BasicSpeaker`
note:requiredbyaboundin`speak_to`
-->src/main.rs:16:21
|
16|fnspeak_to(s:implSpeaker){
|^^^^^^^requiredbythisboundin`speak_to`

Formoreinformationaboutthiserror,try`rustc--explainE0277`.

最初的错误消息是模糊的，但是第一个代码块旁边的消息更清晰：“&BasicSpeaker没有实现trait Speaker”。

前面的代码示例演示了你可以在引用上调用没有在该引用上实现的方法，因为Rust会默默地为你解引用该值。Rust是这样做的：

//Rust将'speaker_ref.speak()'转换为
(*speaker_ref).speak();

直接的解决方案

最直接的解决方案是在BasicSpeaker的引用上实现Speaker，如下所示：

implSpeakerfor&BasicSpeaker{
fnspeak(&self){
println!("Hello!");
}
}

implSpeakerfor&BasicSpeaker{
fnspeak(&self){
return(**self).speak();
}
}

很明显，我必须对self进行两次解引用，因为该函数接受&self，而self是&BasicSpeaker。这意味着参数是一个&&BasicSpeaker，必须对其进行两次解引用才能获得实现speak()的BasicSpeaker。

好了，现在没有那么多代码复制了，但是还有另一个问题，如果我想定义另一个Speaker，比如NamedSpeaker，那么我必须编写两次代码——一次为NamedSpeaker，一次为&NamedSpeaker。

用泛型Trait解决这个问题

我可以写一个泛型的实现：“如果一个struct T实现了Speaker，那么写一个用于&T的Speaker实现。”

///所有实现Speaker的事物的引用也必须是Speaker的。
implSpeakerfor&T
where
T:Speaker,
{
fnspeak(&self){
return(**self).speak();
}
}

implSpeakerfor&T{
fnspeak(&self){
return(**self).speak();
}
}

//获取一个对BasicSpeaker的可变引用
letspeaker_mut_ref:&mutBasicSpeaker=&mutspeaker;
//通过可变引用，调用在BasicSpeaker上定义的speak方法
speak_to(speaker_mut_ref);

///所有实现Speaker的事物的可变引用也必须是Speaker的。
implSpeakerfor&mutT
where
T:Speaker,
{
fnspeak(&self){
return(**self).speak();
}
}

implSpeakerforBox
where
T:Speaker,
{
fnspeak(&self){
return(**self).speak();
}
}