What happens to vector elements when performing…

When performing a realloc operation on memory managed by a vector (for example, when using std::vector and manually working with a data pointer), the following occurs:

A new block of memory of larger size is allocated.
The old elements are copied (byte-wise) into the new memory block.
The old memory block is freed.

It is important to note that std::vector manages its memory internally when resizing (via resize, push_back on overflow) using its own allocation mechanisms and constructors/destructors of objects. realloc is not directly used by std::vector. Using realloc with a pointer obtained from std::vector::data() leads to undefined behavior, as std::vector does not control this new memory block and its elements will not be correctly initialized/copied using copy constructors.

If this were an old C-style array working directly with malloc/realloc, then it would simply byte-wise copy the data without calling constructors or assignment operators.

In the context of C++ and std::vector, resizing involves:

Allocating a new buffer (possibly larger).
Moving (preferably) or copying elements from the old buffer to the new one.
Calling destructors for objects in the old buffer.
Freeing the old buffer.

Example of C-style realloc usage:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    int *arr = (int *)malloc(3 * sizeof(int)); // Allocate memory for 3 ints
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;

    // Suppose we need to increase the array to 5 elements
    int *new_arr = (int *)realloc(arr, 5 * sizeof(int)); // Resize memory

    if (new_arr != NULL) {
        arr = new_arr; // Pointer now points to the new block
        // Old elements (1, 2, 3) are byte-wise copied
        arr[3] = 4; // Add new elements
        arr[4] = 5;

        for (int i = 0; i < 5; i++) {
            printf("%d ", arr[i]);
        }
        printf("\n");

        free(arr); // Free the memory
    } else {
        printf("realloc failed\n");
        free(arr); // Free original memory on realloc failure
    }

    return 0;
}

C++ std::vector example:

#include <vector>
#include <iostream>

struct MyObject {
    int id;
    MyObject(int i) : id(i) { std::cout << "Constructing " << id << std::endl; }
    MyObject(const MyObject& other) : id(other.id) { std::cout << "Copying " << id << std::endl; }
    MyObject(MyObject&& other) noexcept : id(other.id) { std::cout << "Moving " << id << std::endl; }
    ~MyObject() { std::cout << "Destroying " << id << std::endl; }
};

int main() {
    std::vector<MyObject> vec; // Initially empty

    vec.reserve(3); // Reserve space, constructors are not called

    vec.push_back(MyObject(1)); // Temporary object is constructed, then moved/copied into the vector
    vec.push_back(MyObject(2)); // Same as above
    vec.push_back(MyObject(3)); // Same as above

    std::cout << "Capacity: " << vec.capacity() << std::endl;

    // Adding a new element that requires reallocation
    vec.push_back(MyObject(4));

    std::cout << "Capacity after push_back: " << vec.capacity() << std::endl;

    // Here, the following occurs:
    // 1. Allocation of a new buffer (usually 1.5x or 2x the old size).
    // 2. Moving or copying (calling move/copy constructors) of old elements (1, 2, 3) into the new buffer.
    // 3. Construction of the new element (4) in the new buffer.
    // 4. Destructors are called for old elements (1, 2, 3) that were in the old buffer.
    // 5. The old buffer is freed.

    return 0; // Destructors for remaining elements are called
}

It is important to distinguish between the low-level C function realloc, which simply works with raw memory, and the high-level std::vector operations that manage object lifecycles.

What happens to vector elements when performing realloc operation?