Rust
Arrays, vectoren en segmenten

arrays

Een array is een stapel-toegewezen lijst met statische afmetingen van objecten van één type.

Arrays worden meestal gemaakt door een lijst met elementen van een bepaald type tussen vierkante haakjes te plaatsen. Het type array wordt aangeduid met de speciale syntaxis: [T; N] waarin T het type van zijn elementen is en N hun telling, die beide bekend moeten zijn tijdens het compileren.

[4u64, 5, 6] is bijvoorbeeld een array met 3 elementen van het type [u64; 3] . Opmerking: 5 en 6 worden afgeleid van het type u64 .

Voorbeeld

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

beperkingen

Zoekpatronen arrays (of schijven) wordt niet ondersteund in stabiele Rust (zie # 23121 en slice patronen ).

Roest ondersteunt geen genericiteit van typeniveau-cijfers (zie RFC's # 1657 ). Daarom is het niet mogelijk om eenvoudig een eigenschap voor alle arrays (van alle groottes) te implementeren. Als gevolg hiervan worden de standaardkenmerken alleen geïmplementeerd voor arrays tot een beperkt aantal elementen (laatst gecontroleerd, tot 32 inbegrepen). Arrays met meer elementen worden ondersteund, maar implementeren niet de standaardkenmerken (zie docs ).

Deze beperkingen worden hopelijk in de toekomst opgeheven.

vectoren

Een vector is in wezen een pointer naar een heap-toegewezen, dynamisch formaat lijst met objecten van een enkel type.

Voorbeeld

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

Slices

Segmenten zijn weergaven in een lijst met objecten en hebben type [T] , waarmee een segment van objecten met type T .

Een segment is van een ongeschikt type en kan daarom alleen achter een aanwijzer worden gebruikt. (String world analogy: str , string slice genoemd, heeft ook geen grootte.)

Arrays worden in plakjes gedwongen en vectoren kunnen van plakjes worden gescheiden. Daarom kunnen plakmethoden op beide worden toegepast. (String world analogy: str is to String , wat [T] is voor 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]
}