Erstellen eines Vektors von Nullen für eine bestimmte Größe

Ich möchte einen Vektor von Nullen mit einer bestimmten Größe initialisieren, die zur Laufzeit festgelegt wird.

In C wäre es wie:

int main(void)
{
    uint size = get_uchar();
    int A[size][size];
    memset(A, 0, size*size*sizeof(int));
}

Hier ist die Hilfsfunktion, die ich versucht habe, in Rust zu schreiben, aber ich denke, die Slicing-Syntax 0..sizebeleidigt den Compiler. Außerdem sieht es ausführlicher aus als die C-Version. Gibt es einen idiomatischeren Weg, dies zu tun?

fn zeros(size: u32) -> Vec<i32> {
    let mut zero_vec: Vec<i32> = Vec::with_capacity(size);
    for i in 0..size {
        zero_vec.push(0);
    }
    return zero_vec;
}

Ich schwöre, dass die alten Dokumente hier eine from_elem()Methode erklärt haben und keine der Permutationen der [0 ; size] Notation zu funktionieren scheint

Ich möchte dies letztendlich in einen Teilstring-Suchalgorithmus einfügen:

pub fn kmp(text: &str, pattern: &str) -> i64 {
    let mut shifts = zeros(pattern.len()+1);
}

Um einen Vektor von Nullen (oder einen anderen konstanten Wert) einer bestimmten Länge zu initialisieren, können Sie das vec!Makro verwenden:

let len = 10;
let zero_vec = vec![0; len];

Trotzdem funktionierte Ihre Funktion nach nur wenigen Syntaxkorrekturen für mich:

fn zeros(size: u32) -> Vec<i32> {
    let mut zero_vec: Vec<i32> = Vec::with_capacity(size as usize);
    for i in 0..size {
        zero_vec.push(0);
    }
    return zero_vec;
}

uintist in Rust 1.0 nicht mehr vorhanden, sizemusste umgewandelt werden als usizeund die Typen für die Vektoren mussten übereinstimmen (geändert let mut zero_vec: Vec<i64>in let mut zero_vec: Vec<i32>.

Hier ist ein anderer Weg, viel kürzer. Es funktioniert mit Rust 1.0:

fn zeros(size: u32) -> Vec<i32> {
    vec![0; size as usize]
}

fn main() {
    let vec = zeros(10);
    for i in vec.iter() {
        println!("{}", i)
    }
}

Sie können auch die iter::repeatFunktion verwenden, die meiner Meinung nach "idiomatischer" ist (und für mich einfach besser aussieht):

use std::iter;

fn zeros(size: usize) -> Vec<i32> {
    iter::repeat(0).take(size).collect()
}

Sie können die Größenänderung verwenden

let mut v = Vec::new();
let l = 42;
v.resize(l, 0u32);