Namespaces
Variants

std::list<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'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 dans list .
2) T n'est pas CopyInsertable dans list .
(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 <list>
#include <iostream>
void print(auto rem, const std::list<int>& c)
{
    for (std::cout << rem; const int el : c)
        std::cout << el << ' ';
    std::cout << '\n';
}
int main()
{
    std::list<int> c = {1, 2, 3};
    print("The list 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 list 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 132 C++98 des itérateurs à accès aléatoire étaient utilisés pour déterminer la plage d'effacement utiliser des itérateurs bidirectionnels
LWG 679 C++98 resize() passait value par valeur passe par référence constante
LWG 1420 C++98 le comportement de resize ( size ( ) ) n'était pas spécifié spécifié

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)