Smart pointers zoals `std::unique_ptr`, `std::shared_ptr` en `std::weak_ptr` zijn krachtige hulpmiddelen voor automatisch geheugenbeheer in C++. Ze helpen geheugenlekken te voorkomen en maken het beheer van de levensduur van objecten eenvoudiger en veiliger. **1. std::unique_ptr** - **Gebruik:** Voor eigenaren van een enkel object. Het zorgt dat het object automatisch wordt vrijgegeven wanneer de `unique_ptr` uit scope gaat. - **Typische situatie:** Wanneer je zeker weet dat slechts één eigenaar is van een resource. **Voorbeeld:** ```cpp #include <memory> std::unique_ptr<int> p = std::make_unique<int>(10); // p bezit nu het integer-object p = std::make_unique<int>(20); // Het oude object wordt automatisch vrijgegeven ``` In jouw situatie: ```cpp std::unique_ptr<int> p = std::make_unique<int>(10); p = std::make_unique<int>(10); // Het eerste object wordt automatisch vrijgegeven voordat het nieuwe wordt toegewezen ``` Dit is correct en veilig, omdat `unique_ptr` automatisch het oude object vrijmaakt bij toewijzing. --- **2. std::shared_ptr** - **Gebruik:** Wanneer meerdere objecten of delen van code hetzelfde resource mogen bezitten. Het telt de referenties en vrijgeeft het object wanneer de laatste `shared_ptr` wordt vernietigd. - **Typische situatie:** Bij gedeeld gebruik van een resource, bijvoorbeeld bij grafen, referentie-gebaseerde datastructuren, of callback-systemen. **Voorbeeld:** ```cpp #include <memory> std::shared_ptr<int> sp1 = std::make_shared<int>(10); std::shared_ptr<int> sp2 = sp1; // Beide delen eigenaar // Het object wordt pas vrijgegeven wanneer beide destructors worden aangeroepen ``` --- **3. std::weak_ptr** - **Gebruik:** Om een niet-eigenlijk referentie te houden die niet telt voor het referentietelling van een `shared_ptr`. Handig om circulaire referenties te voorkomen. - **Typische situatie:** Bij het implementeren van observer-patterns of cache-mechanismen. **Voorbeeld:** ```cpp #include <memory> std::shared_ptr<int> sp = std::make_shared<int>(10); std::weak_ptr<int> wp = sp; // Geen invloed op de referentietelling if (auto spt = wp.lock()) { // Kan veilig toegang krijgen tot object } ``` --- **Samenvatting en adviezen voor jouw code:** - Gebruik `std::make_unique` om `unique_ptr` veilig te initialiseren. - Bij toewijzing van een `unique_ptr` wordt het oude object automatisch vrijgegeven, zoals in jouw voorbeeld. - Overweeg `shared_ptr` als je resource gedeeld moet worden, bijvoorbeeld in complexe datastructuren. - Gebruik `weak_ptr` om circulaire verwijzingen te voorkomen die anders geheugenlekken veroorzaken. Door deze smart pointers correct te gebruiken, voorkom je geheugenlekken en dangling pointers, en wordt je code veiliger en onderhoudsvriendelijker.

Zeker, ik leg uit hoe je smart pointers effectief kunt gebruiken in C++. ## Smart Pointers Overzicht **std::unique_ptr**: Exclusief eigendom - slechts één eigenaar van het object **std::shared_ptr**: Gedeeld eigendom - meerdere eigenaren via reference counting **std::weak_ptr**: Niet-eigenaar referentie - voorkomt circulaire referenties ## Je Code Analyse ```cpp std::unique_ptr<int> p = std::make_unique<int>(10); p = std::make_unique<int>(10); // Eerste object wordt automatisch gedeleteerd! ``` Dit is correct - de eerste `unique_ptr` geeft automatisch het geheugen vrij voordat het de nieuwe pointer overneemt. ## Praktische Voorbeelden ### 1. std::unique_ptr - Exclusief eigendom ```cpp // Factory functie die ownership overdraagt std::unique_ptr<MijnKlasse> maakObject() { return std::make_unique<MijnKlasse>(); } void gebruikObject() { auto obj = maakObject(); // Ownership wordt overgedragen obj->doeIets(); // Geheugen wordt automatisch vrijgegeven bij verlaten scope } ``` ### 2. std::shared_ptr - Gedeeld eigendom ```cpp class DatabaseManager { private: std::shared_ptr<DatabaseConnection> dbConn; public: DatabaseManager(std::shared_ptr<DatabaseConnection> conn) : dbConn(conn) {} void queryData() { if(auto conn = dbConn.lock()) { // Veilige toegang conn->executeQuery("SELECT ..."); } } }; // Gebruik: auto db = std::make_shared<DatabaseConnection>(); DatabaseManager manager1(db); DatabaseManager manager2(db); // Beide delen dezelfde connection ``` ### 3. std::weak_ptr - Voorkom circulaire referenties ```cpp class Ouder; class Kind { private: std::weak_ptr<Ouder> ouder; // Geen ownership, voorkomt memory leak public: void setOuder(std::shared_ptr<Ouder> parent) { ouder = parent; } void gebruikOuder() { if(auto parent = ouder.lock()) { // Controleer of object nog bestaat parent->doeIets(); } } }; ``` ## Typische Probleemoplossingen ### 1. Geheugenleks voorkomen ```cpp // VOOR: Handmatig geheugenbeheer (foutgevoelig) void foutgevoeligeCode() { int* data = new int[1000]; if(conditie) return; // Memory leak! delete[] data; // Vergeten = leak } // NA: Automatisch beheer void veiligeCode() { auto data = std::make_unique<int[]>(1000); if(conditie) return; // Geen leak - unique_ptr geeft vrij } ``` ### 2. Exception safety ```cpp void onveiligeFunctie() { Resource* res1 = new Resource(); Resource* res2 = new Resource(); // Als dit exceptie gooit: res1 leak delete res1; delete res2; } void veiligeFunctie() { auto res1 = std::make_unique<Resource>(); auto res2 = std::make_unique<Resource>(); // Geen leaks bij exceptions } ``` ### 3. Ownership semantiek duidelijk maken ```cpp // Duidelijk wie eigenaar is std::unique_ptr<Data> verwerkData(); // Neemt ownership over void gebruikData(const std::shared_ptr<Data>& data); // Deelt ownership void bekijkData(const Data* data); // Alleen lezen, geen ownership ``` ## Best Practices 1. Gebruik `std::make_unique` en `std::make_shared` i.p.v. `new` 2. Geef `unique_ptr` door als waarde voor ownership transfer 3. Gebruik `const std::shared_ptr&` voor gedeelde toegang zonder ownership change 4. Gebruik `weak_ptr` wanneer circulaire referenties mogelijk zijn Smart pointers maken je code veiliger, leesbaarder en onderhoudbaarder!