如何在 Rust 中的包裝向量上實現迭代器特征？

Question

有類似的代碼

#[derive(Debug)]
struct BinaryVec {
    vec: Vec<u8>,
}

impl BinaryVec {
    fn empty() -> BinaryVec {
        BinaryVec { vec: Vec::new() }
    }

    fn push(&mut self, bit: u8) {
        self.vec.push(bit);
    }
}

我希望能夠在不公開的情況下迭代結構的向量。 例如，將其稱為：

let bin_vec = BinaryVec::empty();
bin_vec.push(1);
bin_vec.push(0);
bin_vec.push(1);
for el in bin_vec.iter() { 
    // do something with 1,0,1 elements 
}

但我看到Iterator trait 只需要next方法，它假定結構中保存的 iter state 。

有沒有辦法直接通過 Rust 中的更高級別的結構傳遞 vec iter，而不向結構添加新的 state 相關字段？

Answer 1

實際上，要按照您的描述調用它，您不需要為它實現Iterator 。 您只需要返回內部 vec 的迭代器：

impl BinaryVec {
     ...
     fn iter(self: &Self) -> impl Iterator<Item=u8>{
           self.vec.iter()
     }
}

請注意，即使是標准Vec也沒有實現Iterator ，它是iter返回的結構實現了它。

Answer 2

Vec<T>本身也沒有實現Iterator either. However, it implements Iterator either. However, it implements IntoIterator`：

• impl<T> IntoIterator for Vec<T> ：您可以for item in vec編寫，並且每個item將采用T值。 這會消耗向量。
• impl<T> IntoIterator for &'_ [T] （其中&Vec<T> derefs to &[T] ）：您可以for item in &vec編寫，並且每個item將采用&T 。
• impl<T> IntoIterator for &'_ mut [T] （其中&mut Vec<T> derefs to &mut [T] ）：您可以for item in &mut vec編寫，並且每個item都將采用&mut T 。

您可能還想為您的包裝器實現這些：

impl IntoIterator for BinaryVec {
  type Item = u8;
  type IntoIter = <Vec<u8> as IntoIterator>::IntoIter; // so that you don't have to write std::vec::IntoIter, which nobody remembers anyway

  fn into_iter(self) -> Self::IntoIter {
    self.vec.into_iter()
  }
}

// We deref to slice so that we can reuse the slice impls
impl Deref for BinaryVec {
  type Output = [u8];

  fn deref(&self) -> &[u8] {
    &self.vec[..]
  }
}
impl DerefMut for BinaryVec {
  type Output = [u8];

  fn deref_mut(&mut self) -> &mut [u8] {
    &mut self.vec[..]
  }
}

請注意，如果T沒有實現Copy ，則為&mut [T]實現IntoIterator並非易事。