Why Does the Vector Size Double After the Push_Back Operation in C ?

In C , the std::vector class manages a dynamic array that can grow in size as needed. This dynamic resizing is essential for efficient memory management, especially when elements are frequently added or removed.

Capacity and Size

A vector has two key properties: its size, the number of elements it currently holds, and its capacity, the amount of space allocated for future elements. The capacity is always greater than or equal to the size.

Adding an Element with push_back

When you call push_back to add an element to a vector, the vector performs the following steps:

If the current size is less than the capacity, the new element is added, and both the size and capacity remain unchanged. If the size equals the capacity, meaning the vector is full, the vector needs to allocate more memory to accommodate the new element. To do this efficiently, it typically doubles its capacity and then adds the new element.

By doubling the capacity, the vector can accommodate multiple push_back operations without needing to reallocate memory each time an element is added. This strategy minimizes the number of reallocations, which can be costly in terms of performance.

Evidence of Doubling Capacity

Consider the following code snippet:

#include iostream
#include vector
int main() {
    std::vectorint vec;
    (1);  // Reserve space for at least one element
    for (int i  0; i  10; i  ) {
        vec.push_back(i);
        std::cout  Size:   ()   Capacity:   ()  std::endl;
    }
    return 0;
}

Running this code will show how the size and capacity change with each push_back. Initially, the vector has a size of one and a capacity of one. After the first push_back, both size and capacity remain one. At this point, the vector doesn't need to double the capacity. However, as the elements are added, the capacity will double at certain points—specifically, from 1 to 2 and then from 2 to 4. This demonstrates how the vector manages memory efficiently as it grows.

Why the Size Doubles?

A snarky yet accurate answer to the question is: “Because the vector had a size of 1 before the push_back.” If the vector started with a size of 1 and the push_back succeeds after that, it will have a size of 2, which is obviously doubled. Here’s a step-by-step explanation:

A push_back increases the size by 1.

If the vector runs out of space, a push_back can cause a reallocation. In the case of reallocation, the vector’s capacity increases.

The capacity must increase geometrically that is, the new size should be a factor of the old size. Doubling the capacity is a common strategy because it provides a good balance between memory usage and performance.

The exact factor isn’t specified. However, theoretically, a factor no greater than the golden mean (~1.618) is optimal to allow coalesced chunks to satisfy the next reallocation request. In practice, most implementations use a factor of 3/2 (1.5), which is a bit less than the golden mean.

Some earlier implementations used a factor of 2, but this seems to have fallen out of favor due to performance concerns and the need for more precise control over allocation sizes.

Conclusion

In summary, the vector size doubles after the push_back operation to efficiently manage memory, reduce the number of reallocations, and maintain optimal performance. This doubling strategy is a well-established and effective approach in C programming.