Что происходит с элементами std::vector при выполнении операции realloc?

std::vector не использует realloc. При изменении размера контейнера, требующего перераспределения памяти, происходит следующее:

1. Выделяется новая область памяти достаточного размера.
2. Элементы из старой области памяти перемещаются в новую.
   • Для типов, поддерживающих перемещающую семантику (T с корректной реализацией конструктора перемещения и/или оператора присваивания перемещением), используется перемещение. Это более эффективно, так как старые ресурсы (например, память, выделенная внутри объектов) передаются новым объектам, а старые объекты остаются в валидном, но неопределенном состоянии или очищаются деструкторами.
   • Для типов, не поддерживающих перемещающую семантику или если компилятор не может применить перемещение, используется копирование.
   • Если элементы являются тривиально копируемыми (T является POD-типом или имеет тривиальные операции копирования и перемещения), может использоваться memcpy или аналогичные низкоуровневые функции для быстрого копирования необработанных данных.
3. Деструкторы вызываются для элементов в старой области памяти.
4. Старая область памяти освобождается.

Важно отметить, что указатели и ссылки на элементы в старой области памяти становятся недействительными после перераспределения.

#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;
}

Таким образом, происходит перемещение или копирование элементов в новую область памяти, а затем их деструкция в старой.