Rust
Arrays, Vektoren und Slices

Arrays

Ein Array ist eine dem Stapel zugeordnete Liste von Objekten eines einzigen Typs mit statischer Größe.

Arrays werden normalerweise erstellt, indem eine Liste von Elementen eines bestimmten Typs in eckige Klammern eingeschlossen wird. Der Typ eines Arrays wird mit der speziellen Syntax angegeben: [T; N] wobei T die Art seiner Elemente und N ihre Anzahl ist, die beide zum Zeitpunkt der Kompilierung bekannt sein müssen.

Beispielsweise ist [4u64, 5, 6] ein 3-Element-Array vom Typ [u64; 3] . Anmerkung: Es wird angenommen, dass 5 und 6 vom Typ u64 .

Beispiel

fn main() {
    // Arrays have a fixed size.
    // All elements are of the same type.
    let array = [1, 2, 3, 4, 5];

    // Create an array of 20 elements where all elements are the same.
    // The size should be a compile-time constant.
    let ones = [1; 20];

    // Get the length of an array.
    println!("Length of ones: {}", ones.len());

    // Access an element of an array.
    // Indexing starts at 0.
    println!("Second element of array: {}", array[1]);

    // Run-time bounds-check.
    // This panics with 'index out of bounds: the len is 5 but the index is 5'.
    println!("Non existant element of array: {}", array[5]);
}

Einschränkungen

Pattern-Matching auf Arrays (oder Slices) wird im stabilen Rust nicht unterstützt (siehe # 23121 und Slice-Pattern ).

Rust unterstützt keine Generizität von Ziffern auf Typebene (siehe RFCs # 1657 ). Daher ist es nicht möglich, ein Merkmal einfach für alle Arrays (aller Größen) zu implementieren. Daher werden die Standardmerkmale nur für Arrays mit einer begrenzten Anzahl von Elementen implementiert (zuletzt geprüft, bis zu 32 eingeschlossen). Arrays mit mehr Elementen werden unterstützt, implementieren jedoch nicht die Standardmerkmale (siehe Dokumente ).

Diese Einschränkungen werden hoffentlich in Zukunft aufgehoben.

Vektoren

Ein Vektor ist im Wesentlichen ein Zeiger auf eine Heap-zugewiesene Liste von Objekten eines einzelnen Typs mit dynamischer Größe.

Beispiel

fn main() {
    // Create a mutable empty vector
    let mut vector = Vec::new();

    vector.push(20);
    vector.insert(0, 10); // insert at the beginning

    println!("Second element of vector: {}", vector[1]); // 20

    // Create a vector using the `vec!` macro
    let till_five = vec![1, 2, 3, 4, 5];

    // Create a vector of 20 elements where all elements are the same.
    let ones = vec![1; 20];

    // Get the length of a vector.
    println!("Length of ones: {}", ones.len());

    // Run-time bounds-check.
    // This panics with 'index out of bounds: the len is 5 but the index is 5'.
    println!("Non existant element of array: {}", till_five[5]);
}

Scheiben

Slices sind Ansichten in eine Liste von Objekten und haben Typ [T] , der eine Slice von Objekten mit Typ T .

Ein Slice ist ein nicht skalierter Typ und kann daher nur hinter einem Zeiger verwendet werden. (String-World-Analogie: str , als String-Slice bezeichnet, hat ebenfalls keine Größe.)

Arrays werden zu Slices zusammengefügt, Vektoren können zu Slices dereferenziert werden. Daher können Slice-Methoden auf beide angewendet werden. (String-Welt-Analogie: str ist zu String , was [T] zu Vec<T> .)

fn main() {
    let vector = vec![1, 2, 3, 4, 5, 6, 7, 8];
    let slice = &vector[3..6];
    println!("length of slice: {}", slice.len()); // 3
    println!("slice: {:?}", slice); // [4, 5, 6]
}