2015-01-11 9 views
24

मैं जंग के साथ एक चरण के साथ एक चरण के साथ फिर से कैसे कर सकता हूं? मैं एक सी ++ पृष्ठभूमि से आ रहा हूँ तो मैं जैसेमैं एक कस्टम चरण के साथ एक सीमा पर फिर से कैसे शुरू करूं?

for(auto i = 0; i <= n; i+=2) { 
    //... 
} 

जंग में मैं range फ़ंक्शन का उपयोग करना कुछ करना चाहते हैं, और ऐसा प्रतीत नहीं होता एक तीसरा तर्क है की तरह एक होने के लिए उपलब्ध कस्टम कदम मैं यह कैसे हासिल कर सकता हूं?

उत्तर

29

range_step_inclusive और range_step लंबे समय तक चलते प्रतीत होते हैं।

#![feature(iterator_step_by)] 

fn main() { 
    for x in (1..10).step_by(2) { 
     println!("{}", x); 
    } 
} 
+1

cf. num टोकरा का उपयोग करें https://doc.rust-lang.org/core/ops/struct.Range.html#method.step_by और https://github.com/rust-lang/rust/issues/27741 – maxschlepzig

1

आप कुछ पूर्वनिर्धारित, और छोटे 2 तरह से आगे बढ़ रहे हैं, तो आप मैन्युअल रूप से कदम iterator उपयोग कर सकते हैं: वहाँ एक अस्थिर Iterator::step_by जो इस प्रकार किया जा सकता है रात में विधि है। उदाहरण के लिए:

let mut iter = 1..10; 
loop { 
    match iter.next() { 
     Some(x) => { 
      println!("{}", x); 
     }, 
     None => break, 
    } 
    iter.next(); 
} 

तुम भी (हालांकि यह निश्चित रूप से पचाने के लिए लंबे समय तक और कठिन हो रही है) एक मनमाना राशि से कदम के लिए इसका उपयोग कर सकते हैं:

let mut iter = 1..10; 
let step = 4; 
loop { 
    match iter.next() { 
     Some(x) => { 
      println!("{}", x); 
     }, 
     None => break, 
    } 
    for _ in 0..step-1 { 
     iter.next(); 
    } 
} 
3

आप अपने सी लिखते हैं ++ कोड:

for (auto i = 0; i <= n; i += 2) { 
    //... 
} 

... जंग में तो जैसे:

let mut i = 0; 
while i <= n { 
    // ... 
    i += 2; 
} 

मुझे लगता है कि जंग संस्करण भी अधिक पठनीय है।

+6

और यदि आप किसी भी तरह से सम्मिलित करते हैं लूप में "जारी रखें", आप मर चुके हैं ... –

+0

पुन: लूप में "जारी रखें" डालने के बाद, कोई भी संरचना के लिए भी एक सशर्त शाखा के अंदर ही ऐसा करेगा, मुझे लगता है। यदि ऐसा है, तो मुझे लगता है कि "जारी रखें" से पहले संरचना में सशर्त शाखा के अंदर वृद्धि करना ठीक होगा, और फिर यह इरादे के रूप में काम करेगा। या मैं कुछ दिख रहा हूँ? – WDS

8

यह जब तक .step_by विधि स्थिर किया जाता है, एक आसानी से पूरा कर सकते हैं कि आप एक Iterator साथ क्या चाहते हैं (जो क्या Range रों वास्तव में वैसे भी कर रहे हैं) मुझे लगता है:

struct SimpleStepRange(isize, isize, isize); // start, end, and step 

impl Iterator for SimpleStepRange { 
    type Item = isize; 

    #[inline] 
    fn next(&mut self) -> Option<isize> { 
     if self.0 < self.1 { 
      let v = self.0; 
      self.0 = v + self.2; 
      Some(v) 
     } else { 
      None 
     } 
    } 
} 

fn main() { 
    for i in SimpleStepRange(0, 10, 2) { 
     println!("{}", i); 
    } 
} 

एक पुनरावृति करने की आवश्यकता है विभिन्न प्रकार के एक से अधिक श्रेणियों, कोड सामान्य बनाया जा सकता है इस प्रकार है:

use std::ops::Add; 

struct StepRange<T>(T, T, T) 
    where for<'a> &'a T: Add<&'a T, Output = T>, 
      T: PartialOrd, 
      T: Clone; 

impl<T> Iterator for StepRange<T> 
    where for<'a> &'a T: Add<&'a T, Output = T>, 
      T: PartialOrd, 
      T: Clone 
{ 
    type Item = T; 

    #[inline] 
    fn next(&mut self) -> Option<T> { 
     if self.0 < self.1 { 
      let v = self.0.clone(); 
      self.0 = &v + &self.2; 
      Some(v) 
     } else { 
      None 
     } 
    } 
} 

fn main() { 
    for i in StepRange(0u64, 10u64, 2u64) { 
     println!("{}", i); 
    } 
} 

मैं ऊपरी सीमा एक खुला समाप्त संरचना बनाने के लिए जाँच करता है, तो अनंत लूप के लिए आवश्यक है खत्म करने के लिए आप के लिए छोड़ देंगे ...

इस दृष्टिकोण के लाभ यह है कि for शर्करा के साथ काम करता है और अस्थिर सुविधाओं को प्रयोग करने योग्य होने पर भी काम करना जारी रखेगा; मानक Range एस का उपयोग कर डी-शक्कर दृष्टिकोण के विपरीत, यह कई .next() कॉल द्वारा दक्षता खोना नहीं है। नुकसान यह है कि यह इटरेटर सेट अप करने के लिए कोड की कुछ पंक्तियां लेता है, इसलिए केवल उस कोड के लिए लायक हो सकता है जिसमें बहुत सारे लूप हैं।

+0

एक और प्रकार जोड़कर, आपके दूसरे विकल्प में 'यू' आप विभिन्न प्रकार के साथ अतिरिक्त समर्थन के प्रकार का उपयोग कर सकते हैं और अभी भी 'टी'' उत्पन्न कर सकते हैं।उदाहरण के लिए समय और अवधि दिमाग में आती है। – Ryan

+0

@Ryan, यह एक अच्छा विचार प्रतीत होता है और काम करना चाहिए, संरचना के साथ निम्नानुसार परिभाषित किया गया है: स्ट्रक्चर स्टेप रेंज (टी, टी, यू) जहां <'a, 'b> और 'टी: जोड़ें <&' बी यू, आउटपुट = टी>, टी: पार्टियलऑर्ड, टी: क्लोन; जो इनपुट टी और यू प्रकारों के लिए अलग-अलग जीवनकाल की अनुमति देनी चाहिए। – GordonBGood

संबंधित मुद्दे

 संबंधित मुद्दे