Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

std::basic_string::reserve — pojemność a rozmiar

`reserve(n)` zapewnia miejsce na przyszłe elementy bez zmiany ich liczby. `resize(n)` zmienia liczbę elementów zarówno w napisie, jak i w wektorze.

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

Składnia

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(n) z nagłówka <string> jest dostępne również przez std::string. W C++23 po udanym wywołaniu capacity() >= n, ale size() i zawartość pozostają bez zmian. n oznacza minimalną łączną pojemność, nie liczbę dodatkowych znaków. Jeśli n <= capacity(), nie ma realokacji, a pojemność się nie zmienia. W przeciwnym razie następuje realokacja, a pojemność może być większa niż n.

std::vector::reserve(n) z <vector> według tej samej reguły rezerwuje miejsce na elementy, ale ich nie tworzy. Realokacja unieważnia dotychczasowe wskaźniki, referencje i iteratory do elementów, w tym iterator końca end(). Wektor gwarantuje, że kolejne wstawienia nie spowodują realokacji, dopóki nie przekroczą pojemności. Nie przenoś tej gwarancji na operacje modyfikujące napis.

Użyj resize(n), gdy potrzebujesz dokładnie n elementów: przy zmniejszaniu usuwa końcowe elementy, a przy zwiększaniu dodaje nowe. Warianty s.resize(n, c) i v.resize(n, value) wypełniają nowe pozycje podaną wartością. Zapas pojemności nie rozszerza zakresu indeksów elementów: zapisuj je tylko dla i < size(). W napisie s[s.size()] odnosi się do terminatora zerowego, a nie do dodatkowego znaku napisu.

std::basic_string::reserve(n) zgłasza std::length_error, gdy n > max_size(), i może przekazać wyjątek alokatora, np. std::bad_alloc. W razie wyjątku napis pozostaje bez zmian. Bezargumentowe s.reserve() to osobne, niewiążące żądanie zmniejszenia pojemności, przestarzałe od C++20 i nadal obecne w C++23. Aby o to poprosić, użyj s.shrink_to_fit(); zmniejszenie pojemności nie jest gwarantowane.

Przykłady

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

Wynik

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

Po `reserve(64)` obie kolekcje nadal mają po dwa elementy. Program sprawdza tylko dolną granicę pojemności; dopiero `resize` dodaje po dwa elementy.

Powiązane lekcje

  • C++ · Lekcja 5 · Zaawansowany · Wersja: 3

Źródła