KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::basic_string::reserve — capaciteit versus grootte

`reserve(n)` maakt ruimte voor toekomstige elementen zonder hun aantal te wijzigen. `resize(n)` wijzigt dat aantal bij zowel strings als vectoren.

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

Syntax

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 is gedeclareerd in <string> en is beschikbaar op std::string. In C++23 geldt na een geslaagde aanroep van s.reserve(n) dat capacity() >= n, terwijl size() en de inhoud gelijk blijven. n is de minimale totale capaciteit, niet het aantal extra tekens. Als n <= capacity(), vindt geen herallocatie plaats en blijft de capaciteit gelijk. Anders wordt de opslag opnieuw toegewezen en kan de capaciteit groter worden dan n.

std::vector::reserve(n) in <vector> volgt dezelfde capaciteitsregel zonder elementen aan te maken. Herallocatie maakt bestaande pointers, referenties en iterators naar elementen ongeldig, evenals de iterator voorbij het laatste element. Een vector garandeert dat latere invoegingen niet heralloceren totdat een invoeging de capaciteit zou overschrijden. Ga er niet van uit dat die garantie ook geldt voor bewerkingen die een string wijzigen.

Gebruik resize(n) als je precies n elementen nodig hebt: bij verkleinen verdwijnen elementen aan het einde, bij vergroten komen er elementen bij. De overloads s.resize(n, c) en v.resize(n, value) vullen nieuwe posities met de opgegeven waarde. Ongebruikte capaciteit vergroot het indexbereik van de elementen niet: schrijf alleen naar elementen als i < size(). Bij een string verwijst s[s.size()] naar het afsluitende nulteken, niet naar een extra teken in de string.

std::basic_string::reserve(n) werpt std::length_error als n > max_size() en kan een uitzondering van de allocator, zoals std::bad_alloc, doorgeven. Bij een uitzondering blijft de string ongewijzigd. De aparte overload s.reserve() zonder argument is een niet-bindend verzoek om de capaciteit te verkleinen. Deze is sinds C++20 verouderd, maar bestaat nog in C++23. Gebruik s.shrink_to_fit() voor dat verzoek; een verkleining is niet gegarandeerd.

Voorbeelden

#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';
}

Resultaat

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

Na `reserve(64)` hebben beide containers nog steeds twee elementen. Het programma controleert alleen de ondergrens van de capaciteit; pas `resize` voegt aan elke container twee elementen toe.

Gerelateerde lessen

  • C++ · Les 5 · Gevorderd · Versie: 3

Bronnen