Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

std::basic_string::reserve — kapacita a velikost

`reserve(n)` připraví místo pro budoucí prvky, aniž změní jejich počet. `resize(n)` mění počet prvků jak v řetězci, tak ve vektoru.

Verze: 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 je deklarována v <string> a lze ji volat i na std::string. V C++23 po úspěšném volání s.reserve(n) platí capacity() >= n, zatímco size() a obsah se nemění. n je minimální celková kapacita, nikoli počet znaků navíc. Pokud n <= capacity(), k realokaci nedojde a kapacita zůstane stejná. Jinak dojde k realokaci a kapacita může být větší než n.

std::vector::reserve(n) z <vector> se řídí stejným pravidlem pro kapacitu, aniž by vytvářela prvky. Realokace zneplatní dosavadní ukazatele, reference a iterátory na prvky i koncový iterátor. Vektor zaručuje, že při dalších vloženích nedojde k realokaci, dokud některé vložení nepřekročí kapacitu. Tuto záruku nepřenášej na operace měnící řetězec.

Použij resize(n), když potřebuješ přesně n prvků: při zmenšení odebere prvky z konce a při zvětšení přidá nové. Přetížení s.resize(n, c) a v.resize(n, value) vyplní nové pozice zadanou hodnotou. Volná kapacita nerozšiřuje rozsah indexů prvků: do prvků zapisuj jen pro i < size(). V řetězci s[s.size()] označuje ukončovací nulový znak, nikoli další znak řetězce.

std::basic_string::reserve(n) vyvolá std::length_error, pokud n > max_size(), a může předat výjimku alokátoru, například std::bad_alloc. Při výjimce zůstává řetězec beze změny. Samostatné přetížení s.reserve() bez argumentu je nezávazný požadavek na snížení kapacity, zastaralý od C++20, ale stále přítomný v C++23. Použij místo něj s.shrink_to_fit(); snížení není zaručeno.

Příklady

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

Výsledek

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

Po `reserve(64)` mají oba kontejnery stále dva prvky. Program kontroluje jen dolní mez kapacity; teprve `resize` přidá do každého kontejneru dva prvky.

Související lekce

  • C++ · Lekce 5 · Pokročilá · Verze: 3

Zdroje