Quindi, mi piacerebbe utilizzare puntatori intelligenti anziché grezzi e quasi ogni argomento su SO dice sulla libreria Boost. Ma std ha cose come std::auto_ptr e std::shared_ptr. Perché aumentare? Qual è la differenza?Qual è la differenza tra puntatori intelligenti e puntatori intelligenti std?
Fondamentalmente Boost ha fatto il shared_ptr prima. Si può notare che molte delle nuove classi di contenitori in C++ 11 erano in Boost molto tempo fa. Mi aspetto che questo modello continui anche con le prossime revisioni dello standard C++. Boost supporta vecchi compilatori C++ che non parlano C++ 11, il che è un grande vantaggio.
Per inciso, std::auto_ptr è deprecato in C++ 11, che porta in std::shared_ptr e std::unique_ptr, che sono entrambi significativamente più utili.
In particolare: Boost è un parco giochi della biblioteca che consente agli autori di esplorare lo spazio di progettazione e convalidare le loro librerie con utenti reali.Il comitato C++ (che include molti di questi autori) entra quindi e standardizza ciò che ha funzionato. –
Bene, std::shared_ptr e boost:shared_ptr sono entrambi puntatori di conteggio di riferimento. Invece std :: auto_ptr funziona in modo molto diverso. La differenza tra std::shared_ptr e boost:shared_ptr è molto piccola e per lo più storicamente. Prima del C++ 11 non esisteva lo std::shared_ptr e solo lo boost:shared_ptr. Quando è stato progettato C++ 11, hanno preso come modello boost:shared_ptr.
Tutti i puntatori intelligenti citati hanno in comune il fatto di avere il proprio meccanismo per assicurarsi che la gestione della durata dei punti sia eseguita correttamente. auto_ptr funziona in modo che se si dispone di più istanze di uno auto_ptr, solo uno di essi contiene un puntatore all'oggetto reale. Ogni volta che si crea un auto_ptr da un altro auto_ptr, il nuovo punta all'oggetto e quello vecchio a NULL. D'altra parte con shared_ptr ci possono essere più istanze shared_ptr che condividono lo stesso oggetto, solo quando l'ultimo esce dall'ambito, solo allora l'oggetto viene cancellato ..
In C++ 11 c'è un puntatore simile digitare std::auto_ptr, ovvero std::unique_ptr, ma ci sono alcune differenze importanti, vedere anche std::auto_ptr to std::unique_ptr.
Riferimenti:
Vedi anche:
std :: auto_ptr è deprecato btw –
I nuovi puntatori intelligenti, come 'std :: shared_ptr' ecc (con l'eccezione di' std :: auto_ptr ') in C++ 11 sono stati modellati dopo le strutture con lo stesso nome in Boost. –
Controlla le date di quegli articoli SO che hai menzionato. Alcuni puntatori intelligenti 'boost', come' boost :: shared_ptr', sono stati introdotti nello standard solo l'anno scorso (e quindi sono diventati 'std :: shared_ptr'). – Gorpik