如果你在一個類型上實現了一個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實現?！?/p>

///所有實現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();
}
}