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)