Rust
Tableaux, vecteurs et tranches

Tableaux

Un tableau est une liste d'objets de type unique, allouée de manière statique et de taille statique.

Les tableaux sont généralement créés en incluant une liste d'éléments d'un type donné entre crochets. Le type d'un tableau est désigné par la syntaxe spéciale: [T; N] où T est le type de ses éléments et N leur nombre, qui doivent tous deux être connus au moment de la compilation.

Par exemple, [4u64, 5, 6] est un tableau de 3 éléments de type [u64; 3] . Remarque: 5 et 6 sont supposés être de type u64 .

Exemple

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

Limites

La correspondance des motifs sur les tableaux (ou les tranches) n'est pas prise en charge dans Rust stable (voir les modèles de tranches et les numéros 23121 ).

La rouille ne supporte pas la généricité des chiffres au niveau du type (voir RFC # 1657 ). Par conséquent, il n'est pas possible d'implémenter simplement un trait pour tous les tableaux (de toutes tailles). Par conséquent, les caractéristiques standard ne sont implémentées que pour les tableaux d'un nombre limité d'éléments (dernier contrôle, jusqu'à 32 inclus). Les tableaux avec plus d'éléments sont supportés, mais n'implémentent pas les traits standard (voir docs ).

Nous espérons que ces restrictions seront levées à l'avenir.

Vecteurs

Un vecteur est essentiellement un pointeur sur une liste d'objets de type unique, de taille dynamique et allouée au tas.

Exemple

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

Tranches

Les tranches sont des vues dans une liste d'objets et ont le type [T] , indiquant une tranche d'objets de type T

Une tranche est un type non formaté et ne peut donc être utilisé qu’avec un pointeur. (Analogie du monde des chaînes: str , appelée string slice, est également non formatée.)

Les tableaux sont forcés dans des tranches et les vecteurs peuvent être déréférencés en tranches. Par conséquent, les méthodes de tranche peuvent être appliquées aux deux. (Analogie du monde de la chaîne: str est à String , ce que [T] à 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]
}