The C++ vector library provides a sequence container that combines efficient random access, value semantics, and dynamic resizing. This guide explains how std::vector works in practice, when it is appropriate, and how to use it safely and efficiently. You will find clear rules on complexity guarantees, reallocation behavior, move versus copy operations, and common pitfalls. Written for everyday use, the content stays evergreen by focusing on widely supported standard semantics rather than transient implementation details.
std::vector Core Semantics
std::vector is a contiguous sequence container that manages a dynamic array of objects. It owns its elements, handles destruction automatically, and provides value semantics. Vectors grow as needed through reallocation, and they expose familiar interfaces such as at(), operator[], front(), back(), and data(). Because elements are stored contiguously, vector benefits from cache friendliness and integrates well with C APIs and algorithms expecting arrays. This section explains the fundamental guarantees and constraints that make vector a default choice for many C++ developers.
Contiguity and Layout Guarantees
The C++ standard guarantees that vector elements are stored contiguously, matching array
Allocator Model and Customization
Vector uses an allocator to manage memory and construct or destroy elements. By default, std::allocator is used, which relies on operator new and delete. You can supply a custom allocator to control allocation behavior, enable shared memory patterns, or integrate with specialized memory pools. The allocator type is part of the vector type, which affects container copying and container identity across library boundaries. Standard library implementations typically require allocators to meet the Allocator requirements, including rebind support and pointer traits compatibility.
Construction, Assignment, and Destructor Behavior
Vector supports multiple construction patterns: default construction, fill construction, range construction from iterators, and initializer list construction. Move construction and move assignment leave the source in a valid but unspecified state, typically empty. Copy construction and copy assignment perform element-wise copies. Destructor calls the destructor of each element and deallocates storage, unless a custom allocator specifies otherwise. Understanding these distinctions helps avoid subtle resource management issues in complex types.
Initialization and Emplacement Options
- Default initialization: creates an empty vector with no allocated storage.
- Fill initialization: vector(n, value) creates n copies of value.
- Range initialization: vector(first, last) copies from iterator range.
- Initializer list: vector({1, 2, 3}) uses std::initializer_list.
- Emplace back: constructs elements in-place using forwarded arguments.
Move, Copy, and Swapping Semantics
Move operations on vector are typically constant time and leave the source in a valid but unspecified (often empty) state. Copy operations duplicate elements and allocate independent storage. Swap between vectors is constant time and exchanges internal pointers, capacity, and size. These properties make vector efficient for return values and easy to reason about in expressions involving temporaries.
Capacity, Growth, and Complexity Guarantees
Vector exposes size(), max_size(), capacity(), empty(), and reserve(). Reserve ensures that capacity() is at least the argument, preventing reallocation until size exceeds reserved capacity. Resize changes size, default-inserting or value-initializing elements as needed. Complexity guarantees are important: random access is O(1), insertion or removal in the middle is O(n), and push back is amortized constant time. Understanding growth factors helps anticipate memory usage and reallocation frequency.
Reallocation and Stability Guarantees
When size() exceeds capacity(), vector reallocates and moves existing elements to new storage. If move construction is noexcept, elements are moved; otherwise, they are copied to preserve correctness. Reallocation invalidates references, pointers, and iterators to elements. Methods reserve() and shrink_to_fit() provide control over capacity, where shrink_to_fit is a nonbinding request to reduce capacity to fit size. These rules remain consistent across standard library versions and are safe assumptions for long-term codebases.
Common Complexity and Capacity Operations
| Operation | Complexity | Notes |
|---|---|---|
| operator[] | Constant | No bounds checking |
| at | Constant | Bounds checking; throws on out_of_range |
| front / back | Constant | Undefined if empty |
| push_back | Amortized constant | Reallocation if capacity exceeded |
| pop_back | Constant | Destroys last element |
| insert(pos, count, value) | O(n + count) | Elements moved or copied |
| erase(pos) | O(n) | Elements moved to fill gap |
| reserve(n) | Linear in size + new capacity | Prepares storage, may reallocate |
| clear | Linear in size | Destroys all elements |
| shrink_to_fit | Linear | Nonbinding request to reduce capacity |
Element Access, Iterators, and Range‑Based Usage
Vector supports direct pointer access via data() and reference access via operator[] and at(). Prefer at() when bounds safety is important, because it performs checking and throws exceptions on invalid indices. Iterators returned by begin() and end() are random access and remain valid until reallocation or erasure. Range-based for loops work naturally, but be cautious when erasing elements during iteration; prefer the erase–remove idiom to avoid invalidation issues.
Pointers, Iterators, and Reference Stability
- References and pointers to elements are invalidated on reallocation.
- Insertion at end may cause reallocation; all iterators and references are invalidated.
- Insertion or removal in the middle invalidates iterators and references at and after the point of insertion or removal.
- Calling reserve() can prevent reallocation and keep references valid up to size changes within the new capacity.
Safe Patterns and Best Practices
Use vector as the default sequence container unless you have specific reasons such as intrusive containers or strict no‑dynamic‑allocation constraints. Initialize with reserve() when the final size is approximately known to avoid repeated reallocations. Avoid storing raw pointers into vector elements if the vector may reallocate; prefer handles like indices or use stable containers when necessary. Prefer emplace_back over push_back with temporaries to construct elements directly in storage and reduce move or copy steps.
Recommended Usage Patterns
- Default member initialization: std::vector<T> items{};
- Preallocate known capacity: vec.reserve(estimate);
- Append with emplace: vec.emplace_back(args...);
- Clear efficiently: vec.clear(); vec.shrink_to_fit(); if you need to minimize memory.
- Erase–remove idiom: vec.erase(std::remove(vec.begin(), vec.end(), value), vec.end());