La libreria standard C++ 11 fornisce qualsiasi utilità per convertire da std::shared_ptr
a std::unique_ptr
o viceversa? Questa operazione è sicura?C++ 11 unique_ptr e shared_ptr è in grado di convertire il tipo dell'altro?
risposta
std::unique_ptr
è il modo in C++ 11 per esprimere proprietà esclusiva, ma uno dei suoi caratteristiche più interessanti è che semplice ed efficiente converte instd:: shared_ptr
.Questa è una parte fondamentale del motivo per cui lo
std::unique_ptr
è particolarmente adatto come tipo di ritorno di una funzione di fabbrica. Le funzioni di fabbrica non possono sapere se i chiamanti desiderano utilizzare la semantica della proprietà esclusiva per l'oggetto restituito o se la proprietà condivisa (ad esempio,std::shared_ptr
) sia più appropriata. Restituendo unostd::unique_ptr
, le fabbriche forniscono ai chiamanti il puntatore intelligente più efficiente, ma non impediscono ai chiamanti di sostituirlo con il fratello più flessibile.
std::shared_ptr
astd::unique_ptr
non è consentito. Una volta che hai trasformato la gestione a vita di una risorsa in unstd::shared_ptr
, non cambierai idea. Anche se il conteggio dei riferimenti è uno, non è possibile recuperare la proprietà della risorsa per, ad esempio, avere unastd::unique_ptr
gestirla.Riferimento: Efficace C++ moderno. 42 MODI SPECIFICI PER MIGLIORARE L'USO DI C++ 11 E C++ 14. Scott Meyers.
In breve, è possibile convertire facilmente e in modo efficiente una std::unique_ptr
per std::shared_ptr
, ma non è possibile convertire std::shared_ptr
a std::unique_ptr
.
Ad esempio:
std::unique_ptr<std::string> unique = std::make_unique<std::string>("test");
std::shared_ptr<std::string> shared = std::move(unique);
o:
std::shared_ptr<std::string> shared = std::make_unique<std::string>("test");
Dato u_ptr unique_ptr, creare shared_ptr s_ptr:
std::shared_ptr<whatever> s_ptr(u_ptr.release());
In senso contrario è impraticabile.
Ecco il modo "giusto": 'std :: shared_ptr
E qui c'è il pedante modo "giusto": 'std :: shared_ptr
- 1. C++ 11 closure shared_ptr
- 2. C++ allocazione di shared_ptr con C++ 11 (std :: shared_ptr): è ancora male inizializzare il parametro shared_ptr in una variabile temporanea?
- 3. operazioni atomiche per shared_ptr in C++ 11
- 4. Qual è il motivo della differenza nel comportamento di distruzione tra std :: unique_ptr e std :: shared_ptr?
- 5. C++ 11 std :: shared_ptr + boost :: serializzazione
- 6. Restituzione di unique_ptr locale come shared_ptr
- 7. Come risolvere compilatore C++-errore "non è in grado di convertire 'Tipo' a 'tipo const *'"?
- 8. C++ 11 riferimento/puntatore non proprietario a unique_ptr?
- 9. C++ 11 Cancella il tipo di classe?
- 10. Sono in grado di utilizzare C++ 11 in QNX?
- 11. shared_ptr e riferimenti in C++
- 12. Trasferimento della proprietà dell'oggetto da un unique_ptr a un altro unique_ptr in C++ 11?
- 13. C++ 11 Template Method specializzazione per tipo di ritorno
- 14. Questo tipo di ritorno finale è legale in C++ 11?
- 15. deduci il tipo di elementi di tupla in C++ 11
- 16. Mappa di mutex C++ 11
- 17. C++ 11: GCC 4.8 static_local std :: unique_ptr riferimento undefined
- 18. C++ 11: unique_ptr si lamenta del tipo incompleto, ma non quando lo avvolgo
- 19. Semantica C++ 11 "auto"
- 20. Spostare proprietà da std :: shared_ptr a std :: unique_ptr
- 21. Come eseguire il debug del codice C++ 11 con unique_ptr in DDD (o gdb)?
- 22. C++ Regola di Zero: la cancellazione polimorfico e il comportamento unique_ptr
- 23. Spostare un unique_ptr con deleter personalizzato a uno shared_ptr
- 24. intrusive_ptr in C++ 11
- 25. Quando ha senso usare unique_ptr con i container STL? (C++ 11)
- 26. Qual è il modo corretto di convertire uno std :: unique_ptr in uno std :: unique_ptr in una superclasse?
- 27. Parametro/tipo di archiviazione per un lambda C++ 11
- 28. serializzazione shared_ptr e tra applicazioni C# e C++?
- 29. Il riferimento di tipo non è in grado di trovare il tipo pubblico denominato
- 30. C++ 11 definisce il tipo di funzione acquisita tramite riferimento
Definire "operazione sicura" per favore. Che tipo di sicurezza stai cercando? sicurezza di gestione a vita? Filo di sicurezza? – jaggedSpire
"STL" non significa libreria standard. L'STL non ha nulla a che fare con 'shared_ptr'. – curiousguy
@jaggedSpire La sicurezza del thread significherebbe che i proprietari sono utilizzati in thread diversi, ovvero il conteggio degli usi non è 1. – curiousguy