Antwoord.

Shallow copy (oppervlakkige kopie) kopieert alleen de waarden van de klasse-leden, inclusief pointers, maar kopieert de gegevens op deze pointers niet. Deep copy (diepe kopie) maakt nieuwe kopieën van de gegevens die via pointers worden vermeld, wat gezamenlijk geheugengebruik en dubbele vrijgave voorkomt.

Voorbeeld:

class Buffer {
public:
    Buffer(size_t size) : size(size), data(new int[size]) {}
    // Shallow copy (verkeerd)
    Buffer(const Buffer& other) : size(other.size), data(other.data) {}
    // Deep copy (juist)
    Buffer& operator=(const Buffer& other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }
    ~Buffer() { delete[] data; }
private:
    size_t size;
    int* data;
};

Vraag met een valstrik.

Als de klasse een pointer naar een dynamische array bevat, waarom is het niet genoeg om de copy constructor en operator= standaard te kopiëren?

Juist antwoord:

Standaardkopiëren implementeert een oppervlakkige kopie. Twee objecten zullen naar dezelfde array wijzen, en bij vernietiging zal er twee keer geprobeerd worden om hetzelfde geheugen vrij te geven (double free), wat zal leiden tot een crash.

Voorbeelden van echte fouten door onbekendheid met de nuances van het onderwerp.

---

Verhaal In een grote serverapplicatie werd een eigen klasse Image geïmplementeerd, die een dynamische buffer van pixels beheerde. De ontwikkelaars hadden geen diepe kopie geïmplementeerd, en bij het doorgeven van Image-objecten per waarde tussen threads vond dubbele geheugen vrijgave plaats, wat leidde tot regelmatige crashes.

---

Verhaal In een studentenproject werd een container Field gebruikt, die een pointer naar een dynamisch toegewezen array van cellen bevatte. Bij het wijzigen van de grootte van de array kopieerde de kopieconstructor alleen de pointer, en beide containers werkten met hetzelfde geheugen, wat leidde tot inconsistente gegevens en moeilijk te traceren bugs.

---

Verhaal In oude C++-code van een grafische engine was er een klasse Texture geïmplementeerd zonder eigen destructor en toewijzingsoperator, wat leidde tot memory leak — geheugentekorten bij het kopiëren en toewijzen van tijdelijke objecten van texturen.