arrays - 填充一个数组“let x = [1..11]，在不同的函数中多次迭代它？

Question

我正在为一个简单的问题寻找一个简单而不臃肿的解决方案。

代码(playpen):

use std::ops::Range;

// Sum of square numbers from 1 to 10 # 1^2 + 2^2 + 3^2 ...
fn sum_square(v: &[i64; 10]) -> i64 {
    let mut sum: i64 = 0;
    for x in v {
        sum += x * x;
    }
    return sum;
}


// Square sum of the added numbers from 1 to 10 # (1+2+3+...)^2
fn square_sum(v: &[i64; 10]) -> i64{
    let mut sum: i64 = 0;
    for x in v {
        sum += x;
    }
    return sum*sum;
}

fn main() {
    let v: [i64; 10] = [1,2,3,4,5,6,7,8,9,10];
    let diff = sum_square(&v) - square_sum(&v);
    println!("{}", diff);
}

我在主函数中有一个数组，其中填充了 1-10 之间的数字(是的，我知道 [1..11] 行不通，但最好的解决方案是什么？使用“范围”是毫无疑问的，我想要一个数组而不必键入每个数字)。现在我需要在不同的函数中多次(这里是 2 次)遍历这个数组。

我不想使用 .copy()(因为我不想移动)，我想将数组借用到此处解释的函数:http://imgur.com/xMDVpoC

fn main() {
    let v: [i64; 10] = [1..11];
    let diff = sum_square(&v) - square_sum(&v);
    println!("{}", diff);
}

两个函数，每个函数都迭代这个数组。所以我只用一个

fn sum_square(v: &[i64; 10]) -> i64 {
    let mut sum: i64 = 0;
    for x in v {
        sum += x * x;
    }
    return sum;
}

似乎有效。如果我使用第二个函数

// Square sum of the added numbers from 1 to 10 # (1+2+3+...)^2
fn square_sum(v: &[i64; 10]) -> i64{
    let mut sum: i64 = 0;
    for x in v {
    sum += x;
    }
    return sum*sum;
}

我得到一个错误:类型不匹配解决<core::slice::Iter<'_, i64> as core::iter::Iterator>::Item == i64 :

Answer 1

Pothead Grandma 有一个合理的解释，但我还想包括一些其他细节。

fn square_sum(v: &[i64]) -> i64 { // 1
    let mut sum = 0;
    for &x in v { // 2
        sum += x;
    }
    sum * sum // 3
}

fn main() {
    let v: Vec<_> = (1..11).collect(); // 4
    let diff = sum_square(&v) - square_sum(&v); //5
    println!("{}", diff);
}

1. 我们接受数字的片段，而不是数组的引用。切片只是一大块值以及有多少个值。
2. 我们绑定(bind)到一个引用变量，所以x将被隐式取消引用。这意味着不必总是说 *x要获取变量的值，我们可以使用 x获得值(value)。
3. 不需要明确的 return陈述。当您从方法中提前返回时，显式返回很有用，但如果函数返回值，则函数的最后一条语句就是返回值。
4. 使用范围和 collect 它变成了Vec . collect采用迭代器并生成集合(在本例中为 Vec )。
5. 我们引用了 Vec . Rust 有 auto-dereferencing rules , 和 &Vec<T> will dereference to &[T] .

本着展示解决此问题的更类似于 Rust 的方法的精神，我还将展示 fold 和 map :

fn sum_square(v: &[i64]) -> i64 {
    v.iter().map(|i| i * i).fold(0, |accumulator, i| accumulator + i)
}

fn square_sum(v: &[i64]) -> i64 {
    let sum = v.iter().fold(0, |accumulator, &i| accumulator + i);
    sum * sum
}

或使用 AdditiveIterator :

use std::iter::AdditiveIterator;

fn sum_square(v: &[i64]) -> i64 {
    v.iter().map(|i| i * i).sum()
}

fn square_sum(v: &[i64]) -> i64 {
    let sum: i64 = v.iter().cloned().sum();
    sum * sum
}