[Rust] 반복자

개요

• Iterator 트레잇을 구현
• iter()
  • 반복자 반환
• into_iter()
  • 소유권을 갖는 반복자 반환
• iter_mut
  • 가변 참조 반복자 반환

예제

• 코드

  •  struct Test {
         value: u32,
     }
            
     impl Iterator for Test {
         type Item = u32;
            
         fn next(&mut self) -> Option<Self::Item> {
             self.value += 1;
            
             Some(self.value)
         }
     }
            
     fn main() {
         let v = vec![1, 2, 3];
         for value in v.iter() {
             println!("1.1 : {}", value);
         }
         println!("1.2 : {:?}", v);
            
         let v = vec![1, 2, 3];
         let mut iter = v.iter();
         println!("2.1 : {:?}", iter.next());
         println!("2.2 : {:?}", iter.next());
         println!("2.3 : {:?}", iter.next());
         println!("2.4 : {:?}", iter.next());
         println!("2.5 : {:?}", v);
            
         let mut v = vec![1, 2, 3];
         v.iter_mut().for_each(|i| *i += 1);
         println!("3.2 : {:?}", v);
            
         let v = vec![1, 2, 3];
         v.into_iter().for_each(|i| println!("4.1 : {}", i));
         //println!("4.2 : {:?}", v);
            
         let v = vec![1, 2, 3];
         let sum: i32 = v.iter().sum();
         println!("5.1 : {}", sum);
         println!("5.2 : {}", v.iter().sum::<i32>());
            
         let v = vec![1, 2, 3];
         println!(
             "6.1 : {:?}",
             v.iter().filter(|i| *i % 2 == 1).collect::<Vec<_>>()
         );
            
         let mut test = Test { value: 0 };
         println!("7.1 : {:?}", test.next());
         println!("7.2 : {:?}", test.next());
     }
    

• 실행 결과

  •  1.1 : 1
     1.1 : 2
     1.1 : 3
     1.2 : [1, 2, 3]
     2.1 : Some(1)
     2.2 : Some(2)
     2.3 : Some(3)
     2.4 : None
     2.5 : [1, 2, 3]
     3.2 : [2, 3, 4]
     4.1 : 1
     4.1 : 2
     4.1 : 3
     5.1 : 6
     5.2 : 6
     6.1 : [1, 3]
     7.1 : Some(1)
     7.2 : Some(2)