GoogleMaps v2 for Android：在渲染地图时无法删除标记(GoogleMaps v2 for Android: Cannot remove marker while map is being rendered)

 是的，取消引用值和转换数字类型在Rust中是正常的。 这些转换有助于程序员识别边缘情况。 正如loganfsmyth指出 ： 
 
 
 
 i32可以保存大于f32值，可以准确表示 
 
 
 不幸的是，编译器无法判断出你的情况是什么“正确”，所以你仍然必须保持警惕。 
 
 为了它的价值，我将使用Iterator::sum编写您当前的实现： 
 
fn mean(items: &[i32]) -> f64 {
    let sum: f64 = items.iter().map(|&v| v as f64).sum();
    sum / (items.len() as f64)
}
 
 您还应该处理输入为空的情况，以避免除以零： 
 
fn mean(items: &[i32]) -> Option<f64> {
    let len = items.len();

    if len == 0 {
        None
    } else {
        let sum: f64 = items.iter().map(|&v| v as f64).sum();
        Some(sum / (len as f64))
    }
}
 
 使用什么是一个很好的解决方案来计算所有值的总和超过双倍限制的平均值？ ，但做了更多迭代器： 
 
fn mean2(ary: &[i32]) -> f64 {
    ary.iter().enumerate().fold(0.0, |avg, (i, &x)| {
        avg + ((x as f64 - avg) / (i + 1) as f64)
    })
}
 
 也可以看看： 
 
 
 
 为什么不鼓励接受对String（＆String）或Vec（＆Vec）的引用作为函数参数？ 
 

Yes, dereferencing values and converting numeric types is normal in Rust. These conversions help the programmer recognize that edge cases are possible. As loganfsmyth points out:
 
 
 
An i32 can hold values greater than f32 can represent accurately
 
 
Unfortunately, the compiler can't tell what's "correct" for your case, so you still have to be on guard.
 
For what it's worth, I'd write your current implementation using Iterator::sum:
 
fn mean(items: &[i32]) -> f64 {
    let sum: f64 = items.iter().map(|&v| v as f64).sum();
    sum / (items.len() as f64)
}
 
You should also probably handle the case where the input is empty to avoid dividing by zero:
 
fn mean(items: &[i32]) -> Option<f64> {
    let len = items.len();

    if len == 0 {
        None
    } else {
        let sum: f64 = items.iter().map(|&v| v as f64).sum();
        Some(sum / (len as f64))
    }
}
 
Using the method from What is a good solution for calculating an average where the sum of all values exceeds a double's limits?, but made a bit more iterator-heavy:
 
fn mean2(ary: &[i32]) -> f64 {
    ary.iter().enumerate().fold(0.0, |avg, (i, &x)| {
        avg + ((x as f64 - avg) / (i + 1) as f64)
    })
}
 
See also:
 
 
 
Why is it discouraged to accept a reference to a String (&String) or Vec (&Vec) as a function argument?