Przestrzenie nazw
Warianty
Działania

std::vector::reserve

Z cppreference.com
< cpp‎ | container‎ | vector
void reserve( size_type new_cap );

Zwiększa pojemność wektora do wielkości równej co najmniej new_cap. Jeśli new_cap jest większe niż obecna pojemność capacity(), alokowana jest nowa pamięć. W przeciwnym wypadku metoda nie robi nic.

Jeśli nowa pojemność new_cap jest większa od obecnej pojemności capacity(), wszystkie referencje i iteratory, wliczając iterator zakońcowy zostają unieważnione. W przeciwnym wypadku, żadne referencje ani iteratory nie zostają unieważnione.

Spis treści

[edytuj] Parametry

new_cap - nowa pojemność wektora
Wymagania względem typów
-
T musi spełniać wymagania MoveInsertable.

[edytuj] Zwracana wartość

(brak)

[edytuj] Wyjątki

Jeśli wyrzucony jest wyjątek, funkcja nie zmienia stanu kontenera. (strong exception guarantee).

Jeśli konstruktor przenoszący T nie jest noexcept oraz T nie jest CopyInsertable do *this, wektor użyje konstruktora przenoszącego. Jeśli ten konstruktor wyrzuci wyjątek, gwarancja niezmienności stanu kontenera jest zniesiona, a efekty niesprecyzowane. (od C++11)

[edytuj] Złożoność

Co najwyżej liniowa względem rozmiaru size() kontenera.

[edytuj] Notka

Poprawne wykorzystanie reserve() pozwala zapobiec niepotrzebnym realokacjom, jednak nieprawidłowe korzystanie z reserve() (np. użycie przed każdym wywołaniem push_back()) może znacząco zwiększyć liczbę realokacji (poprzez spowodowanie liniowego wzrostu pojemności, a nie wykładniczego) i spowodować wzrost złożoności obliczeniowej i spadek wydajności. Dla przykładu, funkcja otrzymująca wektor przez referencję i dokładająca na jego koniec elementy zwykle nie powinna wywoływać reserve() na tym wektorze, gdyż nie zna ona charakterystyki wykorzystywania tego wektora.

W celu wstawienia pewnego zakresu do wektora, lepsza jest z reguły zakresowa wersja insert(), jako że zachowuje poprawne tempo wzrostu (utrzymany jest wzrost wykładniczy), w przeciwieństwie do serii push_back()ów następującej po wywołaniu reserve().

reserve() nie może być wykorzystane do zmniejszenia pojemności kontenera, w tym celu dostarczona jest metoda shrink_to_fit().

[edytuj] Przykład

#include <cstddef>
#include <new>
#include <vector>
#include <iostream>
 
// minimal C++11 allocator with debug output
template <class Tp>
struct NAlloc {
    typedef Tp value_type;
    NAlloc() = default;
    template <class T> NAlloc(const NAlloc<T>&) {}
    Tp* allocate(std::size_t n) {
        n *= sizeof(Tp);
        std::cout << "allocating " << n << " bytes\n";
        return static_cast<Tp*>(::operator new(n));
    }
    void deallocate(Tp* p, std::size_t n) {
        std::cout << "deallocating " << n*sizeof*p << " bytes\n";
        ::operator delete(p);
    }
};
template <class T, class U>
bool operator==(const NAlloc<T>&, const NAlloc<U>&) { return true; }
template <class T, class U>
bool operator!=(const NAlloc<T>&, const NAlloc<U>&) { return false; }
 
int main()
{
    int sz = 100;
    std::cout << "using reserve: \n";
    {
        std::vector<int, NAlloc<int>> v1;
        v1.reserve(sz);
        for(int n = 0; n < sz; ++n)
            v1.push_back(n);
    }
    std::cout << "not using reserve: \n";
    {
        std::vector<int, NAlloc<int>> v1;
        for(int n = 0; n < sz; ++n)
            v1.push_back(n);
    }
}

Możliwy wynik:

using reserve: 
allocating 400 bytes
deallocating 400 bytes
not using reserve: 
allocating 4 bytes
allocating 8 bytes
deallocating 4 bytes
allocating 16 bytes
deallocating 8 bytes
allocating 32 bytes
deallocating 16 bytes
allocating 64 bytes
deallocating 32 bytes
allocating 128 bytes
deallocating 64 bytes
allocating 256 bytes
deallocating 128 bytes
allocating 512 bytes
deallocating 256 bytes
deallocating 512 bytes

[edytuj] Zobacz także

zwraca liczbę elementów, które mogą być przechowane w obecnie zarezerwowanej pamięci
(publiczna metoda) [edit]
zwraca maksymalną możliwą liczbę elementów
(publiczna metoda) [edit]
zmienia liczbę przechowywanych elementów
(publiczna metoda) [edit]
zmniejsza zużycie pamięci poprzez zwolnienie nieużywanej pamięci
(publiczna metoda) [edit]