Are std::vector elements guaranteed to be contiguous?

Yes, the elements in std::vector are guaranteed to be stored contiguously in memory. This means that they are arranged without any gaps, similar to an array. This property enables direct access to elements of std::vector using pointer arithmetic, similar to how we access elements in arrays. For instance, if we have a pointer to the first element of std::vector, we can access subsequent elements by incrementing the pointer. This contiguous memory layout also offers performance benefits, particularly in scenarios involving large data processing and cache-friendly requirements. Because the data is contiguous, the CPU cache can more efficiently preload data, enhancing access speed. Additionally, this contiguous memory layout allows std::vector to provide functions such as data(), which returns a pointer to the first element of the vector. This is especially useful when integrating std::vector with C APIs that expect raw arrays. In this example, we create a std::vector<int> and initialize some values, then obtain a pointer to the underlying array using the data() function and traverse all elements using pointer arithmetic. This demonstrates the contiguity of elements at the low level. Here is the code example:

cpp
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};

    // Get the data pointer of vector
    int* p = v.data();

    // Output the elements of vector
    for (int i = 0; i < v.size(); ++i) {
        std::cout << *(p + i) << " ";  // Access via pointer
    }

    return 0;
}

According to the C++ standard, std::vector must ensure that all elements can be accessed using array syntax, meaning that for a std::vector<T> vec, vec[0], vec[1], up to vec[n-1] (where n is the size of the vector) are stored contiguously in memory. This makes traversing the vector and accessing elements via pointers or array indexing highly efficient. This contiguous storage property also allows direct access to the vector's data using pointers (e.g., using &vec[0]), and enables passing the data as a contiguous block of memory to functions that require it, such as certain C API functions. Additionally, this means that std::vector can effectively utilize CPU cache, further enhancing performance. Therefore, when you need a dynamic array with high performance requirements, choosing std::vector is an ideal choice, as it combines the benefits of dynamic memory management and contiguous memory.