std::vector<T,Allocator>::reserve

C++ 参考手册

位置：首页 > C++ 参考手册 >容器库 >std::vector > std::vector<T,Allocator>::reserve

void reserve( size_type new_cap );

增加 vector 的容量到大于或等于 new_cap 的值。若 new_cap 大于当前的 capacity() ，则分配新存储，否则该方法不做任何事。

reserve() 不更改 vector 的 size 。

若 new_cap 大于 capacity() ，则所有迭代器，包含尾后迭代器和所有到元素的引用都被非法化。否则，没有迭代器或引用被非法化。

参数

new_cap	-	vector 的新容量
类型要求
- `T` 必须满足可移动插入 (MoveInsertable) 的要求。

返回值

（无）

异常

若 new_cap > max_size() 则为 std::length_error 。
任何 Allocator::allocate() 所抛的异常（典型为 std::bad_alloc ）

若抛出异常，则此函数无效果（强异常保证）。

若 `T` 的移动构造函数不是 noexcept 且 T 非可复制插入 (CopyInsertable) 到 `*this` ，则 vector 将使用移动构造函数。若它抛出，则摒弃保证，且效果未指定。	(C++11 起)

复杂度

至多与容器的 size() 成线性。

注意

不能用 reserve() 减少容器容量。为该目的提供的是 shrink_to_fit() 。

正确使用 reserve() 能避免不必要的分配，但不适当地使用 reserve() （例如在每次 push_back() 调用前调用它）可能会实际增加重分配的数量（通过导致容量线性而非指数增长）并导致计算复杂度增加，性能下降。

示例

运行此代码

#include <cstddef>
#include <new>
#include <vector>
#include <iostream>
 
// 带调试输出的最小 C++11 分配器
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(Tp) << " 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);
    }
}

可能的输出：

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

参阅

capacity	返回当前存储空间能够容纳的元素数 (公开成员函数)
max_size	返回可容纳的最大元素数 (公开成员函数)
resize	改变容器中可存储元素的个数 (公开成员函数)
shrink_to_fit (C++11)	通过释放未使用的内存减少内存的使用 (公开成员函数)