--- title: "Quelle est la différence entre Box<[T]> et Vec ?" description: "Comparaison des différences entre Box<[T]> et Vec concernant la mutabilité, la surcharge mémoire et les implications de performance pour différents cas d'usage" url: "https://mayorana.ch/fr/blog/box-slice-vs-vec-differences" language: "fr" date: "2025-10-28" author: "Mohamed Bennekrouf" tags: - "rust" - "collections" - "box" - "vec" - "memory" - "performance" en_version: "https://mayorana.ch/en/blog/box-slice-vs-vec-differences.md" --- # Quelle est la différence entre Box<[T]> et Vec ?
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 : ```rust 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 : ```rust 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 : ```rust 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 : ```rust 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é.