Esercizio - Gerarchia MyPointer, MyUniquePointer e MySharedPointer (terzo appello 2021-22, programmazione)

#include <cstdlib>
#include <iostream>
#include <map>
#include <new>
#include <utility>
using namespace std;

// ---- per il test: contiamo le allocazioni e le liberazioni di un int, per verificare che non ci siano ----
// ---- leak ne' doppie delete (le altre allocazioni, come i nodi della map, non si contano) ----
static int n_new = 0, n_delete = 0;
void* operator new(size_t s) { if (s == sizeof(int)) ++n_new; return malloc(s); }
void operator delete(void* p) noexcept { free(p); }
void operator delete(void* p, size_t s) noexcept { if (p && s == sizeof(int)) ++n_delete; free(p); }

// ======================= classe base =======================
// Contiene cio' che hanno in comune: il puntatore detenuto, l'accesso e la funzione reset.
class MyPointer {
public:
    virtual ~MyPointer() = default;                  // distruttore virtuale: si distruggono via puntatore alla base
    MyPointer(const MyPointer&) = delete;            // la base non si copia (slicing); le derivate decidono
    MyPointer& operator=(const MyPointer&) = delete;

    virtual void reset(int* p = nullptr) = 0;        // pura: ogni derivata ha la sua politica di liberazione

    int& operator*() const { return *ptr_; }
    int* get() const { return ptr_; }
    explicit operator bool() const { return ptr_ != nullptr; }

protected:
    MyPointer() : ptr_{nullptr} {}                   // protetto: la base e' astratta
    int* ptr_;
};

// ======================= possesso esclusivo =======================
class MyUniquePointer : public MyPointer {
public:
    MyUniquePointer() = default;                                  // costruttore di default: non detiene nulla
    explicit MyUniquePointer(int* p) { ptr_ = p; }                // detiene p
    MyUniquePointer(const MyUniquePointer&) = delete;             // la copia e' INIBITA
    MyUniquePointer& operator=(const MyUniquePointer&) = delete;

    MyUniquePointer(MyUniquePointer&& other) noexcept             // move constructor: trasferisce il possesso
    {
        ptr_ = other.ptr_;
        other.ptr_ = nullptr;
    }
    MyUniquePointer& operator=(MyUniquePointer&& other) noexcept
    {
        if (this != &other) { reset(other.ptr_); other.ptr_ = nullptr; }
        return *this;
    }

    void reset(int* p = nullptr) override                         // detiene p; il vecchio oggetto e' liberato
    {
        if (p == ptr_) return;                                    // reset(get()): niente da fare (e niente delete)
        delete ptr_;
        ptr_ = p;
    }
    ~MyUniquePointer() override { delete ptr_; }
};

// ======================= possesso condiviso =======================
class MySharedPointer : public MyPointer {
public:
    MySharedPointer() = default;
    explicit MySharedPointer(int* p) { acquisisci(p); }
    MySharedPointer(const MySharedPointer& other) { acquisisci(other.ptr_); }   // la copia e' IMPLEMENTATA
    MySharedPointer& operator=(const MySharedPointer& other)
    {
        if (this != &other) reset(other.ptr_);
        return *this;
    }
    MySharedPointer(MySharedPointer&& other) noexcept             // move: il contatore NON cambia
    {
        ptr_ = other.ptr_;
        other.ptr_ = nullptr;
    }
    MySharedPointer& operator=(MySharedPointer&& other) noexcept
    {
        if (this != &other) {
            rilascia();
            ptr_ = other.ptr_;
            other.ptr_ = nullptr;
        }
        return *this;
    }

    void reset(int* p = nullptr) override
    {
        if (p == ptr_) return;
        rilascia();                                               // dice addio al vecchio puntatore
        acquisisci(p);                                            // e detiene il nuovo
    }
    ~MySharedPointer() override { rilascia(); }

    int use_count() const { return ptr_ ? registro_.at(ptr_) : 0; }

private:
    void acquisisci(int* p)
    {
        ptr_ = p;
        if (ptr_) ++registro_[ptr_];                              // un puntatore in piu' su quell'area
    }
    void rilascia()
    {
        if (!ptr_) return;
        auto it = registro_.find(ptr_);
        if (--it->second == 0) {                                  // ero l'ultimo: libero la memoria
            delete ptr_;
            registro_.erase(it);
        }
        ptr_ = nullptr;
    }

    static inline map<int*, int> registro_;                       // registro: indirizzo puntato -> numero di puntatori
};

int main()
{
    cout << "== MyUniquePointer ==\n";
    {
        MyUniquePointer u(new int(5));
        cout << "*u = " << *u << '\n';
        // MyUniquePointer copia = u;                             // errore: la copia e' inibita
        MyUniquePointer v = std::move(u);                         // si puo' solo spostare
        cout << "dopo il move: u " << (u ? "detiene" : "vuoto") << ", *v = " << *v << '\n';
        v.reset(new int(7));                                      // libera il 5 e detiene il 7
        cout << "dopo reset: *v = " << *v << ", delete finora = " << n_delete << '\n';
    }
    cout << "uscito dallo scope: new = " << n_new << ", delete = " << n_delete << '\n';

    cout << "== MySharedPointer ==\n";
    int new0 = n_new, del0 = n_delete;
    {
        MySharedPointer a(new int(10));
        cout << "use_count = " << a.use_count() << '\n';
        {
            MySharedPointer b = a;                                // copia: contatore a 2
            MySharedPointer c;
            c = b;                                                // assegnamento: contatore a 3
            cout << "con b e c: use_count = " << a.use_count() << ", *c = " << *c << '\n';
        }                                                         // b e c escono: contatore torna a 1, nessuna delete
        cout << "dopo l'uscita di b e c: use_count = " << a.use_count() << ", delete = " << n_delete - del0 << '\n';

        MySharedPointer d = a;                                    // di nuovo 2
        a.reset(new int(20));                                     // a lascia il 10 (resta d) e prende il 20
        cout << "dopo a.reset(new int(20)): *a = " << *a << ", *d = " << *d
             << ", use_count(a) = " << a.use_count() << ", use_count(d) = " << d.use_count()
             << ", delete = " << n_delete - del0 << '\n';
        d.reset();                                                // d era l'ultimo del 10: lo libera
        cout << "dopo d.reset(): delete = " << n_delete - del0 << '\n';
    }
    cout << "uscito dallo scope: new = " << n_new - new0 << ", delete = " << n_delete - del0 << '\n';
    return 0;
}

== MyUniquePointer ==
*u = 5
dopo il move: u vuoto, *v = 5
dopo reset: *v = 7, delete finora = 1
uscito dallo scope: new = 2, delete = 2
== MySharedPointer ==
use_count = 1
con b e c: use_count = 3, *c = 10
dopo l'uscita di b e c: use_count = 1, delete = 0
dopo a.reset(new int(20)): *a = 20, *d = 10, use_count(a) = 1, use_count(d) = 1, delete = 0
dopo d.reset(): delete = 1
uscito dallo scope: new = 2, delete = 2