Rust 迭代器的生命周期管理

2023-10-26 language rust

很多场景下可以通过迭代器简化代码编写。

简介

假设需要对某个字符串进行解析，同时输出 Token 信息，为了尽量减少内存开销，不会直接复制字符串，而是通过 &str 方式引用。这样，会有类似如下的代码。

struct TokenIterator {
    data: String,
    start: usize,
    end: usize,
}

impl Iterator for TokenIterator {
    type Item = &str;
    fn next(&mut self) -> Option<Self::Item> {
        // ... ...
    }
}

此时，在 type Item = &str 这行代码处有 `&` without an explicit lifetime name cannot be used here explicit lifetime name needed here 的报错。

简单来说，在 TokenIterator 中会有字符串切片的引用，但并为指明原始字符串的生命周期，以防出现引用存在但是原始的数据已经回收了，那么就需要通过生命周期参数确保，引用至少要比字符串生命周期要长。

生命周期

如下修改为带有生命周期版本。

struct TokenIterator<'a> {
    data: String,
    start: usize,
    end: usize,
}

impl<'a> Iterator for TokenIterator<'a> {
    type Item = &'a str;
    fn next(&mut self) -> Option<Self::Item> {
        // ... ...
    }
}

此时在 struct TokenIterator<'a> { 代码处，仍有 parameter `'a` is never used 的报错。也就是说，虽然引入了变量的生命周期，但是，在结构体中并没有使用。

这一场景下有两种解决方案：

  • 使用 PhantomData 这个 Marker 进行标识。
  • 新增一个结构体对原始数据进行封装。

如下以后者为例。

结构体封装 

struct TokenSet {
    data: String,
}

impl TokenSet {
    pub fn new(data: String) -> TokenSet {
        TokenSet { data }
    }

    pub fn iter<'a>(&'a self) -> TokenIterator<'a> {
        TokenIterator::new(&self.data)
    }
}

struct TokenIterator<'a> {
    data: &'a str,
    token_start: usize,
    token_end: usize,
}

impl<'a> TokenIterator<'a> {
    pub fn new(data: &'a str) -> TokenIterator<'a> {
        TokenIterator {
            data,
            token_start: 0,
            token_end: 0,
        }
    }
}

impl<'a> Iterator for TokenIterator<'a> {
    type Item = &'a str;

    fn next(&mut self) -> Option<Self::Item> {
        // Move beyond the previous token, if any.
        self.token_start = self.token_end;

        // Try to find a non-whitespace character that
        // will denote the beginning of another token.
        let next_char_index = self.data[self.token_start..]
            .char_indices()
            .find(|&(_, c)| !c.is_whitespace())
            .map(|(i, _)| i + self.token_start);

        if let Some(start_index) = next_char_index {
            // We've found the start of another token.
            self.token_start = start_index;

            // Find the end of the token, whether that
            // is whitespace or the end of the string.
            self.token_end = self.data[self.token_start..]
                .char_indices()
                .find(|&(_, c)| c.is_whitespace())
                .map(|(i, _)| i + self.token_start)
                .unwrap_or(self.data.len());

            Some(&self.data[self.token_start..self.token_end])
        } else {
            None
        }
    }
}

fn main() {
    let data = TokenSet::new("iterator data".to_string());
    let mut iterator = data.iter();
    while let Some(v) = iterator.next() {
        println!("{}", v);
    }
}

优化

上述的 TokenSet 实现需要显示调用 iter() 函数才可以，如果要简化调用，也可以实现 IntoIterator 特征，这样在 for 循环中可以无缝连接。