ฉันเรียนรู้ / ทดลองกับสนิมและในความสง่างามทั้งหมดที่ฉันพบในภาษานี้มีลักษณะเฉพาะอย่างหนึ่งที่ทำให้ฉันงงงัน
ตัวชี้การเกิดสนิมโดยอัตโนมัติเมื่อทำการเรียกเมธอด ฉันทำแบบทดสอบเพื่อกำหนดพฤติกรรมที่แน่นอน:
struct X { val: i32 }
impl std::ops::Deref for X {
type Target = i32;
fn deref(&self) -> &i32 { &self.val }
}
trait M { fn m(self); }
impl M for i32 { fn m(self) { println!("i32::m()"); } }
impl M for X { fn m(self) { println!("X::m()"); } }
impl M for &X { fn m(self) { println!("&X::m()"); } }
impl M for &&X { fn m(self) { println!("&&X::m()"); } }
impl M for &&&X { fn m(self) { println!("&&&X::m()"); } }
trait RefM { fn refm(&self); }
impl RefM for i32 { fn refm(&self) { println!("i32::refm()"); } }
impl RefM for X { fn refm(&self) { println!("X::refm()"); } }
impl RefM for &X { fn refm(&self) { println!("&X::refm()"); } }
impl RefM for &&X { fn refm(&self) { println!("&&X::refm()"); } }
impl RefM for &&&X { fn refm(&self) { println!("&&&X::refm()"); } }
struct Y { val: i32 }
impl std::ops::Deref for Y {
type Target = i32;
fn deref(&self) -> &i32 { &self.val }
}
struct Z { val: Y }
impl std::ops::Deref for Z {
type Target = Y;
fn deref(&self) -> &Y { &self.val }
}
#[derive(Clone, Copy)]
struct A;
impl M for A { fn m(self) { println!("A::m()"); } }
impl M for &&&A { fn m(self) { println!("&&&A::m()"); } }
impl RefM for A { fn refm(&self) { println!("A::refm()"); } }
impl RefM for &&&A { fn refm(&self) { println!("&&&A::refm()"); } }
fn main() {
// I'll use @ to denote left side of the dot operator
(*X{val:42}).m(); // i32::m() , Self == @
X{val:42}.m(); // X::m() , Self == @
(&X{val:42}).m(); // &X::m() , Self == @
(&&X{val:42}).m(); // &&X::m() , Self == @
(&&&X{val:42}).m(); // &&&X:m() , Self == @
(&&&&X{val:42}).m(); // &&&X::m() , Self == *@
(&&&&&X{val:42}).m(); // &&&X::m() , Self == **@
println!("-------------------------");
(*X{val:42}).refm(); // i32::refm() , Self == @
X{val:42}.refm(); // X::refm() , Self == @
(&X{val:42}).refm(); // X::refm() , Self == *@
(&&X{val:42}).refm(); // &X::refm() , Self == *@
(&&&X{val:42}).refm(); // &&X::refm() , Self == *@
(&&&&X{val:42}).refm(); // &&&X::refm(), Self == *@
(&&&&&X{val:42}).refm(); // &&&X::refm(), Self == **@
println!("-------------------------");
Y{val:42}.refm(); // i32::refm() , Self == *@
Z{val:Y{val:42}}.refm(); // i32::refm() , Self == **@
println!("-------------------------");
A.m(); // A::m() , Self == @
// without the Copy trait, (&A).m() would be a compilation error:
// cannot move out of borrowed content
(&A).m(); // A::m() , Self == *@
(&&A).m(); // &&&A::m() , Self == &@
(&&&A).m(); // &&&A::m() , Self == @
A.refm(); // A::refm() , Self == @
(&A).refm(); // A::refm() , Self == *@
(&&A).refm(); // A::refm() , Self == **@
(&&&A).refm(); // &&&A::refm(), Self == @
}( สนามเด็กเล่น )
ดังนั้นดูเหมือนว่ามากหรือน้อย:
- คอมไพเลอร์จะแทรกตัวดำเนินการอ้างอิงจำนวนมากเท่าที่จำเป็นเพื่อเรียกใช้เมธอด
- คอมไพเลอร์เมื่อแก้ไขวิธีการประกาศโดยใช้
&self(โทรโดยอ้างอิง):- ก่อนอื่นให้ลองเรียกหาข้ออ้างอิงเดียว
self - จากนั้นลองโทรหาประเภทที่แน่นอนของ
self - จากนั้นพยายามแทรกตัวดำเนินการอ้างอิงจำนวนมากเท่าที่จำเป็นสำหรับการแข่งขัน
- ก่อนอื่นให้ลองเรียกหาข้ออ้างอิงเดียว
- วิธีการประกาศโดยใช้
self(เรียกค่าตาม) สำหรับประเภทTพฤติกรรมราวกับว่าพวกเขาได้รับการประกาศใช้&self(โทรโดยอ้างอิง) สำหรับประเภท&Tและเรียกการอ้างอิงถึงสิ่งที่อยู่ทางด้านซ้ายของผู้ประกอบการจุด - กฎระเบียบดังกล่าวข้างต้นจะถูกทดสอบครั้งแรกกับดิบในตัว dereferencing และถ้าไม่มีการแข่งขันเกินที่มี
Derefลักษณะที่ถูกนำมาใช้
กฎการลงทะเบียนอัตโนมัติที่แน่นอนคืออะไร ใครสามารถให้เหตุผลที่เป็นทางการสำหรับการตัดสินใจออกแบบได้หรือไม่?
1
ฉันเคยโพสต์สิ่งนี้ไปยังsubreddit ของ Rustเพื่อหวังคำตอบที่ดี!
—
Shepmaster
เพื่อความสนุกสนานเป็นพิเศษให้ลองทำการทดสอบซ้ำในชื่อสามัญและเปรียบเทียบผลลัพธ์
—
2665887