रेफरी और इस स्थिति में क्या अंतर है?

Question

इस कोड के साथ क्या गलत है?

let vec = vec![1, 2, 3]; 
let &y = &vec; 

error: cannot move out of borrowed content 
let &y = &vec; 
note: attempting to move value to here 
let &y = &vec; 

और यह सही क्यों है? सब से

let vec = vec![1, 2, 3]; 
let ref y = &vec; 

Answer 1

पैटर्न बाध्यकारी कुछ करने के लिए का उपयोग कर प्राप्त कर सकते हैं;)

आदेश में समझने के लिए संकलक करता है, तो आप let _:() = ...; चाल का उपयोग कर सकते हैं। () प्रकार के एक चर को असाइन करके, आप संकलक को एक त्रुटि संदेश मुद्रित करने के लिए मजबूर करते हैं जो आपको अपने चर के लिए अनुमानित प्रकार देता है।

---

पहले उदाहरण में:

let vec = vec![1, 2, 3]; 
let &y = &vec; 
let _:() = y; 

हम पाते हैं:

<anon>:5:17: 5:18 error: mismatched types: 
expected `()`, 
    found `collections::vec::Vec<_>` 
(expected(), 
    found struct `collections::vec::Vec`) [E0308] 
<anon>:5  let _:() = y; 
         ^
<anon>:5:17: 5:18 help: see the detailed explanation for E0308 

y के प्रकार Vec<i32> है।

1. एक अस्थायी
2. y, जो क्योंकि vec पहले से ही लिया गया है, मना किया है में vec स्थानांतरित करने के लिए प्रयास कर रहा है में उधार vec:

   क्या इसका मतलब है कि आप कर रहे हैं।

बराबर सही कोड होगा:

let vec = vec![1, 2, 3]; 
let y = vec; 

---

दूसरे उदाहरण में:

let vec = vec![1, 2, 3]; 
let ref y = &vec; 
let _:() = y; 

हम पाते हैं:

<anon>:5:17: 5:18 error: mismatched types: 
expected `()`, 
    found `&&collections::vec::Vec<_>` 
(expected(), 
    found &-ptr) [E0308] 
<anon>:5  let _:() = y; 
         ^
<anon>:5:17: 5:18 help: see the detailed explanation for E0308 

इस प्रकार y&&Vec<i32> है।

यह देखते हैं कि let ref a = b; आमतौर पर let a = &b; के बराबर है, और इसलिए इस मामले में: let y = &&vec;।

ref विनाश के लिए बनाया गया है; उदाहरण के लिए, यदि आप था:

let vec = Some(vec![1, 2, 3]); 
if let Some(ref y) = vec { 
} 

आप ref यहाँ का प्रयोग करेंगे yकरने के लिए बाध्य करने में सक्षम होना बिना आगे बढ़ भले ही vec यहाँ लिखें Option<Vec<i32>> है। वास्तव में, ref का उद्देश्य के भीतर एक मौजूदा वस्तु को नष्ट करने के दौरान संदर्भ लेना है।

सामान्यतः, let कथन में, आप ref का उपयोग नहीं करेंगे।

Answer 2

पहले, आप अपने काम करने के उदाहरण में & जरूरत नहीं है। यदि आप इसका उपयोग करते हैं, तो आप &&Vec<_> के साथ समाप्त होते हैं, जिसकी आपको वास्तव में आवश्यकता नहीं है।

let vec = vec![1, 2, 3]; 
let ref y = vec; 

आपके पहले कोड के साथ समस्या यह है कि आप एक ही समय में दो चीजें कर रहे हैं। यह अलग दो भागों में चलें:

पहले भाग, destructures (चर बंधन से पहले &) vec

let y1 = &vec; 

दूसरे भाग के लिए एक संदर्भ बनाता है।

let &y2 = y1; 

आप संदर्भ है, जो केवल यदि प्रकार Copy है काम करता है से बाहर स्थानांतरित करने, क्योंकि तब किसी भी प्रयास के बजाय वस्तु की प्रतिलिपि बनाएगा स्थानांतरित करने के लिए कोशिश कर रहे हैं इसका मतलब यह है।

Answer 3

एक ही प्रतीक (&) दो अलग-अलग चीजें कर रहा है जब बाध्यकारी के दाएं और बाएं-अंत तरफ उपयोग किया जाता है। बाएं हाथ की ओर एक पैटर्न मिलान की तरह काम करता है, तो:

let x = (y, z); // x contains a tuple with value (y, z) 
let (a, b) = x // x is destructured into (a, b), so now 
       // a has value y and b has value z 

उसी तरह

let x = &y; // x is a reference to y 
let &z = x; // this is like let &z= &y, so we want z to be y 
      // this is equivalent to let z = *x 

एक ref बाईं ओर बंधन में कह रहा है "संदर्भ द्वारा पैटर्न मैच, ना कि मान द्वारा" । तो ये दो कथन समकक्ष हैं:

let ref y = vec; 
let y = &vec; 

हालांकि एक दूसरे में, दूसरा एक और मूर्ख है।

आप pointers/ref chapter on rust by example