Question

这是我的第一个Rust程序，似乎我已经遇到了可怕的借用检查程序。 :)

程序应该读取命令行中传递的参数，求它们并返回结果。我很难将参数解析为整数。

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    let sum_args: i32 =
        args
        .iter()
        .skip(1)
        .fold(0, |a, &b| a + b.parse::<i32>().ok().expect("Not an i32!"));
    println!("{:?}", sum_args.to_string());
}

哪个失败了：

error[E0507]: cannot move out of borrowed content
 --> src/main.rs:9:22
  |
9 |         .fold(0, |a, &b| a + b.parse::<i32>().ok().expect("Not an i32!"));
  |                      ^-
  |                      ||
  |                      |hint: to prevent move, use `ref b` or `ref mut b`
  |                      cannot move out of borrowed content

我该怎么办？

Answer 1

args是Vec<String>，iter迭代器返回对字符串（&String）的引用。查看类型的一个技巧是尝试将值分配给单元类型()：

let () = args.iter().next();

哪个错误显示类型：

error[E0308]: mismatched types
 --> src/main.rs:5:13
  |
5 |         let () = args.iter().next();
  |             ^^ expected enum `std::option::Option`, found ()
  |
  = note: expected type `std::option::Option<&std::string::String>`
  = note:    found type `()`

在你的闭包中，你试图自动取消引用（|a, &b|）第二个值。如果能够取消引用它，那么String将移动从向量中移出，这将使向量中的内存处于不确定状态！如果我们在此之后尝试使用向量，我们可能会导致段错误，这是Rust旨在帮助防止的事情之一。

最简单的方法是不要取消引用它（将b留作&String）：

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    let sum_args: i32 =
        args
        .iter()
        .skip(1)
        .fold(0, |a, b| a + b.parse::<i32>().expect("Not an i32!"));
    println!("{:?}", sum_args.to_string());
}

一些额外的小问题......

collect：

时，您不必指定矢量元素类型

let args: Vec<_> = env::args().collect();

您无需创建字符串即可打印出数字：

println!("{}", sum_args);

我可能已将其写成

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    let sum_args: i32 =
        args
        .iter()
        .skip(1)
        .map(|n| n.parse::<i32>().expect("Not an i32!"))
        .sum();
    println!("{}", sum_args);
}

过于聪明的解决方案警告

如果你不得不总结一堆可能失败的数字的迭代器，你可以创建一个实现FromIterator并且不分配任何内存的类型：

use std::env;
use std::iter::{FromIterator, Sum};

struct SumCollector<T>(T);

impl<T> FromIterator<T> for SumCollector<T>
    where T: Sum
{
    fn from_iter<I>(iter: I) -> Self
        where I: IntoIterator<Item = T>
    {
        SumCollector(iter.into_iter().sum())
    }
}

fn main() {
    let sum: Result<SumCollector<i32>, _> = env::args().skip(1).map(|v| v.parse()).collect();
    let sum = sum.expect("Something was not an i32!");
    println!("{}", sum.0);
}

Rust 1.16甚至应该支持这种开箱即用的方式：

use std::env;

fn main() {
    let sum: Result<_, _> = env::args().skip(1).map(|v| v.parse::<i32>()).sum();
    let sum: i32 = sum.expect("Something was not an i32!");
    println!("{}", sum);
}

在总结命令行参数时，“无法摆脱借来的内容”

1 个答案: