Namespaces
Variants

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

From cppreference.net

void resize ( size_type count ) ;
(1) (constexpr depuis C++26)
void resize ( size_type count, const value_type & value ) ;
(2) (constexpr depuis C++26)

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'à 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 deque .
2) T n'est pas CopyInsertable dans deque .
(depuis C++11)

Complexité

Linéaire dans la différence entre la taille actuelle et count .

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 .

Exemple

#include <deque>
#include <iostream>
void print(auto rem, const std::deque<int>& c)
{
    for (std::cout << rem; const int el : c)
        std::cout << el << ' ';
    std::cout << '\n';
}
int main()
{
    std::deque<int> c = {1, 2, 3};
    print("The deque 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 deque 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 1418 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. T n'était pas requis d'être MoveInsertable
1. utilise pop_back()
2. requis
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 deque , 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 deque , rendant le MoveAssignable inutile.
  2. La suppression d'éléments en utilisant pop_back() implique que les éléments doivent être supprimés de l'arrière vers l'avant.

Voir aussi

renvoie le nombre maximum possible d'éléments
(fonction membre publique)
renvoie le nombre d'éléments
(fonction membre publique)
vérifie si le conteneur est vide
(fonction membre publique)