Cosa succede con gli elementi di std::vector durante…

std::vector non utilizza realloc. Quando si modifica la dimensione del contenitore, richiedendo una ridistribuzione della memoria, avviene quanto segue:

Viene allocata una nuova area di memoria di dimensioni sufficienti.
Gli elementi dell’area vecchia vengono spostati in quella nuova.
- Per i tipi che supportano la semantica di movimento (T con un costruttore di movimento e/o operatore di assegnazione di movimento correttamente implementati), viene usato il movimento. Questo è più efficiente, poiché le risorse vecchie (ad esempio, memoria allocata all’interno degli oggetti) vengono trasferite ai nuovi oggetti, e i vecchi oggetti rimangono in uno stato valido ma indefinito o vengono puliti dai distruttori.
- Per i tipi che non supportano la semantica di movimento o se il compilatore non può applicare il movimento, si usa la copia.
- Se gli elementi sono trivialmente copiabili (T è un tipo POD o ha operazioni di copia e movimento triviale), si può usare memcpy o funzioni simili di basso livello per copiare rapidamente i dati grezzi.
Vengono chiamati i distruttori sugli elementi nella vecchia area di memoria.
La vecchia area di memoria viene liberata.

È importante notare che i puntatori e i riferimenti agli elementi nella vecchia area diventano invalidi dopo la ridistribuzione.

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

struct MyItem {
    std::string name;
    // Costruttore
    MyItem(const std::string& n) : name(n) {
        std::cout << "Constructing " << name << std::endl;
    }
    // Costruttore di copia
    MyItem(const MyItem& other) : name(other.name) {
        std::cout << "Copying " << name << std::endl;
    }
    // Operatore di assegnazione per copia
    MyItem& operator=(const MyItem& other) {
        if (this != &other) {
            name = other.name;
            std::cout << "Copy assigning " << name << std::endl;
        }
        return *this;
    }
    // Costruttore di movimento
    MyItem(MyItem&& other) noexcept : name(std::move(other.name)) {
        std::cout << "Moving " << name << std::endl;
    }
    // Operatore di assegnazione per movimento
    MyItem& operator=(MyItem&& other) noexcept {
        if (this != &other) {
            name = std::move(other.name);
            std::cout << "Move assigning " << name << std::endl;
        }
        return *this;
    }
    // Distruttore
    ~MyItem() {
        std::cout << "Destroying " << name << std::endl;
    }
};

int main() {
    std::vector<MyItem> items;
    items.reserve(2); // Riserva spazio per 2 elementi

    items.emplace_back("item1"); // Senza realloc
    items.emplace_back("item2"); // Senza realloc

    std::cout << "Aggiunta del terzo elemento, attiva operazione simile a realloc:" << std::endl;
    items.emplace_back("item3"); // Richiede realloc
    // L’output mostrerà il movimento per item1 e item2, poi la distruzione degli oggetti vecchi
    // e la costruzione del nuovo item3.
    // Se MyItem non supporta il semantico di movimento, verrà mostrato copia.

    return 0;
}

Cosa succede con gli elementi di std::vector durante l'operazione realloc?