Erstellen von zweidimensionalen arrays in Rust

Wie erstelle ich eine leere veränderlich zwei-dimensionales array in Rust?

Dies ist, was ich bisher versucht habe:

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

Dieser erzeugt den Fehler

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

    Anmerkung der Redaktion: Diese Antwort ist älter als Rust 1.0 und einige der Konzepte und syntax verändert haben. Andere Antworten gelten zu Rust 1.0.

    Wollen Sie die Inhalte des Arrays werden veränderliche oder variable, die Sie hält? Wenn Sie möchten, veränderliche Inhalt, macht diese Arbeit für Sie?

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

    Wenn Sie möchten, die variable, die verändert aber nicht den Inhalt, versuchen Sie dies:

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

    Funktioniert diese Hilfe? Ich wollte eigentlich nicht kompilieren, also die syntax geringfügig ab.

    • Ja. Dieser funktioniert. Weißt du, wie würde ich den pass solchen array an die Funktion? Muss die Funktion zum ändern der Werte von array. Danke.
    • Sie passieren konnten, wird der Wert in zwei Arten. Eine option wäre &mut [[u8 * 4] * 4]--- Zeiger auf eine zwei-dimensionale fester Länge-array. Sie würde einfach tun &mut state zu bekommen, wie ein Zeiger.
    • Oh, und in der Regel mit einer veränderlichen variable wie diese würde es auch erlauben, Sie zu dynamisieren die Elemente eines fixed-length Arrays, wie Sie sind im Besitz der variable. Leider ist dieser bug <github.com/mozilla/rust/issues/3226> werden verhindern, dass Sie für jetzt.
    • Danke. Ich habe es arbeiten wie diese & [mut [mut u8 * 4] * 4] für die Funktions-parameter. Wie bekomme ich den Zeiger auf erste Zeile des zwei-dimensionalen array?
    • Dieser funktioniert nicht mehr.
    • Für zukünftige Besucher: dies ist eine pre-1.0-version von rust gibt es eine andere Antwort unten mit einer neuen syntax. let mut state = [[0u8; 4]; 4];.
    • Das funktioniert nicht mehr, bitte erwägen Sie, dieses veraltete Antwort

    InformationsquelleAutor Eric Holk
  2. 39

    In Rust 1.0, die folgenden Werke:

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

    Beachten Sie, dass die Länge der inneren Bereich ist ein integraler Bestandteil der Art. Zum Beispiel, können Sie die Referenz - (und pass) state wie folgt:

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

    aber nicht ohne die Angabe der festen Länge des sub-array. Wenn Sie brauchen, variable Länge sub-arrays, die Sie brauchen können, um etwas wie das hier tun:

    let x: [Box<[u8]>; 3] = [
    Box::new([1, 2, 3]),
    Box::new([4]), 
    Box::new([5, 6])
];
let y: &[Box<[u8]>] = &x;
    • Beachten Sie, dass dieses Gerät in Panik, wenn Sie Zugriff out of bounds. Das fühlt sich nicht sehr Rost-like.
    • Danke hardy, aber "(und, ja, die Wandlungsfähigkeit funktioniert jetzt)" -> wie würden Sie Zugriff und mutieren ein element ?
    • in den zwei Jahren seit deinem Kommentar gepostet wurde bounds checking muss richtig umgesetzt wurden, wie ich empfangen compile-Zeit Fehler, wenn Sie versuchen, die out-of-bounds Zugriff auf sowohl die äußeren und inneren arrays.
    InformationsquelleAutor dhardy
  3. 11

    Können Sie erstellen, die eine dynamisch-size-2D-Vektor so:

    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;
}
    • Ich denke, es sollte Lesen ...chunks_mut(height)... vorausgesetzt, der Zugang ist grid[0...width-1][0...height-1]
    InformationsquelleAutor Procrade
  4. 4

    Initialisierung:

    Es gibt mehrere Ansätze für 2D Array-Initialisierung:

    1. Verwendung von Konstanten für M (Zeilen) & N (Spalten) 

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

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

    2. Explizite Deklaration mit Typ-Annotationen

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

    Traversierung:

    Die nur-lese - durchqueren ist so einfach wie:

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

    oder 

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

    Aktualisierung element(s):

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

    Idiomatischer C 2-dimensionale arrays werden deklariert, mit der gleichen Reihenfolge der array-Größen verwendet, die beim Zugriff auf das array:

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

    In Rust, die Erklärung Größen sind gespiegelt; erstellen 8 von 16 2-dimensionales array, die syntax ist:

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