Puntatori intelligenti in C++

Fa parte della sezione Programmazione orientata agli oggetti del percorso C++ di Coddy. Lezione 15 di 104.

Gli smart pointer sono classi wrapper che gestiscono automaticamente la memoria heap per te. Eliminano la necessità di chiamate manuali a delete, liberando la memoria quando il puntatore esce dall'ambito.

Includi l'header <memory> per usare i puntatori intelligenti.

unique_ptr - proprietà esclusiva. Solo un puntatore alla volta può possedere la risorsa.

#include <memory>

std::unique_ptr<Player> player = std::make_unique<Player>("Hero");
player->attack();  // Usa come un normale puntatore

// Non si può copiare, ma si può trasferire la proprietà
std::unique_ptr<Player> player2 = std::move(player);
// player ora è nullptr

shared_ptr - proprietà condivisa. Più puntatori possono possedere la stessa risorsa. La memoria viene liberata quando l'ultimo proprietario viene distrutto.

std::shared_ptr<Player> p1 = std::make_shared<Player>("Hero");
std::shared_ptr<Player> p2 = p1;  // Both own the resource

std::cout << p1.use_count();  // Prints 2

weak_ptr - osservatore non proprietario di un shared_ptr. Utile per interrompere i riferimenti circolari.

std::shared_ptr<Player> shared = std::make_shared<Player>("Hero");
std::weak_ptr<Player> weak = shared;

if (auto locked = weak.lock()) {  // Converti in shared_ptr
    locked->attack();
}

Usa unique_ptr per impostazione predefinita per la proprietà esclusiva. Usa shared_ptr quando più oggetti devono condividere una risorsa. Usa weak_ptr per osservare senza prolungare la durata.

Preferisci make_unique e make_shared a new senza wrapper.

Sfida

Facile

Creiamo un sistema di condivisione di documenti che dimostri i diversi modelli di proprietà dei puntatori intelligenti. Vedrai come unique_ptr impone la proprietà esclusiva, come shared_ptr consente più proprietari e come weak_ptr può osservare senza influire sul ciclo di vita.

Creerai due file per organizzare il codice:

Document.h: definisci una classe Document che rappresenta un documento condivisibile. Dovrebbe avere:
- Un attributo privato title (stringa)
- Un costruttore che accetta un titolo e stampa "Document created: <title>"
- Un distruttore che stampa "Document deleted: <title>"
- Un metodo getTitle() che restituisce il titolo
main.cpp: dimostra tutti e tre i tipi di puntatori intelligenti leggendo un titolo di documento dall'input, quindi:
- Crea un unique_ptr a un Document con il titolo inserito
- Stampa "Unique owner: <title>"
- Trasferisci la proprietà a un altro unique_ptr usando std::move
- Stampa "Ownership transferred"
- Crea un shared_ptr a un nuovo Document con il titolo "SharedDoc"
- Crea un secondo shared_ptr che punta allo stesso documento
- Stampa "Shared owners: <count>" usando use_count()
- Crea un weak_ptr da uno dei puntatori condivisi
- Usa lock() per accedere al documento tramite il puntatore debole e stampa "Weak access: <title>"

Ricorda di includere <memory> per i puntatori intelligenti. Usa std::make_unique e std::make_shared per creare i puntatori intelligenti. I messaggi del distruttore ti aiuteranno a vedere quando ciascun documento viene eliminato automaticamente al termine del programma.

Includi il file header in main.cpp usando #include "Document.h".

Provalo tu

#include <iostream>
#include <memory>
#include <string>
#include "Document.h"

using namespace std;

int main() {
    string inputTitle;
    cin >> inputTitle;

    // TODO: Crea un unique_ptr a un Document con inputTitle
    // usando std::make_unique

    // TODO: Imprime "Unique owner: <title>"

    // TODO: Transfiere la propiedad a otro unique_ptr usando std::move

    // TODO: Imprime "Ownership transferred"

    // TODO: Crea un shared_ptr a un nuevo Document con el título "SharedDoc"
    // usando std::make_shared

    // TODO: Crea un segundo shared_ptr que apunte al mismo documento

    // TODO: Imprime "Shared owners: <count>" usando use_count()

    // TODO: Crea un weak_ptr a partir de uno de los punteros compartidos

    // TODO: Usa lock() para acceder al documento mediante weak_ptr
    // e imprime "Weak access: <title>"

    return 0;
}