Rust
Array, Vettori e Fette

Array

Un array è un elenco di oggetti di un singolo tipo, allocato allo stack in modo statico.

Gli array vengono generalmente creati racchiudendo un elenco di elementi di un determinato tipo tra parentesi quadre. Il tipo di array è indicato con la sintassi speciale: [T; N] dove T è il tipo dei suoi elementi e N loro conteggio, entrambi devono essere noti al momento della compilazione.

Ad esempio, [4u64, 5, 6] è una matrice di 3 elementi di tipo [u64; 3] . Nota: 5 e 6 sono dedotti per essere di tipo u64 .

Esempio

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

limitazioni

La corrispondenza del modello su array (o sezioni) non è supportata in Rust stabile (vedere # 23121 e modelli di sezioni).

Rust non supporta la genericità dei numeri a livello di testo (vedere RFC # 1657 ). Pertanto, non è possibile implementare semplicemente un tratto per tutti gli array (di tutte le dimensioni). Di conseguenza, i tratti standard vengono implementati solo per gli array fino a un numero limitato di elementi (l'ultimo controllo, fino a 32 inclusi). Sono supportati gli array con più elementi, ma non implementano i tratti standard (vedi documenti ).

Si spera che queste restrizioni vengano revocate in futuro.

Vettori

Un vettore è essenzialmente un puntatore a un elenco di oggetti di un singolo tipo allocati in modo dinamico e dimensionato su heap.

Esempio

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

fette

Le slice sono viste in un elenco di oggetti e hanno tipo [T] , che indica una porzione di oggetti con tipo T

Una sezione è un tipo non standardizzato e pertanto può essere utilizzata solo dietro un puntatore. (String world analogy: str , chiamato slice slice, è anche unsized).

Gli array vengono convertiti in sezioni e i vettori possono essere sottoposti a dereferenziazione a sezioni. Pertanto, i metodi slice possono essere applicati a entrambi. (Stringa analogia del mondo: str is to String , what [T] is to 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]
}