web-dev-qa-db-fra.com

Création d'un vecteur de zéros pour une taille spécifique

Je voudrais initialiser un vecteur de zéros avec une taille spécifique qui est déterminée lors de l'exécution.

En C, ce serait comme:

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

Voici la fonction d'aide que j'ai essayé d'écrire dans Rust, mais je pense que la syntaxe de découpage 0..size Offense le compilateur. En outre, il semble plus verbeux que la version C. Existe-t-il une manière plus idiomatique de procéder?

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;
}

Je jure que les anciens documents expliquaient une méthode from_elem()ici et aucune des permutations du [0 ; size]notation ne semble fonctionner

J'aimerais finalement coller ceci dans un algorithme de recherche de sous-chaîne:

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

Pour initialiser un vecteur de zéros (ou toute autre valeur constante) d'une longueur donnée, vous pouvez utiliser le vec! macro:

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

Cela dit, votre fonction a fonctionné pour moi après quelques corrections de syntaxe:

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;
}

uint n'existe plus dans Rust 1.0, size devait être converti en usize, et les types de vecteurs nécessaires pour correspondre ( modifié let mut zero_vec: Vec<i64> à let mut zero_vec: Vec<i32>.

54
anderspitman

Voici une autre façon, beaucoup plus courte. Cela fonctionne avec 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)
    }
}
13
VRage

Vous pouvez également utiliser le iter::repeat fonction, qui je suppose est "plus idiomatique" (et me semble plus agréable):

use std::iter;

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

Vous pouvez utiliser redimensionner

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