Rust 如何将整数拆分为单个数字

但是借钱人说绳子的生命周期 不够长.

那是因为它是doesn't.您没有使用迭代器，所以digits的类型是

std::iter::Map<std::str::Chars<'_>, <closure>>

也就是说，一个尚未计算的迭代器，其中包含对已分配字符串的引用(Chars中的未命名生存期'_).但是，由于该字符串没有所有者，因此会在语句末尾删除它；在使用迭代器之前.

所以，是的，因为Rust ，它阻止了免费使用后的错误！

使用迭代器将"解决"这个问题，因为对分配的字符串的引用不会试图比分配的字符串活得更长；它们都在声明末尾结束:

let digits: Vec<_> = num.to_string().chars().map(|d| d.to_digit(10).unwrap()).collect();

如果要返回迭代器，可以将Vec转换回迭代器:

fn digits(num: usize) -> impl Iterator<Item = u32> {
    num.to_string()
        .chars()
        .map(|d| d.to_digit(10).unwrap())
        .collect::<Vec<_>>()
        .into_iter()
}

至于另一种解决方案，有math way, stolen from the C++ question种方法可以创建一个向量:

fn x(n: usize) -> Vec<usize> {
    fn x_inner(n: usize, xs: &mut Vec<usize>) {
        if n >= 10 {
            x_inner(n / 10, xs);
        }
        xs.push(n % 10);
    }
    let mut xs = Vec::new();
    x_inner(n, &mut xs);
    xs
}

fn main() {
    let num = 42;
    let digits: Vec<_> = num.to_string().chars().map(|d| d.to_digit(10).unwrap()).collect();
    println!("{:?}", digits);
    let digits = x(42);
    println!("{:?}", digits);
}

然而，您可能希望为负数添加所有特殊情况逻辑，测试也不是一个坏主意.

您可能还需要一个花哨的裤子迭代器版本:

fn digits(mut num: usize) -> impl Iterator<Item = usize> {
    let mut divisor = 1;
    while num >= divisor * 10 {
        divisor *= 10;
    }

    std::iter::from_fn(move || {
        if divisor == 0 {
            None
        } else {
            let v = num / divisor;
            num %= divisor;
            divisor /= 10;
            Some(v)
        }
    })
}

或者完全自定义的类型:

struct Digits {
    n: usize,
    divisor: usize,
}

impl Digits {
    fn new(n: usize) -> Self {
        let mut divisor = 1;
        while n >= divisor * 10 {
            divisor *= 10;
        }

        Digits {
            n: n,
            divisor: divisor,
        }
    }
}

impl Iterator for Digits {
    type Item = usize;

    fn next(&mut self) -> Option<Self::Item> {
        if self.divisor == 0 {
            None
        } else {
            let v = Some(self.n / self.divisor);
            self.n %= self.divisor;
            self.divisor /= 10;
            v
        }
    }
}

fn main() {
    let digits: Vec<_> = Digits::new(42).collect();
    println!("{:?}", digits);
}

另见:

• What is the correct way to return an Iterator (or any other trait)?