एक स्वामित्व सूचक

Question

स्थानांतरित करने के लिए कैसे संदर्भ के लिए, मैं जंग 0.7 का उपयोग कर रहा हूँ।

मैं एक स्वामित्व लिंक्ड सूची का उपयोग कर एक ढेर कार्यान्वयन के लिए कोशिश कर रहा हूँ और मैं मुसीबत में चल रहा हूँ।

trait Stack<T> { 
    fn push(&mut self, item : T); 
    fn pop(&mut self) -> Option<T>; 
} 

enum Chain<T> { 
    Link(T, ~Chain<T>), 
    Break 
} 

impl<T> Stack<T> for ~Chain<T> { 
    fn push(&mut self, item : T) { 
     *self = ~Link(item, *self); 
    } 
    fn pop(&mut self) -> Option<T> { 
     None 
    } 
} 

मैं rustc stack.rs करने का प्रयास करते मैं निम्नलिखित त्रुटि मिलती है:

stack.rs:13:28: 13:34 error: cannot move out of dereference of & pointer 
stack.rs:13   *self = ~Link(item, *self); 
             ^~~~~~ 

मैं नहीं जानता कि मैं यह कैसे काबू पाने सकता है या क्या मैं अलग तरह से कर सकता है यह अनुमति देने के लिए। ऐसा लगता है जैसे मैं कामयाब संकेत का उपयोग किए बिना इस डेटा संरचना बनाने के लिए सक्षम होना चाहिए, लेकिन मैं बात इस तरह की पर दस्तावेज़ीकरण का एक बहुत नहीं देखा है। ।

Answer 1

स्वयं (जो मुझे लगता है कि इसे से बाहर एक नई बात का निर्माण, Link(item, *self)implies a move के मामले में भी शामिल है से या तो काम इसका मतलब यह है कि नए Link निर्माण है कि स्वयं, बेकार हो जाता है की प्रक्रिया में है क्योंकि:

"After a value has been moved, it can no longer be used from the source location and will not be destroyed there."

सही रास्ता ™ शायद सबसे अच्छा क्या this example in the stdlib में किया है द्वारा प्रलेखित है। यह एक दोगुना लिंक्ड सूची है, और यह किया जाता है, लेकिन यह अस्थायी है, और मुझे आशा है कि नि: शुल्क कॉपी। वहाँ भी list of useful container types, भी है।

मैं आपके डेटा के इस अपरिवर्तनीय संस्करण को प्रबंधित करने का प्रबंधन किया संरचना, हालांकि काम कर रहा है।

trait Stack<T> { 
    fn push(self, item : T) -> Self; 
    fn pop(self)   -> Option<(T, Self)>; 
    fn new()    -> Self; 
} 

#[deriving(Eq, ToStr)] 
enum Chain<T> { 
    Link(T, ~Chain<T>), 
    Break 
} 

impl<T> Stack<T> for Chain<T> { 
    fn push(self, item : T) -> Chain<T> { 
     Link(item, ~self) 
    } 
    fn pop(self)   -> Option<(T, Chain<T>)> { 
     match self { 
      Link(item, ~new_self) => Some((item, new_self)), 
      Break     => None 
     } 
    } 
    fn new()    -> Chain<T> { 
     Break 
    } 
} 

fn main() { 
    let b : ~Chain<int> = ~Stack::new(); 
    println(b.push(1).push(2).push(3).to_str()); 
}