Creazione di array bidimensionali in Rust

Question

Come creare un array bidimensionale mutabile vuoto in Rust?

Questo è quello che ho provato finora:

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

Questo produce l'errore

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

Answer 1

Nota del redattore: Questa risposta precede Rust 1.0 e alcuni dei concetti e la sintassi sono cambiati . Altre risposte si applicano a Rust 1.0.

Volete che il contenuto dell'array sia mutabile o la variabile che lo trattiene? Se vuoi contenuti mutabili, funziona per te?

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

Se si desidera la variabile di essere mutevoli, ma non i contenuti, provate questo:

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

fa questo aiuto? In realtà non ho compilato questo, quindi la sintassi potrebbe essere leggermente fuori.

Answer 2

A Rust 1.0, i seguenti lavori:

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

noti che la lunghezza del segmento interno è parte integrante del tipo. Ad esempio, è possibile fare riferimento (e pass) state come segue:

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

ma non senza specificare la lunghezza fissa del sub-array. Se avete bisogno di sub-array di lunghezza variabile potrebbe essere necessario fare qualcosa di simile:

let x: [Box<[u8]>; 3] = [ 
    Box::new([1, 2, 3]), 
    Box::new([4]), 
    Box::new([5, 6]) 
]; 
let y: &[Box<[u8]>] = &x; 

Answer 3

È possibile creare un vettore 2D dinamicamente dimensioni come questo:

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

Answer 4

Idiomatic C array 2-dimensionali sono dichiarate usando lo stesso ordine delle grandezze di campo come usato quando accede alla matrice:

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

In ruggine, le dimensioni di dichiarazione vengono girate; per creare un array bidimensionale 8 x 16, la sintassi è:

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