How is memory reallocation performed for a…

When adding elements to std::vector, if its current capacity (capacity()) is insufficient to hold new elements, a reallocation of memory occurs:

A new, larger memory buffer is allocated. The size of the new buffer is usually chosen with some margin (for example, 1.5 or 2 times larger than the current), to avoid frequent reallocations.
All existing elements are moved (move semantics, if available and defined for the element type) or copied into the new buffer.
The old memory buffer is freed.
The pointer to the start of the buffer and the vector's capacity are updated to point to the new buffer.

This process can be relatively time-consuming, especially with a large number of elements, as it involves allocating new memory, moving/copying data, and freeing old memory.

The capacity of a vector can be checked using the capacity() method, and the number of elements with size(). Reallocation occurs when size() equals capacity().

Example demonstrating reallocation:

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec;
    std::cout << "Initial capacity: " << vec.capacity() << std::endl;

    for (int i = 0; i < 10; ++i) {
        vec.push_back(i);
        // Check capacity each time
        std::cout << "After adding " << i << ", size: " << vec.size() << ", capacity: " << vec.capacity() << std::endl;
    }

    return 0;
}

This program's output will show how capacity() increases as elements are added, demonstrating reallocation points. The exact growth strategy (by what factor) depends on the standard library implementation.

To optimize performance when the number of elements is known in advance, it is recommended to use the reserve() method to pre-allocate the necessary memory and avoid multiple reallocations.

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec;
    // Pre-allocate memory for 100 elements
    vec.reserve(100);
    std::cout << "Capacity after reserve(100): " << vec.capacity() << std::endl; // Will be >= 100

    for (int i = 0; i < 10; ++i) {
        vec.push_back(i);
        // Capacity does not change until the reserved limit is exceeded
        std::cout << "After adding " << i << ", size: " << vec.size() << ", capacity: " << vec.capacity() << std::endl;
    }

    return 0;
}

Using reserve() can significantly improve insertion performance, especially when adding a large number of elements.

How is memory reallocation performed for a std::vector container in C++?