时间戳

首页 > 解决方案 > 在 Rust 中实现迭代器

rust - 在 Rust 中实现迭代器

问题描述

我正在制作一个生锈的迭代器。在next()我要提取的方法next_element中current_element，将返回哪个，并创建新Term实例并将其设置为next_element：

pub struct Term {
    pub coefficient: f64,
    pub index: i32,
    pub exponent: f64,
}

pub struct SeriesIterator {
    next_element: Term,
}

impl Iterator for SeriesIterator {
    type Item = Term;
    fn next(&mut self) -> Option<Self::Item> {
        let current_element = self.next_element;
        self.next_element = Term {
            coefficient: 1.0,
            index: current_element.index + 1,
            exponent: f64::from(current_element.index + 1),
        };
        Some(current_element)
    }
}

如何将所有权next_element移入current_element其中，最终将随着归还而移出next()？

cannot move out of `self.next_element` which is behind a mutable reference
   |
   |     let current_element = self.next_element;
   |                          ^^^^^^^^^^^^^^^^

标签： rust

解决方案

  1. 使用std::mem::replace，试试这个：
    fn next(&mut self) -> Option<Self::Item> {
        let index = self.next_element.index + 1;

        Some(std::mem::replace(
            &mut self.next_element,
            Term {
                coefficient: 1.0,
                index: index,
                exponent: f64::from(index),
            },
        ))
    }
  1. 使用#[derive(Clone, Copy)]： 
    fn next(&mut self) -> Option<Self::Item> {
        let current_element = self.next_element; // copy

        self.next_element.coefficient = 1.0;
        self.next_element.index += 1;
        self.next_element.exponent = f64::from(self.next_element.index);

        Some(current_element)
    }

试试这个工作示例： 


#[derive(Clone, Copy)]
pub struct Term {
    pub coefficient: f64,
    pub index: i32,
    pub exponent: f64,
}
pub struct SeriesIterator {
    next_element: Term,
}

impl Iterator for SeriesIterator {
    type Item = Term;
    fn next(&mut self) -> Option<Self::Item> {
        let current_element = self.next_element; // copy

        self.next_element.coefficient = 1.0;
        self.next_element.index += 1;
        self.next_element.exponent = f64::from(self.next_element.index);

        Some(current_element)
    }
}

fn main() {
    let mut t = SeriesIterator {
        next_element: Term {
            coefficient: 1.0,
            index: 0,
            exponent: 1.0,
        },
    };

    let next = t.next().unwrap();
    println!("{}", next.index); // 0
    println!("{}", t.next_element.index); // 1

    let next = t.next().unwrap();
    println!("{}", next.index); // 1
    println!("{}", t.next_element.index); // 2
}

输出：

0
1
1
2

推荐阅读