memoria moderna in c++

panoramica

la memoria moderna in c++ punta a eliminare leak e dangling pointer usando ownership esplicita e risorse a durata controllata.

unique_ptr e ownership

usa std::unique_ptr per esprimere ownership esclusiva. è leggero e perfetto per risorse non condivise.

#include <memory>

struct asset {
    int id;
    explicit asset(int value) : id(value) {}
};

std::unique_ptr<asset> make_asset() {
    return std::make_unique<asset>(42);
}

int main() {
    auto a = make_asset();
    // a possiede la risorsa
    return 0;
}

non copiare un unique_ptr: spostalo con std::move.

shared_ptr e weak_ptr

std::shared_ptr serve quando l'ownership è condivisa. usa std::weak_ptr per evitare cicli.

#include <memory>
#include <vector>

struct node {
    int value;
    std::vector<std::shared_ptr<node>> children;
    std::weak_ptr<node> parent;
};

move semantics

lo spostamento evita copie costose. implementa costruttore e assegnazione move quando gestisci risorse.

struct buffer {
    std::unique_ptr<int[]> data;
    size_t size;
    buffer(size_t n) : data(new int[n]), size(n) {}
    buffer(buffer&& other) noexcept : data(std::move(other.data)), size(other.size) {
        other.size = 0;
    }
};

errori comuni

• usare new senza delete
• creare cicli con shared_ptr
• spostare un oggetto e continuare a usarlo
• dimenticare noexcept nei move

esercizi

riscrivi una classe che usa new/delete usando unique_ptr.

crea una struttura ad albero con shared_ptr e weak_ptr per il parent.

checklist

• usa unique_ptr come default
• shared_ptr solo dove necessario
• move semantics per risorse pesanti
• scrivi test per casi limite

panoramica

In questo capitolo su memoria moderna in c++, smart pointer, move semantics, ownership e pattern raii. L'obiettivo è trasformare i concetti in micro-pattern riutilizzabili con esempi piccoli e verificabili.

Lavora in sequenza: leggi, prova, modifica gli snippet e annota i trade-off principali (performance, leggibilità, manutenzione).

obiettivi

• capire e applicare panoramica in uno scenario reale
• capire e applicare unique_ptr in uno scenario reale
• capire e applicare shared_ptr in uno scenario reale
• capire e applicare move semantics in uno scenario reale

scheda rapida

#include <iostream>
#include <vector>

int main() {
  std::vector<int> dati{1, 2, 3};
  for (auto &v : dati) {
    v *= 2;
  }
  for (const auto &v : dati) {
    std::cout << v << " ";
  }
  std::cout << "\n";
  return 0;
}

Adatta questo scheletro agli esempi della lezione e sostituisci i dati con il tuo dominio.

tips

• compila con warning elevati
• preferisci RAII
• usa const ovunque possibile
• usa unique_ptr per ownership
• shared_ptr solo se necessario
• evita new/delete

mini progetto

Gestisci oggetti con smart pointer.

• crea factory con make_unique
• passa ownership
• usa shared_ptr per condividere
• verifica lifetime

output atteso: uno script o query ripetibile con risultati verificabili.