Какво се случва с елементите на std::vector при…

std::vector не използва realloc. Когато променя размера на контейнера, което изисква преразпределение на паметта, се случва следното:

Заделя се нова област от памет с достатъчен размер.
Елементите се преместват от старата област в новата.
- За типове, които поддържат семантиката на преместване (T с правилна реализация на конструктор за преместване и/или оператор за присвояване за преместване), се използва преместване. Това е по-ефективно, тъй като старите ресурси (например памет, заделена вътре в обектите) се прехвърлят към новите обекти, а старите обекти остават в валидно, но неопределено състояние или се почистват от деструкторите.
- За типове, които не поддържат семантиката на преместване или ако компилаторът не може да приложи преместване, се използва копиране.
- Ако елементите са тривиално копируеми (T е POD тип или има тривиални операции за копиране и преместване), може да се използва memcpy или подобни нискоуровневи функции за бързо копиране на сурови данни.
Деструкторите се извикват за елементите в старата област от памет.
Старата област от памет се освобождава.

Важно е да се отбележи, че указателите и референциите към елементите в старата област от памет стават невалидни след преразпределението.

#include <vector>
#include <iostream>
#include <string>

struct MyItem {
    std::string name;
    // Конструктор
    MyItem(const std::string& n) : name(n) {
        std::cout << "Constructing " << name << std::endl;
    }
    // Конструктор за копиране
    MyItem(const MyItem& other) : name(other.name) {
        std::cout << "Copying " << name << std::endl;
    }
    // Оператор за копиране
    MyItem& operator=(const MyItem& other) {
        if (this != &other) {
            name = other.name;
            std::cout << "Copy assigning " << name << std::endl;
        }
        return *this;
    }
    // Конструктор за преместване
    MyItem(MyItem&& other) noexcept : name(std::move(other.name)) {
        std::cout << "Moving " << name << std::endl;
    }
    // Оператор за преместване
    MyItem& operator=(MyItem&& other) noexcept {
        if (this != &other) {
            name = std::move(other.name);
            std::cout << "Move assigning " << name << std::endl;
        }
        return *this;
    }
    // Деструктор
    ~MyItem() {
        std::cout << "Destroying " << name << std::endl;
    }
};

int main() {
    std::vector<MyItem> items;
    items.reserve(2); // Резервиране на памет за 2 елемента

    items.emplace_back("item1"); // Без преразпределение
    items.emplace_back("item2"); // Без преразпределение

    std::cout << "Adding third item, triggering realloc-like operation:" << std::endl;
    items.emplace_back("item3"); // Изисква преразпределение
    // Изходът ще покаже преместване за item1 и item2, след това деструкция на старите обекти
    // и конструиране на новия item3.
    // Ако MyItem не поддържаше преместване, щеше да се изведе за копиране.

    return 0;
}

Какво се случва с елементите на std::vector при операцията realloc?