我正在编写一个函数,该函数需要较大整数的各个数字来执行操作。
我尝试了以下操作:
fn example(num: i32) {
// I can safely unwrap because I know the chars of the string are going to be valid
let digits = num.to_string().chars().map(|d| d.to_digit(10).unwrap());
for digit in digits {
println!("{}", digit)
}
}
但是借位检查员说字符串寿命不足:
error[E0716]: temporary value dropped while borrowed
--> src/lib.rs:3:18
|
3 | let digits = num.to_string().chars().map(|d| d.to_digit(10).unwrap());
| ^^^^^^^^^^^^^^^ - temporary value is freed at the end of this statement
| |
| creates a temporary which is freed while still in use
4 | for digit in digits {
| ------ borrow later used here
|
= note: consider using a `let` binding to create a longer lived value
以下内容确实有效:
let temp = num.to_string();
let digits = temp.chars().map(|d| d.to_digit(10).unwrap());
但是那看起来更人为。
是否有更好,更自然的方法?
但是借位检查人员说该字符串寿命不足。
那是因为它不是。您没有使用迭代器,因此digits
的类型为
std::iter::Map<std::str::Chars<'_>, <closure>>
即,是一个尚待评估的迭代器,它包含对分配的字符串的引用('_
中的未命名生存期Chars
)。但是,由于该字符串没有所有者,因此它将在语句末尾删除;在消耗迭代器之前。
所以,对Rust来说,它防止了After-After-Free的bug!
认为迭代器可以“解决”问题,因为对分配的字符串的引用不会比分配的字符串寿命更长;它们都在语句结尾处结束:
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);
}
另请参见: