std::vector<T,Allocator>:: resize
|
void
resize
(
size_type count
)
;
|
(1) | (constexpr depuis C++20) |
|
void
resize
(
size_type count,
const
value_type
&
value
)
;
|
(2) | (constexpr depuis C++20) |
Redimensionne le conteneur pour contenir count éléments :
- Si count est égal à la taille actuelle, ne fait rien.
- Si la taille actuelle est supérieure à count , le conteneur est réduit à ses premiers count éléments.
- Si la taille actuelle est inférieure à count , alors :
Table des matières |
Paramètres
| count | - | nouvelle taille du conteneur | ||
| value | - | la valeur pour initialiser les nouveaux éléments | ||
| Exigences de type | ||||
-
|
||||
Complexité
Linéaire dans la différence entre la taille actuelle et count . Complexité supplémentaire possible due à la réallocation si la capacité est inférieure à count .
Exceptions
Si une exception est levée pour quelque raison que ce soit, ces fonctions n'ont aucun effet (
garantie de sécurité d'exception forte
).
Bien que non explicitement spécifié,
std::length_error
est levé si la capacité requise par le nouveau
vector
dépasse
max_size()
.
|
Dans la surcharge
(
1
)
, si le constructeur par déplacement de
|
(depuis C++11) |
Notes
Si l'initialisation par défaut dans la surcharge
(
1
)
est indésirable, par exemple si les éléments sont de type non-classe et que la mise à zéro n'est pas nécessaire, elle peut être évitée en fournissant un
personnalisé
Allocator::construct
.
La capacité du vecteur n'est jamais réduite lors du redimensionnement vers une taille plus petite car cela invaliderait tous les itérateurs, alors que la spécification n'invalide que les itérateurs vers/après les éléments effacés.
Exemple
#include <vector> #include <iostream> void print(auto rem, const std::vector<int>& c) { for (std::cout << rem; const int el : c) std::cout << el << ' '; std::cout << '\n'; } int main() { std::vector<int> c = {1, 2, 3}; print("The vector holds: ", c); c.resize(5); print("After resize up to 5: ", c); c.resize(2); print("After resize down to 2: ", c); c.resize(6, 4); print("After resize up to 6 (initializer = 4): ", c); }
Sortie :
The vector holds: 1 2 3 After resize up to 5: 1 2 3 0 0 After resize down to 2: 1 2 After resize up to 6 (initializer = 4): 1 2 4 4 4 4
Rapports de défauts
Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.
| DR | Appliqué à | Comportement publié | Comportement corrigé |
|---|---|---|---|
| LWG 679 | C++98 |
resize()
passait
value
par valeur
|
passe par référence constante |
| LWG 1525 | C++98 | le comportement de resize ( size ( ) ) n'était pas spécifié | spécifié |
| LWG 2033 | C++11 |
1. les éléments étaient supprimés en utilisant
erase()
[1]
2. les exigences de type pour
T
étaient incorrectes
|
1. utilise
pop_back()
2. corrigées |
| LWG 2066 | C++11 |
la surcharge
(
1
)
n'avait pas la garantie
de sûreté d'exception de la surcharge ( 2 ) |
ajoutée |
| LWG 2160 | C++11 |
les éléments étaient supprimés en utilisant
pop_back()
[2]
suite à la résolution de LWG 2033 |
ne spécifie pas la méthode
de suppression des éléments |
-
↑
erase()
peut supprimer des éléments au milieu d'un
vector, donc le type de valeur doit être MoveAssignable afin que les éléments suivant la section supprimée puissent être déplacés vers l'avant pour combler l'espace. Cependant,resize()ne peut supprimer que des éléments à la fin duvector, rendant MoveAssignable inutile. - ↑ Supprimer des éléments en utilisant pop_back() implique que les éléments doivent être supprimés de la fin vers le début.
Voir aussi
|
retourne le nombre maximum possible d'éléments
(fonction membre publique) |
|
|
retourne le nombre d'éléments
(fonction membre publique) |
|
|
retourne le nombre d'éléments pouvant être contenus dans le stockage actuellement alloué
(fonction membre publique) |
|
|
vérifie si le conteneur est vide
(fonction membre publique) |