Question

我试图实现一个将产生素数的迭代器。我将已发现的素数存储在Vec<u64>。

中

这是我的实施：

struct Primes {
    primes: Vec<u64>,
}

impl Primes {
    fn new() -> Primes {
        Primes { primes: vec!(2, 3) }
    }

    fn iter(&self) -> PrimesIterator {
        PrimesIterator { primes: &self.primes, index : 0 }
    }
}

struct PrimesIterator<'a> {
    primes: & 'a Vec<u64>,
    index: usize,
}

impl<'a> Iterator for PrimesIterator<'a> {
    type Item = u64;

    fn next(&mut self) -> Option<u64> {
        if self.index < self.primes.len() {
            let result = self.primes[self.index];
            self.index += 1;
            Some(result)
        } else {
            let mut n = *self.primes.last().unwrap();
            loop {
                n += 2;
                if is_prime(self.primes, n) {
                    self.primes.push(n);
                    self.index += 1;
                    return Some(n);
                }
            }
        }
    }
}

fn is_prime(primes: &[u64], n: u64) -> bool {
    for &p in primes.iter() {
        if n % p == 0 {
            return false;
        }
        if p * p > n {
            return true;
        }
    }
    return false;
}

但是当我尝试编译它时，我收到以下错误：

main.rs: error: cannot borrow immutable borrowed content `*self.primes` as mutable
main.rs:                     self.primes.push(n);

我宣称自己是和我一样，所以我真的不明白这里的错误以及如何解决这个问题。

Answer 1

您的PrimesIterator类型包含对Vec<u64>的不可变引用。您需要将其声明为可变引用：

struct PrimesIterator<'a> {
    primes: &'a mut Vec<u64>,
    index: usize,
}

这当然要求您修改iter()函数以确保它传递可变引用：

impl Primes {
    fn new() -> Primes {
        Primes { primes: vec!(2, 3) }
    }

    fn iter(&mut self) -> PrimesIterator {
        PrimesIterator { primes: &mut self.primes, index : 0 }
    }
}

无法从实现中修改struct字段：“不能将不可变借用内容借用为可变”

1 个答案: