Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::basic_string::reserve — capacité et taille

`reserve(n)` prévoit de la place sans modifier le nombre d’éléments. `resize(n)` change ce nombre, aussi bien pour une chaîne que pour un vecteur.

Version : ISO C++23; implementation support may vary

Syntaxe

ISO C++23 member declarations (excerpts):

// <string>, in std::basic_string<CharT, Traits, Allocator>
constexpr void reserve(size_type n);
void reserve(); // Deprecated since C++20
constexpr void resize(size_type n);
constexpr void resize(size_type n, CharT c);

// <vector>, in std::vector<T, Allocator>
constexpr void reserve(size_type n);
constexpr void resize(size_type n);
constexpr void resize(size_type n, const T& value);

std::basic_string::reserve est déclaré dans <string> et s’utilise notamment sur std::string. En C++23, après un appel réussi à s.reserve(n), on a capacity() >= n, sans changement de size() ni du contenu. n désigne la capacité totale minimale, pas un nombre de caractères supplémentaires. Si n <= capacity(), il n’y a pas de réallocation et la capacité reste identique. Sinon, la chaîne réalloue son stockage et peut obtenir une capacité supérieure à n.

std::vector::reserve(n), dans <vector>, suit la même règle de capacité sans créer d’éléments. Une réallocation invalide les pointeurs, références et itérateurs existants vers les éléments, ainsi que l’itérateur de fin. Pour un vecteur, les insertions suivantes ne réallouent pas tant qu’elles ne dépassent pas la capacité. Ne supposez pas que cette garantie s’applique aux opérations qui modifient une chaîne.

Utilisez resize(n) pour obtenir exactement n éléments : la réduction supprime les derniers éléments, l’agrandissement en ajoute. Les surcharges s.resize(n, c) et v.resize(n, value) remplissent les nouvelles positions avec la valeur fournie. La capacité inutilisée n’étend pas la plage d’indices des éléments : n’écrivez dans un élément que pour i < size(). Dans une chaîne, s[s.size()] désigne le caractère nul terminal, pas un caractère supplémentaire de la chaîne.

std::basic_string::reserve(n) lève std::length_error si n > max_size() et peut propager une exception de l’allocateur, comme std::bad_alloc. En cas d’exception, la chaîne reste inchangée. La surcharge distincte s.reserve() sans argument est une demande non contraignante de réduction de capacité, dépréciée depuis C++20 mais encore présente en C++23. Utilisez s.shrink_to_fit() pour faire cette demande ; la réduction n’est pas garantie.

Exemples

#include <iostream>
#include <string>
#include <vector>

int main() {
    std::string s = "hi";
    std::vector<int> v{1, 2};

    s.reserve(64);
    v.reserve(64);
    std::cout << std::boolalpha;
    std::cout << "string reserve: " << static_cast<unsigned int>(s.size()) << ' '
              << (s.capacity() >= 64) << ' ' << s << '\n';
    std::cout << "vector reserve: " << static_cast<unsigned int>(v.size()) << ' '
              << (v.capacity() >= 64) << ' ' << v[0] << ' ' << v[1] << '\n';

    s.resize(4, '!');
    v.resize(4, 9);
    std::cout << "string resize: " << static_cast<unsigned int>(s.size())
              << ' ' << s << '\n';
    std::cout << "vector resize: " << static_cast<unsigned int>(v.size())
              << ' ' << v[2] << ' ' << v[3] << '\n';
}

Résultat

string reserve: 2 true hi
vector reserve: 2 true 1 2
string resize: 4 hi!!
vector resize: 4 9 9

Après `reserve(64)`, les deux conteneurs ont toujours deux éléments. Le programme vérifie seulement la borne inférieure de la capacité ; c’est `resize` qui ajoute deux éléments à chacun.

Leçons associées

  • C++ · Leçon 5 · Avancé · Version : 3

Sources