Question

我想在Rust中创建一个函数，该函数生成具有随机值的x大小的数组。我想问一下如何在Rust函数中返回一个数组，如果您可以检查我其余代码是否正常，那就太好了。很抱歉我的基本问题，但我是初学者。

use rand::prelude::*;

fn generateArray(howManyValues: u32)->[f64]
{
    let mut rng = rand::thread_rng();
    let array: [f64, howManyValues];
    for i in 0..howManyValues
    {
        array[i] = rng.gen()*100;
    }

    println!("{:?}", array);
    return array;
}

fn main() {
    generateArray(10);
}

Answer 1

首先，像Rust中的其他编程语言一样，数组不能增长或收缩。您可以使用向量。

let v : Vec<i32> = Vec::new();

您可以使用.push（）函数将值推入向量中。

Answer 2

我想在Rust中创建一个函数，该函数生成具有随机值的x大小的数组

Rust的Vec可能比数组要好，除非您使用某种外部函数接口（FFI），或者Rust API需要一个数组（它可能需要Deref<Target = [T]>，基本上对所有类似数组的类型（包括Vec和原始数组）通用。 Vec类似于C ++的Vector和Java的ArrayList。

use rand::prelude::*;

fn generate_vec(len: usize)->Vec<f64>
{
    let mut rng = rand::thread_rng();
    let mut vec = Vec::with_capacity(len);
    for _ in 0..len {
        vec.push(rng.gen::<f64>()*100.);
    }
    return vec;
}


fn main() {
    let generated_vec = generate_vec(10);
    println!("{:?}", generated_vec);
}

我进行了一些样式更改，例如带下划线而不是camelCase的函数名称，将print宏移至main函数，并更改len的类型以进行使用，因为这是rust中数组的最大大小。如果您真的想要一个数组，请继续阅读。

如果在编译时知道数组的大小，则可以使用数组，但是不能从函数返回原始数组-它不是Sized。您可以返回一个切片（将其视为指向数组的指针），但是如果数组在函数中的堆栈上分配，则一旦函数返回，它将不再存在。 Rust解决此问题的最基本方法是Box。 Box<T>包含一个堆分配的T。使用大数组时要小心，因为使用此方法它们仍会放在堆之前，因此会导致堆栈溢出。

use rand::prelude::*;

const CONST_LEN:usize = 10;

fn generate_array()->Box<[f64]>
{
    let mut rng = rand::thread_rng();
    let mut boxed_arr = Box::new([0.; CONST_LEN]);
    for i in 0..CONST_LEN {
        boxed_arr[i] = rng.gen::<f64>() * 100.;
    }
    boxed_arr
}


fn main() {
    let generated_array = generate_array();
    println!("{:?}", generated_array);
}

如果在编译时不知道该长度，或者该长度太大而无法容纳在堆栈中，则应再次使用Vec，并将其转换为Box<[T]>（使用into_boxed_slice()的T数组。

use rand::prelude::*;

fn generate_array(len: usize) -> Box<[f64]> {
    let mut rng = rand::thread_rng();
    let mut vec = vec![0.; len];
    for num in vec.iter_mut() {
        *num = rng.gen::<f64>() * 100.;
    }
    vec.into_boxed_slice()
}

fn main() {
    let generated_array = generate_array(10);
    println!("{:?}", generated_array);
}

Answer 3

要适应您的函数并仍然返回数组，需要指定返回类型即fn generateArray()->[f64; 100]中的元素数。锈类型系统说明了数组的大小，因此[f64; 100]（长度为100的数组包含f64）与[f64; 99]是不同的类型。在函数中指定数组的长度使得重用性降低，因为它总是返回相同大小的数组。

如果您只需要创建充满随机浮点数的堆栈分配数组，则可以使用宏，但这会限制您使用编译时已知的数组大小（C ++术语中为constexpr，在C ++中为const Rust术语）。我认为这种宏观方法略显单调。宏可能看起来像

use rand::prelude::*;

macro_rules! make_array {
    ($size:literal) => {{
        let mut rng = rand::thread_rng();
        let mut arr = [0_f64; $size];
        for item in arr.iter_mut() {
            *item = rng.gen::<f64>()*100.;
        }
        arr
    }}
}

fn main() {
    let arr = make_array!(32);
    println!("{:?}", arr);
    let arr = make_array!(16);
    println!("{:?}", arr);
}

与修改后的函数相比，它更具可重用性，因为您可以指定不同数量的元素。

如何在Rust函数中返回数组

3 个答案: