Esercizio - RAII e garanzie sulle eccezioni (quarto appello 2021-22, teoria)

void suspicious(int s, int x)
{
    int* p = new int[s];
    // ...
    if (x) return;                 // il flusso NON arriva al delete[]
    // ... un'eccezione, per esempio da v.at(x), salta il delete[] allo stesso modo
    delete[] p;
}

#include <cstdlib>
#include <iostream>
#include <memory>
#include <new>
#include <vector>
using namespace std;

static int n_new = 0, n_delete = 0;                  // contano i blocchi allocati e liberati
void* operator new(size_t s)  { ++n_new; return malloc(s); }
void* operator new[](size_t s) { ++n_new; return malloc(s); }
void operator delete(void* p) noexcept { if (p) ++n_delete; free(p); }
void operator delete[](void* p) noexcept { if (p) ++n_delete; free(p); }
void operator delete(void* p, size_t) noexcept { if (p) ++n_delete; free(p); }
void operator delete[](void* p, size_t) noexcept { if (p) ++n_delete; free(p); }

// Gestione MANUALE: il flusso puo' non arrivare al delete[] (return anticipato; lo stesso vale per un'eccezione)
void sospetta(int s, int x)
{
    int* p = new int[s];
    p[0] = 1;
    if (x) return;                                   // uscita anticipata: il delete[] e' saltato
    delete[] p;
}

// Gestione RAII: la memoria e' acquisita nel costruttore dell'oggetto e liberata dal suo distruttore
void sicura_vector(int s, int x)
{
    vector<int> v(s);                                // il buffer appartiene al vector
    v[0] = 1;
    if (x) return;                                   // all'uscita dallo scope il distruttore di v libera il buffer
}

void sicura_unique(int s, int x)
{
    unique_ptr<int[]> p(new int[s]);                 // lo smart pointer e' un oggetto con distruttore
    p[0] = 1;
    if (x) return;
}

int main()
{
    int a = n_new, d = n_delete;
    sospetta(10, 0);
    cout << "sospetta, senza return anticipato: new " << n_new - a << ", delete " << n_delete - d << '\n';
    a = n_new; d = n_delete;
    sospetta(10, 1);
    cout << "sospetta, con return anticipato:   new " << n_new - a << ", delete " << n_delete - d << "  <- LEAK\n";
    a = n_new; d = n_delete;
    sicura_vector(10, 1);
    cout << "vector, con return anticipato:     new " << n_new - a << ", delete " << n_delete - d << '\n';
    a = n_new; d = n_delete;
    sicura_unique(10, 1);
    cout << "unique_ptr, con return anticipato: new " << n_new - a << ", delete " << n_delete - d << '\n';
    return 0;
}

sospetta, senza return anticipato: new 1, delete 1
sospetta, con return anticipato:   new 1, delete 0  <- LEAK
vector, con return anticipato:     new 1, delete 1
unique_ptr, con return anticipato: new 1, delete 1

#include <iostream>
#include <memory>
#include <stdexcept>
#include <vector>
using namespace std;

// Riempie un vector con n valori; con fallisci == true lancia un'eccezione al terzo inserimento
void riempi(vector<int>& v, int n, bool fallisci)
{
    for (int i = 0; i < n; ++i) {
        if (fallisci && i == 2) throw runtime_error("riempimento fallito");
        v.push_back(i);
    }
}

// VERSIONE 1: gestione manuale con try/catch. Dà la BASIC GUARANTEE: o funziona, o lancia e non perde memoria.
vector<int>* make_vec_manuale(int n, bool fallisci)
{
    vector<int>* p = new vector<int>;
    try {
        riempi(*p, n, fallisci);
    }
    catch (...) {
        delete p;                    // libera
        throw;                       // e rilancia la stessa eccezione
    }
    return p;                        // il chiamante dovra' fare delete
}

// VERSIONE 2: RAII con unique_ptr. Nessun try/catch: se riempi() lancia, il distruttore di p libera il vector.
unique_ptr<vector<int>> make_vec(int n, bool fallisci)
{
    unique_ptr<vector<int>> p { new vector<int> };
    riempi(*p, n, fallisci);
    return p;                        // spostato al chiamante: nessuna delete da ricordare
}

int main()
{
    vector<int>* a = make_vec_manuale(4, false);
    cout << "manuale, senza errore: " << a->size() << " elementi\n";
    delete a;                        // responsabilita' del chiamante

    try {
        vector<int>* b = make_vec_manuale(4, true);
        cout << "non arrivo qui: " << b->size() << '\n';
    }
    catch (runtime_error& e) {
        cout << "manuale, con errore: eccezione \"" << e.what() << "\", nessun leak (delete p nel catch)\n";
    }

    unique_ptr<vector<int>> c = make_vec(4, false);
    cout << "unique_ptr, senza errore: " << c->size() << " elementi, nessuna delete da scrivere\n";

    try {
        unique_ptr<vector<int>> d = make_vec(4, true);
        cout << "non arrivo qui: " << d->size() << '\n';
    }
    catch (runtime_error& e) {
        cout << "unique_ptr, con errore: eccezione \"" << e.what() << "\", il vector e' stato liberato da solo\n";
    }
    return 0;
}

manuale, senza errore: 4 elementi
manuale, con errore: eccezione "riempimento fallito", nessun leak (delete p nel catch)
unique_ptr, senza errore: 4 elementi, nessuna delete da scrivere
unique_ptr, con errore: eccezione "riempimento fallito", il vector e' stato liberato da solo