std::vector

std::vector is a sequence container that encapsulates a dynamically sized contiguous array.

Its elements are stored contiguously, so a pointer to an element can be passed to APIs that expect a pointer into an array. That contiguous-storage guarantee is one of the main reasons vector is the default owning sequence container in modern C++.

# Declarations

template<
class T,
class Allocator = std::allocator<T>
> class vector;

namespace pmr {
template< class T >
using vector = std::vector<T, std::pmr::polymorphic_allocator<T>>;
}

(since C++17)

# Template parameters

• T: element type. The exact requirements depend on the operations used. In general, elements must be erasable, and many operations impose stronger construction, assignment, or move requirements.
• Allocator: allocator used to obtain storage and manage element lifetimes. It must satisfy the Allocator requirements. Since C++20, the program is ill-formed if Allocator::value_type is not T.

# Incomplete-type support

Since C++17, vector itself may be instantiated with an incomplete element type if the allocator satisfies the allocator completeness requirements. Individual member functions may still require T to be complete at the point of use.

# Specializations

• std::pmr::vector<T> is an alias for std::vector<T, std::pmr::polymorphic_allocator<T>>.
• std::vector<bool> is a space-optimized partial specialization with proxy-reference behavior and different practical tradeoffs from ordinary vector<T>.

# Example

#include <iostream>
#include <vector>
 
int main()
{
    // Create a vector containing integers
    std::vector<int> v = {8, 4, 5, 9};
 
    // Add two more integers to vector
    v.push_back(6);
    v.push_back(9);
 
    // Overwrite element at position 2
    v[2] = -1;
 
    // Print out the vector
    for (int n : v)
        std::cout << n << ' ';
    std::cout << '\n';
}

This is the common vector usage pattern: contiguous owning storage, random-access element updates, and amortized constant-time growth at the end.

# Member types

# Iterator invalidation

Capacity growth is therefore the main boundary between stable and unstable references in vector code.

# Reference map

# Deduction guides

The class has deduction guides so direct construction can infer T and, where applicable, allocator-related types from constructor arguments.

# Notes

vector is usually the right default when you need random-access iteration, amortized constant-time append at the end, and contiguous storage.

Insertion or erasure in the middle is comparatively expensive because elements after the affected position must be moved or shifted.

# Feature-test macros

# Defect reports

# See also

• inplace_vector
• array
• deque