Namespaces
Variants

std::vector<T,Allocator>:: resize

From cppreference.net

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 :
1) Des copies supplémentaires de T ( ) (jusqu'en C++11) éléments insérés par défaut (depuis C++11) sont ajoutés.
2) Des copies supplémentaires de value sont ajoutées.

Table des matières

Paramètres

count - nouvelle taille du conteneur
value - la valeur pour initialiser les nouveaux éléments
Exigences de type
-

Si la condition suivante est satisfaite, le comportement est indéfini :

1) T n'est pas DefaultInsertable ou MoveInsertable dans vector .
2) T n'est pas CopyInsertable dans vector .
(depuis C++11)

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 T n'est pas noexcept et si T n'est pas CopyInsertable dans * this , vector utilisera le constructeur par déplacement pouvant lever une exception. S'il lève une exception, la garantie est annulée et les effets ne sont pas spécifiés.

(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
  1. 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 du vector , rendant MoveAssignable inutile.
  2. 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)