La création de deux dimensions des tableaux dans la Rouille

Comment puis-je créer un vide mutable tableau à deux dimensions dans la Rouille?

C'est ce que j'ai essayé jusqu'à présent:

let mut state[[u8 * 4] * 4];

Ce qui produit l'erreur

error: expected one of `:`, `;`, `=`, or `@`, found `[`
 --> src/main.rs:2:18
  |
2 |     let mut state[[u8 * 4] * 4];
  |                  ^ expected one of `:`, `;`, `=`, or `@` here

OriginalL'auteur php-- | 2012-11-03

  1. 6

    Note de l'éditeur: Cette réponse est antérieure à la Rouille 1.0 et certains des concepts et la syntaxe ont changé. D'autres réponses s'appliquent à la Rouille 1.0.

    Voulez-vous que le contenu du tableau à mutable ou la variable qui contient-il? Si vous voulez mutable contenu, fait ce travail pour vous?

    let state = [mut [mut 0u8, ..4], ..4];

    Si vous voulez de la variable mutable mais pas le contenu, essayez ceci:

    let mut state = [[0u8, ..4], ..4];

    Cela vous aide? Je n'ai pas fait la compilation, donc la syntaxe pourrait être légèrement en dehors.

    Oui. Les travaux de cette. Savez-vous comment transférer de telles tableau à la fonction? La fonction doit modifier les valeurs du tableau. Merci.
    Vous pouvez transmettre la valeur de deux façons. Une option serait &mut [[u8 * 4] * 4]--- pointeur à deux dimensions, la longueur fixe de tableau. Vous faites juste &mut state pour obtenir un pointeur.
    Oh, et, normalement, avoir une mutable variable comme ceci permettrait également de muter les éléments d'une longueur fixe de tableau, comme ils sont la propriété de la variable. Malheureusement, ce bug <github.com/mozilla/rust/issues/3226> vous empêchera de vous pour l'instant.
    Cela ne fonctionne plus.
    Pour les futurs visiteurs: c'est une pré-version 1.0 de la rouille, il y a une autre réponse ci-dessous avec une mise à jour de la syntaxe. let mut state = [[0u8; 4]; 4];.

    OriginalL'auteur Eric Holk

  2. 34

    À Rust 1.0, les ouvrages suivants:

    let mut state = [[0u8; 4]; 6];
state[0][1] = 42;

    Noter que la longueur de l'intérieur du segment est une partie intégrante de la type. Par exemple, vous pouvez référencer (et réussir) state comme suit:

    let a: &[[u8; 4]] = &state;

    mais pas sans spécifier la longueur fixe de la sous-matrice. Si vous avez besoin de longueur variable sous-tableaux vous devrez peut-être faire quelque chose comme ceci:

    let x: [Box<[u8]>; 3] = [
    Box::new([1, 2, 3]),
    Box::new([4]), 
    Box::new([5, 6])
];
let y: &[Box<[u8]>] = &x;
    Notez que cette panique si vous avez accès en dehors des limites. Qui ne se sent pas très à la rouille.
    Grâce hardy, mais "(et, oui, la mutabilité travaille maintenant)" -> comment voulez-vous accès et de muter un élément ?
    en deux ans, depuis votre commentaire a été posté vérification des limites doivent avoir été correctement mis en œuvre, que je reçois le temps de compilation des erreurs lors de la tentative de sortir des limites d'un accès sur l'extérieur et à l'intérieur des tableaux.

    OriginalL'auteur dhardy

  3. 9

    Vous pouvez créer une dynamique, de taille moyenne vectorielle 2D comme ceci:

    fn example(width: usize, height: usize) {
    //Base 1d array
    let mut grid_raw = vec![0; width * height];

    //Vector of 'width' elements slices
    let mut grid_base: Vec<_> = grid_raw.as_mut_slice().chunks_mut(width).collect();

    //Final 2d array
    let grid: &mut [&mut [_]] = grid_base.as_mut_slice();

    //Accessing data
    grid[0][0] = 4;
}
    Je pense qu'il devrait lire ...chunks_mut(height)... en supposant que l'accès est grid[0...width-1][0...height-1]

    OriginalL'auteur Procrade

  4. 2

    Idiomatiques C 2-dimensions des tableaux sont déclarées à l'aide du même ordre de la taille des matrices utilisées lors de l'accès au tableau:

    //Declaration
int array_2d[8][16]; //An 8 by 16 2D array
...
//Access
array_2d[0][1] = 5;

    Dans la Rouille, la déclaration tailles sont retournées; de créer un 8 par 16 tableau en 2 dimensions, la syntaxe est la suivante:

    //Declaration
let mut array_2d: [[i32; 16]; 8];
...
//Access (same as idiomatic C. types for added explicitness)
array_2d[0_usize][1_usize] = 5;

    OriginalL'auteur spatulaninja

  5. 0

    Initialisation:

    Il existe plusieurs approches pour la 2D initialisation de Tableau:

    1. À l'aide des constantes de M (lignes) & N (colonnes) 

      const M: usize = 2;
const N: usize = 4;

let mut grid = [[0 as u8; N] ; M];

    2. Déclaration explicite avec les annotations de type

      let mut grid: [[u8; 4]; 2] = [[0; 4]; 2];

    Déplacement:

    Le en lecture seule traversant est aussi simple que:

    for (i, row) in grid.iter().enumerate() {
    for (j, col) in row.iter().enumerate() {
        print!("{}", col);
    }
    println!()
}

    ou 

    for el in grid.iter().flat_map(|r| r.iter()) {
    println!("{}", el);
}

    La mise à jour de l'élément(s):

    for (i, row) in grid.iter_mut().enumerate() {
    for (j, col) in row.iter_mut().enumerate() {
        col = 1;
    }
}

    OriginalL'auteur magiccrafter