Esercizio - Distruttore, copia e spostamento della classe Elements (secondo appello 2021-22, programmazione)

#include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;

class Elements {
public:
    Elements() : buffer(new double[kLength]) {}     // costruttore dato dal testo (il buffer non e' inizializzato)

    // a) distruttore: libera l'unica risorsa "nuda", il buffer; il vector libera da solo i suoi dati
    ~Elements() { delete[] buffer; }

    // b1) costruttore di copia: deep copy
    Elements(const Elements& other)
        : i(other.i),
          buffer(new double[kLength]),               // NUOVO buffer: non si copia il puntatore
          values(other.values)                       // vector: la sua copia e' gia' profonda
    {
        copy(other.buffer, other.buffer + kLength, buffer);
    }

    // b2) costruttore di spostamento: ruba il buffer
    Elements(Elements&& other) noexcept
        : i(other.i),
          buffer(other.buffer),                      // si prende il puntatore...
          values(std::move(other.values))            // ...e i dati del vector
    {
        other.buffer = nullptr;                      // la sorgente non possiede piu' nulla (delete[] nullptr e' innocuo)
        other.i = 0;
    }

    // b3) assegnamento di copia
    Elements& operator=(const Elements& other)
    {
        if (this != &other) {                        // auto-assegnamento: niente da fare
            double* nuovo = new double[kLength];     // 1. alloca
            copy(other.buffer, other.buffer + kLength, nuovo);   // 2. copia
            delete[] buffer;                         // 3. libera il vecchio
            buffer = nuovo;                          // 4. sostituisce
            i = other.i;
            values = other.values;
        }
        return *this;
    }

    // b4) assegnamento di spostamento
    Elements& operator=(Elements&& other) noexcept
    {
        if (this != &other) {
            delete[] buffer;                         // libera il proprio buffer
            buffer = other.buffer;                   // ruba quello della sorgente
            other.buffer = nullptr;
            i = other.i;
            other.i = 0;
            values = std::move(other.values);
        }
        return *this;
    }

    // --- funzioni aggiunte soltanto per provare la classe ---
    void set(int k, double x) { buffer[k] = x; }
    double get(int k) const { return buffer[k]; }
    void add(int v) { values.push_back(v); }
    size_t n_values() const { return values.size(); }
    bool has_buffer() const { return buffer != nullptr; }

private:
    int i = 0;
    double* buffer = nullptr;
    std::vector<int> values;
    static constexpr int kLength = 300;
};

int main()
{
    Elements a;
    a.set(0, 1.5);
    a.add(10); a.add(20);

    Elements b = a;                                  // costruttore di copia
    b.set(0, 9.9);
    cout << "dopo la copia:   a.get(0) = " << a.get(0) << ", b.get(0) = " << b.get(0)
         << ", a.n_values = " << a.n_values() << ", b.n_values = " << b.n_values() << '\n';

    Elements c = std::move(a);                       // costruttore di spostamento
    cout << "dopo lo spostamento: a.has_buffer = " << a.has_buffer() << ", a.n_values = " << a.n_values()
         << ", c.get(0) = " << c.get(0) << ", c.n_values = " << c.n_values() << '\n';

    Elements d;
    d = b;                                           // assegnamento di copia (d esiste gia')
    d.set(0, 7.7);
    cout << "dopo assegnamento di copia: b.get(0) = " << b.get(0) << ", d.get(0) = " << d.get(0) << '\n';

    Elements e;
    e = Elements();                                  // assegnamento di spostamento (la sorgente e' un temporaneo)
    e = std::move(d);                                // assegnamento di spostamento (esplicito)
    cout << "dopo assegnamento di spostamento: d.has_buffer = " << d.has_buffer() << ", e.get(0) = " << e.get(0) << '\n';
    return 0;
}

dopo la copia:   a.get(0) = 1.5, b.get(0) = 9.9, a.n_values = 2, b.n_values = 2
dopo lo spostamento: a.has_buffer = 0, a.n_values = 0, c.get(0) = 1.5, c.n_values = 2
dopo assegnamento di copia: b.get(0) = 9.9, d.get(0) = 7.7
dopo assegnamento di spostamento: d.has_buffer = 0, e.get(0) = 7.7

Elements d;
d = b;                // b è un lvalue (ha un nome e sopravvive): ASSEGNAMENTO DI COPIA
Elements e;
e = Elements();       // il sorgente è un temporaneo (rvalue): ASSEGNAMENTO DI SPOSTAMENTO
e = std::move(d);     // std::move trasforma d in rvalue: ASSEGNAMENTO DI SPOSTAMENTO