एक परस्पर स्लाइस [डुप्लीकेट] को कैसे टालें

Nov 24 2020

मैं एक परस्पर संदर्भ के माध्यम से एक स्लाइस को आगे बढ़ाना चाहता हूं।

जबकि यह अपरिहार्य स्लाइस के साथ काम करता है:

fn shrink(value: &mut &[u8]) {
    *value = &value[0..2];
}

fn main() {
    let a = [0; 4];
    let mut a_slice: &[u8] = &a;
    shrink(&mut a_slice);
    println!("{:?}", a_slice);
}

यह परस्पर के साथ काम नहीं करता है:

fn shrink<'a: 'b, 'b>(value: &'a mut &'b mut [u8]) {
    *value = &mut value[0..2];
}

fn main() {
    let mut a = [0; 4];
    let mut a_slice: &mut [u8] = &mut a;
    shrink(&mut a_slice);
    println!("{:?}", a_slice);
}

त्रुटि संदेश:

error[E0502]: cannot borrow `a_slice` as immutable because it is also borrowed as mutable
 --> src/main.rs:8:22
  |
7 |     shrink(&mut a_slice);
  |            ------------ mutable borrow occurs here
8 |     println!("{:?}", a_slice);
  |                      ^^^^^^^
  |                      |
  |                      immutable borrow occurs here
  |                      mutable borrow later used here

मुझे पता है कि सीधे उप-प्रकार को वापस करके स्लाइस को अपडेट करने का एक तरीका है।

लेकिन क्या रेफरेंसिंग को परस्पर संदर्भ के माध्यम से एक परिवर्तनशील टुकड़ा बनाने का एक तरीका है?

समस्या के समान है इस एक है, लेकिन मैं आंकड़ा क्या यह इतना अलग बनाता है, कि प्रस्तावित समाधान काम नहीं है नहीं कर सकते।

जवाब

2 Douglas Nov 24 2020 at 18:55

मुझे नहीं पता कि उस कोड में क्या समस्या है, लेकिन एक विकल्प यह होगा कि अपडेट किए गए स्लाइस को सीधे लौटाया जाए:

fn shrink(value: &mut [u8]) -> &mut [u8] {
    &mut value[0..2]
}

fn main() {
    let mut a = [0; 4];
    let mut a_slice = &mut a[..];
    a_slice = shrink(a_slice);
    println!("{:?}", a_slice);
}

उत्परिवर्तित संदर्भ के माध्यम से अपडेट करने के बजाय, कॉलर में अपडेट करने से यह स्पष्ट हो जाता है कि पुराने मूल्य का a_sliceउपयोग किसी भी अधिक नहीं किया जाएगा।