實現(xiàn)Rust Trait類型 那么該類型的引用也實現(xiàn)了trait嗎？

如果你在一個類型上實現(xiàn)了一個trait，然后引用了這個類型，那么類型的引用也實現(xiàn)了這個trait嗎？

有一段時間我是這么想的！但實際上并不是，有時候Rust為你做的事情可能會混淆幕后真正發(fā)生的事情。

為了演示，讓我從一個名為Speaker的trait和一個實現(xiàn)該trait的空struct開始：

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

/// BasicSpeaker是一個空結構體，只是為了實現(xiàn)Speaker。
structBasicSpeaker;

///BasicSpeakers實現(xiàn)speak方法
implSpeakerforBasicSpeaker{
fnspeak(&self){
println!("Hello!");
}
}

//創(chuàng)建BasicSpeaker結構體
letspeaker=BasicSpeaker;
//調用在BasicSpeaker上定義的speak方法
speaker.speak();

確實如此，它就會輸出“Hello!”。

如果我引用了一個BasicSpeaker，我仍然可以對它調用speak，因為Rust會自動解除對變量的引用。所以下面的代碼也可以工作：

//定義一個BasicSpeaker的引用
letspeaker_ref:&BasicSpeaker=&speaker;
//通過引用調用在BasicSpeaker上定義的speak方法
speaker_ref.speak();

這可能會讓你認為BasicSpeaker實現(xiàn)了Speaker，引用&BasicSpeaker也實現(xiàn)了Speaker。也許是Rust的魔法？

讓我們更具體地測試一下，定義一個接受impl Speaker類型形參的函數(shù)。

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

fnmain(){
//創(chuàng)建BasicSpeaker結構體
letspeaker=BasicSpeaker;
//將speaker傳遞給新函數(shù)
speak_to(speaker);
}

這是可行的，因為BasicSpeaker實現(xiàn)了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沒有實現(xiàn)trait Speaker”。

前面的代碼示例演示了你可以在引用上調用沒有在該引用上實現(xiàn)的方法，因為Rust會默默地為你解引用該值。Rust是這樣做的：

//Rust將'speaker_ref.speak()'轉換為
(*speaker_ref).speak();

直接的解決方案

最直接的解決方案是在BasicSpeaker的引用上實現(xiàn)Speaker，如下所示：

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

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

很明顯，我必須對self進行兩次解引用，因為該函數(shù)接受&self，而self是&BasicSpeaker。這意味著參數(shù)是一個&&BasicSpeaker，必須對其進行兩次解引用才能獲得實現(xiàn)speak()的BasicSpeaker。

好了，現(xiàn)在沒有那么多代碼復制了，但是還有另一個問題，如果我想定義另一個Speaker，比如NamedSpeaker，那么我必須編寫兩次代碼——一次為NamedSpeaker，一次為&NamedSpeaker。

用泛型Trait解決這個問題

我可以寫一個泛型的實現(xiàn)：“如果一個struct T實現(xiàn)了Speaker，那么寫一個用于&T的Speaker實現(xiàn)?！?/p>

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

///所有實現(xiàn)Speaker的事物的可變引用也必須是Speaker的。
implSpeakerfor&mutT
where
T:Speaker,
{
fnspeak(&self){
return(**self).speak();
}
}

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