#rust#collections#box
October 28, 2025•5 min

Quelle est la différence entre Box<[T]> et Vec<T> ?

m
mayo

Table des matières

Disposition mémoire Vec<T> vs Box<[T]> Vec<T> ptr len capacity heap : éléments contigus 3 usizes sur la pile (24 octets en 64 bits) Box<[T]> ptr len heap : éléments taille fixe 2 usizes sur la pile — pas de champ capacity

Différences principales

Caractéristique Vec Box<[T]>
Mutabilité de taille Redimensionnable (push, pop) Taille fixe (immuable après création)
Stockage Allocation sur le heap + champ capacité Slice pur sur le heap (pas de métadonnées supplémentaires)
Surcharge mémoire 3 usizes (ptr, len, capacity) 2 usizes (ptr, len)
Coût de conversion O(1) vers Box<[T]> (shrink-to-fit) O(n) vers Vec (doit réallouer)

Quand utiliser chacun

Préfère Vec quand :

Tu as besoin de redimensionnement dynamique :

let mut vec = vec![1, 2, 3];
vec.push(4);  // Fonctionne

Tu modifies fréquemment la collection (par exemple, ajout/suppression d'éléments).

Préfère Box<[T]> quand :

Tu veux une collection de taille fixe et immuable :

let boxed_slice: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
// boxed_slice.push(4);  // ERREUR : Pas de méthode `push`

L'efficacité mémoire est importante (par exemple, systèmes embarqués) :

  • Économise 1 usize (pas de capacité inutilisée).

Interface avec des APIs nécessitant des slices possédés :

fn process(data: Box<[i32]>) { /* ... */ }

Conversion entre eux

Direction Code Coût
Vec → Box<[T]> vec.into_boxed_slice() O(1)
Box<[T]> → Vec Vec::from(boxed_slice) O(n)
Coût de l'aller-retour into_boxed_slice() · O(1) quand capacité == len Vec<i32> len 3 · cap 3 Box<[i32]> len 3 · taille exacte Vec::from(boxed) · O(n), alloue et recopie chaque élément Si cap > len, le O(1) ne tient plus into_boxed_slice() doit d'abord rétrécir : allouer la taille exacte, copier, libérer l'ancien bloc Convertis une seule fois, quand les modifications sont finies — l'aller-retour coûte une copie dans chaque sens.

Exemple :

let vec = vec![1, 2, 3];
let boxed: Box<[i32]> = vec.into_boxed_slice();  // Pas de réallocation
let vec_again = Vec::from(boxed);                // Copie les données

Implications de performance

  • Itération : Identique (les deux sont des tableaux contigus sur le heap).
  • Mémoire : Box<[T]> évite la surcharge de capacité inutilisée.
  • Flexibilité : Vec supporte la croissance en place ; Box<[T]> ne le fait pas.

Cas d'usage réels

  • Vec : Tampons pour données dynamiques (par exemple, corps de requêtes HTTP).
  • Box<[T]> :
    • Configurations chargées une fois et jamais modifiées.
    • Stockage de grands jeux de données immuables (par exemple, assets de jeu).

Points clés

Utilise Vec pour des séquences mutables et redimensionnables. Utilise Box<[T]> pour du stockage immuable et efficace en mémoire. Convertis facilement de Vec vers Box<[T]> quand tu as fini de modifier.

C'est sur un Vec qui traîne de la capacité libre que la conversion paie vraiment : into_boxed_slice() réalloue à la longueur exacte, et le rab retourne à l'allocateur au lieu d'être transporté.

Tags

#rust#collections#box#vec#memory#performance
Retour au blog
Partager ::