std :: auto_ptr in std :: unique_ptr

Con il nuovo standard in arrivo (e parti già disponibili in alcuni compilatori), il nuovo tipo std::unique_ptrdovrebbe essere un sostituto per std::auto_ptr.

Il loro utilizzo si sovrappone esattamente (quindi posso fare una ricerca / sostituzione globale sul mio codice (non che lo farei, ma se lo facessi)) o dovrei essere consapevole di alcune differenze che non sono evidenti dalla lettura della documentazione?

Anche se si tratta di un sostituto diretto, perché dargli un nuovo nome piuttosto che migliorarlo std::auto_ptr?

Non è possibile eseguire una ricerca / sostituzione globale perché è possibile copiarne una auto_ptr(con conseguenze note), ma è unique_ptrpossibile solo spostarla. Qualunque cosa assomigli

std::auto_ptr<int> p(new int);
std::auto_ptr<int> p2 = p; 

dovrà diventare almeno così

std::unique_ptr<int> p(new int);
std::unique_ptr<int> p2 = std::move(p);

Per quanto riguarda le altre differenze, unique_ptrpuò gestire correttamente le matrici (chiamerà delete[], mentre auto_ptrtenterà di chiamare delete.

std::auto_ptre std::unique_ptrsono incompatibili in qualche modo e un calo nella sostituzione in altri. Quindi, nessuna ricerca / sostituzione non è abbastanza buona. Tuttavia, dopo aver trovato / sostituito il lavoro attraverso gli errori di compilazione dovrebbe risolvere tutto tranne i casi angolari strani. La maggior parte degli errori di compilazione richiederà l'aggiunta di a std::move.

• Variabile dell'ambito della funzione:
  compatibile al 100%, a condizione che non venga passato per valore a un'altra funzione.
• Tipo di valore restituito:
  non compatibile al 100% ma compatibile al 99% non sembra sbagliato.
• Parametro di funzione in base al valore:
  100% compatibile con un avvertimento, unique_ptri messaggi di posta elettronica devono essere passati attraverso una std::movechiamata. Questo è semplice in quanto il compilatore si lamenterà se non lo capisci bene.
• Parametro funzione per riferimento:
  compatibile al 100%.
• Variabile membro della classe:
  questa è complicata. std::auto_ptrLa semantica delle copie è malvagia. Se la classe non consente la copia, la std::unique_ptrsostituzione viene interrotta. Tuttavia, se hai provato a fornire alla classe una semantica della copia ragionevole, dovrai modificare il std::auto_ptrcodice di gestione. Questo è semplice in quanto il compilatore si lamenterà se non lo capisci bene. Se hai permesso di copiare una classe con un std::auto_ptrmembro senza alcun codice speciale, allora vergogna e buona fortuna.

In sintesi, std::unique_ptrè un ininterrotto std::auto_ptr. Non consente in fase di compilazione comportamenti che spesso erano errori quando si utilizza a std::auto_ptr. Quindi, se hai usato std::auto_ptrcon le cure necessarie, passare a std::unique_ptrdovrebbe essere semplice. Se hai fatto affidamento sul std::auto_ptrcomportamento strano, devi comunque riformattare il codice.

AFAIK, unique_ptrnon è un sostituto diretto. Il principale difetto che corregge è il trasferimento implicito della proprietà.

std::auto_ptr<int> a(new int(10)), b;
b = a; //implicitly transfers ownership

std::unique_ptr<int> a(new int(10)), b;
b = std::move(a); //ownership must be transferred explicitly

D'altra parte, unique_ptravranno funzionalità completamente nuove: possono essere archiviate in contenitori.

Herb Sutter ha una bella spiegazione su GotW # 89 :

Qual è il problema con auto_ptr? auto_ptr è caritativamente caratterizzato come un coraggioso tentativo di creare un unique_ptr prima che C ++ avesse spostato la semantica. auto_ptr è ora obsoleto e non deve essere utilizzato nel nuovo codice.

Se hai auto_ptr in una base di codice esistente, quando ne hai la possibilità prova a fare una ricerca globale e sostituire auto_ptr in unique_ptr; la stragrande maggioranza degli usi funzionerà allo stesso modo e potrebbe esporre (come errore di compilazione) o correggere (silenziosamente) un paio di bug che non sapevi di avere.

In altre parole, mentre una ricerca e sostituzione globale può "rompere" temporaneamente il codice, dovresti comunque farlo: potrebbe richiedere del tempo per correggere gli errori di compilazione, ma ti farà risparmiare molti più problemi a lungo termine.