CKTIS / C++
std::make_shared — creare un oggetto con proprietà condivisa
std::make_shared crea un oggetto e restituisce uno std::shared_ptr che lo gestisce. Se il tipo non è un array, inoltra gli argomenti per inizializzare l’oggetto. Le copie del puntatore condividono lo stesso oggetto e la responsabilità della sua durata di vita.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <memory>
// Non-array overload in C++23:
template<class T, class... Args>
std::shared_ptr<T> make_shared(Args&&... args);
// Usage:
auto p = std::make_shared<T>(args...);std::make_shared<T>(args...), dichiarata in <memory>, crea un oggetto e restituisce uno std::shared_ptr<T>. Se il tipo non è un array, la funzione inizializza direttamente un oggetto di tipo T mediante T(std::forward<Args>(args)...). In C++23 questo non comporta necessariamente la chiamata a un costruttore: sono possibili anche l’inizializzazione di scalari e, dove consentita, l’inizializzazione di aggregati con parentesi tonde. Dopo una chiamata riuscita, use_count() vale 1. Esistono anche overload per gli array: per esempio, std::make_shared<int[]>(3) crea tre elementi con valore 0.
Copiando uno std::shared_ptr si condivide l’oggetto invece di copiarlo. La distruzione di una copia riduce il numero di proprietari; l’oggetto viene distrutto quando l’ultimo proprietario rinuncia alla proprietà. Nell’esempio, second modifica lo stesso Counter a cui punta first. Alla fine del blocco interno, il numero di proprietari scende da 2 a 1.
Lo standard consiglia al massimo un’allocazione, ma non la garantisce. Se l’allocazione o un costruttore genera un’eccezione, non si verifica alcuna perdita di memoria associata all’oggetto in corso di creazione. La funzione non accetta un deleter personalizzato. Se l’inizializzazione invoca un costruttore, questo deve essere accessibile dal contesto della libreria, non soltanto dal punto di chiamata.
Questa voce riguarda C++23. Il documento collegato è una bozza di lavoro in evoluzione e può includere modifiche successive; la sintassi mostrata omette intenzionalmente constexpr. Un flag del compilatore nel repository non attesta l’ambiente di produzione.
Esempi
#include <iostream>
#include <memory>
struct Counter {
int value;
explicit Counter(int initial) : value(initial) {}
};
int main() {
auto first = std::make_shared<Counter>(7);
{
auto second = first;
++second->value;
std::cout << first->value << ' ' << first.use_count() << '\n';
}
std::cout << first->value << ' ' << first.use_count() << '\n';
}
Risultato
8 2 8 1
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.