बदलें, जबकि नए संस्करण

Question

मैं एक enum संस्करण को अपडेट करना चाहते हैं, जबकि किसी भी क्लोनिंग के बिना नया एक के लिए पुराने संस्करण के एक क्षेत्र से आगे बढ़ के क्षेत्र बढ़ रहा है:

enum X { 
    X1(String), 
    X2(String), 
} 

fn increment_x(x: &mut X) { 
    match x { 
     &mut X::X1(s) => { 
      *x = X::X2(s); 
     } 
     &mut X::X2(s) => { 
      *x = X::X1(s); 
     } 
    } 
} 

इसका कारण यह है काम नहीं करता है हम &mut X से s स्थानांतरित नहीं कर सकते हैं।

कृपया enum X { X1, X2 } को लागू करने और struct S { variant: X, str: String } आदि का उपयोग करने जैसी चीजों का सुझाव न दें। यह एक सरलीकृत उदाहरण है, कल्पना करें कि कई अन्य फ़ील्ड वेरिएंट में हैं, और एक फ़ील्ड को एक संस्करण से दूसरे में ले जाना चाहते हैं।

Answer 1

यह काम नहीं करता है क्योंकि हम से s स्थानांतरित नहीं कर सकते हैं।

तो ऐसा नहीं है ... मूल्य से struct लेने के लिए और वापस जाने के लिए एक नया:

enum X { 
    X1(String), 
    X2(String), 
} 

fn increment_x(x: X) -> X { 
    match x { 
     X::X1(s) => X::X2(s), 
     X::X2(s) => X::X1(s), 
    } 
} 

अंत में, संकलक आप क्योंकि अगर आप बाहर स्ट्रिंग के लिए कदम सकता है सुरक्षा कर रहा है गणना के बाद, यह कुछ आधा निर्मित राज्य में होगा। स्ट्रिंग को मुक्त करने के लिए कौन जिम्मेदार होगा यदि फ़ंक्शन उस सटीक पल पर घबराए? क्या यह स्थानीय चर में enum या स्ट्रिंग में स्ट्रिंग को मुक्त करना चाहिए। यह डबल-फ्री के रूप में दोनों स्मृति-सुरक्षा समस्या नहीं हो सकता है।

आप एक परिवर्तनशील संदर्भ पर इसे लागू करने के लिए किया था, तुम वहाँ अस्थायी रूप से में एक डमी मान संग्रहीत कर सकता है:

use std::mem; 

fn increment_x_inline(x: &mut X) { 
    let old = mem::replace(x, X::X1(String::new())); 
    *x = increment_x(old); 
} 

बनाना एक खाली String बहुत बुरा (यह सिर्फ कुछ संकेत नहीं है, कोई ढेर आवंटन), लेकिन यह हमेशा संभव नहीं है। उस मामले में, आप Option उपयोग कर सकते हैं:

fn increment_x_inline(x: &mut Option<X>) { 
    let old = x.take(); 
    *x = old.map(increment_x); 
} 

Answer 2

आप एक शून्य लागत तरह से मूल्य से बाहर जाने के बिना ऐसा करना चाहते हैं, तो आप (AFAIK) असुरक्षित कोड का एक सा का सहारा लेना है:

#[derive(Debug)] 
enum X { 
    X1(String), 
    X2(String), 
} 

fn increment_x(x: &mut X) { 
    let interim = unsafe { mem::uninitialized() }; 
    let prev = mem::replace(x, interim); 
    let next = match prev { 
     X::X1(s) => X::X2(s), 
     X::X2(s) => X::X1(s), 
    }; 
    let interim = mem::replace(x, next); 
    mem::forget(interim); // Important! interim was never initialized 
} 

संपादित करें: धन्यवाद बाहर बाँटे की जगह के लिए @Shepmaster करने के लिए ...