La potenza di Troy

La parola chiave auto in C++

In C++, la parola chiave auto è una funzionalità potente introdotta in C++11, usata per dichiarare variabili con un tipo di dato inferito. Il compilatore deduce il tipo della variabile dal suo inizializzatore, il che può rendere il codice più leggibile e più facile da mantenere.

Esempio di utilizzo

Considera il seguente esempio, in cui auto viene usata per dichiarare delle variabili:

auto dragon_population{3};          // dragon_population is deduced as an integer
auto westeros{7.7777};              // westeros is deduced as a double
auto wedding_location{"The Twins"}; // wedding_location is deduced as a const char*, not std::string

In ogni caso, il tipo della variabile viene inferito dal valore con cui è inizializzata.

Inferenza dei tipi

La parola chiave auto aiuta a scrivere codice più conciso e leggibile, riducendo la verbosità dei tipi espliciti.

const std::vector<std::string> pigeon_pie{"flour", "butter", "pigeon", "salt"};
auto purple_wedding_pie{pigeon_pie};
purple_wedding_pie.emplace_back("the strangler");

In questo esempio, auto deduce il tipo di purple_wedding_pie come std::vector<std::string>, evitando di dover specificare di nuovo il tipo in modo esplicito.

Compatibilità

La parola chiave auto è compatibile con vari costrutti del C++, il che la rende uno strumento versatile nella programmazione C++ moderna.

auto& element{array[0]};           // reference to an element
const auto object{otherObject};    // const type version of otherObject's type
auto* ptr{&x};                     // pointer to x with the same type as x, but as a pointer.

Nei concetti successivi vedremo spesso la parola chiave auto con le espressioni lambda, i cicli for basati su intervallo e gli iteratori.

Puntatori intelligenti

I puntatori intelligenti sono una funzionalità moderna del C++ pensata per offrire una gestione automatica della memoria, e aiutano a prevenire le perdite di memoria e i puntatori penzolanti, spesso associati ai puntatori grezzi. Fanno da involucro attorno ai puntatori grezzi, aggiungendo funzionalità extra, come la deallocazione automatica della memoria quando il puntatore non serve più.

Sintassi generale

I puntatori intelligenti sono in genere implementati come template di classe nella libreria standard del C++. I due puntatori intelligenti più usati sono std::unique_ptr e std::shared_ptr.

Puntatori unici

std::unique_ptr è un puntatore intelligente che possiede l'oggetto in modo esclusivo. Garantisce che in qualsiasi momento un solo oggetto std::unique_ptr possieda la risorsa. Quando il std::unique_ptr proprietario viene distrutto o reimpostato, distrugge automaticamente gli oggetti e ne libera la memoria.

#include <memory>
// Declaring and defining a unique pointer
auto rightful_king_of_england = std::make_unique<std::string>("Excalibur");

// Unique pointers cannot be copied or assigned
auto mordred = rightful_king_of_england; // Error: Cannot copy a unique_ptr

Vantaggi di std::make_unique()

Quando si crea uno std::unique_ptr, è preferibile usare std::make_unique() invece di ricorrere direttamente a new per allocare la memoria. std::make_unique() offre diversi vantaggi:

1. Sicurezza rispetto alle eccezioni: std::make_unique() garantisce la sicurezza rispetto alle eccezioni. Se durante la costruzione dell'oggetto viene lanciata un'eccezione, la memoria viene deallocata automaticamente, evitando perdite di memoria.
2. Chiarezza: usare std::make_unique() rende il codice più chiaro e più conciso. Elimina la necessità di specificare esplicitamente il tipo da allocare, perché gli argomenti del template vengono dedotti automaticamente.
3. Opportunità di ottimizzazione: i compilatori possono ottimizzare std::make_unique() in modo più efficace rispetto all'allocazione manuale della memoria con new, con un possibile miglioramento delle prestazioni.
4. Evitare gli usi impropri: eliminare la risorsa sottostante è possibile quando lo std::unique_ptr viene costruito manualmente. Questo porterebbe a un comportamento indefinito, quando lo std::unique_ptr prova a eliminarla alla fine del suo scope.

Puntatori condivisi

std::shared_ptr è un puntatore intelligente che permette a più oggetti std::shared_ptr di condividere la proprietà della stessa risorsa. Tiene traccia di quanti puntatori condivisi fanno riferimento alla risorsa e dealloca la memoria solo quando l'ultimo puntatore condiviso che possiede la risorsa esce dallo scope o viene reimpostato.

// Declaring and defining a shared pointer to a dynamically allocated string
auto martian_congressional_republic = std::make_shared<std::string>("protomolecule");

// Creating more shared pointer that shares ownership
auto outer_planets_alliance = martian_congressional_republic;
auto united_nations = martian_congressional_republic;

Vantaggi di std::make_shared()

Come std::make_unique(), std::make_shared() offre vantaggi come una migliore efficienza della memoria, la sicurezza rispetto alle eccezioni e la leggibilità. Combina in un'unica operazione l'allocazione della memoria per il blocco di controllo e per l'oggetto gestito, aumentando l'efficienza e riducendo il rischio di perdite di memoria. Inoltre, la deduzione automatica degli argomenti del template semplifica il codice e ne migliora la leggibilità. Usare std::make_shared() favorisce un codice più pulito, più sicuro e più efficiente quando si lavora con oggetti std::shared_ptr in C++.

Consigli d'uso

Usa i puntatori intelligenti come impostazione predefinita: std::unique_ptr per la proprietà esclusiva e std::shared_ptr per la proprietà condivisa. Riserva i puntatori grezzi ai riferimenti non proprietari o all'interfacciamento con codice legacy. Nella maggior parte dei casi, std::unique_ptr è sufficiente per la proprietà esclusiva, perché offre una gestione della memoria leggera, senza il sovraccarico del conteggio dei riferimenti. std::shared_ptr va usato con parsimonia, perché introduce sovraccarico e complessità, a meno che non serva una vera proprietà condivisa.