These members are not defined in the Random Access Container and Back Insertion Sequence requirements, but are specific to vector.
| Member | Description |
size_type capacity() const | Number of elements for which memory has been allocated. capacity() is always greater than or equal to size(). [2] [3] |
void reserve(size_type n) | If n is less than or equal to capacity() , this call has no effect. Otherwise, it is a request for allocation of additional memory. If the request is successful, then capacity() is greater than or equal to n; otherwise, capacity() is unchanged. In either case, size() is unchanged. [2] [4] |
Notes [1] This member function relies on member template functions, which at present (early 1998) are not supported by all compilers. If your compiler supports member templates, you can call this function with any type of input iterator. If your compiler does not yet support member templates, though, then the arguments must be of type const value_type*.
[2] Memory will be reallocated automatically if more than capacity() – size() elements are inserted into the vector. Reallocation does not change size(), nor does it change the values of any elements of the vector. It does, however, increase capacity(), and it invalidates [5] any iterators that point into the vector.
[3] When it is necessary to increase capacity(), vector usually increases it by a factor of two. It is crucial that the amount of growth is proportional to the current capacity() , rather than a fixed constant: in the former case inserting a series of elements into a vector is a linear time operation, and in the latter case it is quadratic.
[4] Reserve() causes a reallocation manually. The main reason for using reserve() is efficiency: if you know the capacity to which your vector must eventually grow, then it is usually more efficient to allocate that memory all at once rather than relying on the automatic reallocation scheme. The other reason for using reserve () is so that you can control the invalidation of iterators. [5]
[5] A vector's iterators are invalidated when its memory is reallocated. Additionally, inserting or deleting an element in the middle of a vector invalidates all iterators that point to elements following the insertion or deletion point. It follows that you can prevent a vector's iterators from being invalidated if you use reserve() to preallocate as much memory as the vector will ever use, and if all insertions and deletions are at the vector's end.
See also deque, list, slist
Category: containers
Component type: type
Description A deque [1] is very much like a vector: like vector, it is a sequence that supports random access to elements, constant time insertion and removal of elements at the end of the sequence, and linear time insertion and removal of elements in the middle.
The main way in which deque differs from vector is that deque also supports constant time insertion and removal of elements at the beginning of the sequence [2]. Additionally, deque does not have any member functions analogous to vector 's capacity() and reserve() , and does not provide any of the guarantees on iterator validity that are associated with those member functions. [3]
Example deque<int> Q;
Q.push_back(3);
Q.push_front(1);
Q.insert(Q.begin() + 1, 2);
Q[2] = 0;
copy(Q.begin(), Q.end(), ostream_iterator<int>(cout, ' '));
// The values that are printed are 1 2 0
Definition Defined in the standard header deque, and in the nonstandard backward-compatibility header deque.h.
Template parameters | Parameter | Description | Default |
T | The deque's value type: the type of object that is stored in the deque. | |
Alloc | The deque 's allocator, used for all internal memory management. | alloc |
Model of Random access container, Front insertion sequence, Back insertion sequence.
Type requirements None, except for those imposed by the requirements of Random access container, Front insertion
