是否有任何 rust 函数用于包装依赖于引用的迭代器，以便包装器包含引用？

您无法在安全 rust 中创建自引用类型，如此处所述。不幸的是，解决此问题仍然会留下下一个问题。

返回不能超过迭代器的项的迭代器是不可能的，此处对此进行了解释。你的限制性更强：它试图创建在获取下一个项目时不存在的项目，这意味着你需要一个借用迭代器才能使其处于当前状态。

使用一些嵌套的 for 循环创建你的是非常容易的：Vec

fn valuereader<A: FromStr>() -> Vec<A>
where
    A::Err: Debug,
{
    let mut v = Vec::new();
    for line in std::io::stdin().lines() {
        for word in line.unwrap().split_whitespace() {
            let a = word.parse().unwrap();
            v.push(a);
        }
    }
    v
}

但是，这并不是很有启发性，并且会创建许多临时分配，尤其是当您只需要一个迭代器而不是 .Vec

为了使你的原始想法以惯用的方式工作，你需要一个迭代器来生成拥有的项。幸运的是，你的最终项目类型是（或任何必须拥有的 ，所以你可以创建一个迭代器来创建这些。这只会分配一个 ，它将增长到最长行的长度。（游乐场）usizeparseString

use std::fmt::Debug;
use std::io::BufRead;
use std::marker::PhantomData;
use std::str::FromStr;

#[derive(Debug, Clone)]
struct ValueReader<B, V> {
    // The underlying BufRead
    buffer: B,
    // The current line being read
    line: String,
    // The current offset into the current line
    index: usize,
    // The type being parsed
    _value_type: PhantomData<V>,
}

impl<B, V> ValueReader<B, V> {
    fn new(b: B) -> Self {
        Self {
            buffer: b,
            line: String::new(),
            index: 0,
            _value_type: PhantomData,
        }
    }

    fn value(&mut self) -> Option<V>
    where
        V: FromStr,
        V::Err: Debug,
        B: BufRead,
    {
        loop {
            // Check if line is consumed, or the iterator just started
            if self.line.is_empty() {
                let bytes = self.buffer.read_line(&mut self.line).unwrap();
                // Buffer is completely consumed
                if bytes == 0 {
                    return None;
                }
            }

            let unconsumed = self.line[self.index..].trim_start();
            self.index = self.line.len() - unconsumed.len();

            let Some(word) = unconsumed.split_whitespace().next() else {
                // Line is consumed, reset to original state
                self.index = 0;
                self.line.clear();
                continue;
            };
            self.index += word.len();

            return Some(word.parse().unwrap());
        }
    }
}

impl<B, V> Iterator for ValueReader<B, V>
where
    V: FromStr,
    V::Err: Debug,
    B: BufRead,
{
    type Item = V;

    fn next(&mut self) -> Option<Self::Item> {
        self.value()
    }
}

通过使用并且一次只读取一个单词，缩短 .报告错误而不是解包也是明智的。fill_bufconsumeString