Puntatori Intelligenti:O chi è il proprietario del tuo bambino?[chiuso]

StackOverflow https://stackoverflow.com/questions/94227

Domanda

C++ è tutto di proprietà della memoria
Aka "La Proprietà Semantica"

È responsabilità del proprietario di un pezzo di memoria allocata in modo dinamico per liberare la memoria.Quindi la domanda diventa veramente chi possiede la memoria.

In C++ la proprietà è documentata da tipo un puntatore RAW è avvolto all'interno, quindi, in una buona (IMO) programma C++ è molto raro [RARO non MAI] per vedere RAW puntatori passati in giro (come MATERIE prime per i puntatori non hanno dedotto la proprietà quindi non possiamo dire che possiede la memoria e, quindi, senza un'attenta lettura della documentazione che non può dire chi è responsabile per la proprietà).

Al contrario è raro vedere RAW puntatori memorizzati in una classe ogni RAW puntatore viene memorizzato all'interno della propria SMART pointer wrapper.(N. B.: Se non hai un oggetto che non dovrebbe essere la memorizzazione, perché non si può sapere quando andrà fuori del campo di applicazione e possono essere distrutti.)

Quindi la domanda:

  • Che tipo di Proprietà Semantiche sono persone venire attraverso?
  • Quali classi che vengono utilizzate per implementare quelle semantica?
  • Quali situazioni le trovate utili?

Permette di tenere 1 tipo di semantica proprietà a risposta in modo che possa essere votato su e giù singolarmente

Sommario:

Concettualmente puntatori intelligenti sono semplice e ingenua implementazioni sono facili.Ho visto numerosi tentativi di implementazioni, ma invariabilmente sono rotto in qualche modo che non è ovvio per l'uso occasionale ed esempi.Quindi vi consiglio di usare sempre ben testato "Puntatori Intelligenti" da una libreria piuttosto che rotolare il vostro proprio.std::auto_ptr o uno dei boost puntatori intelligenti sembrano coprire tutte le mie esigenze.

std::auto_ptr<T>:

Singola persona possiede l'oggetto.
Ma il trasferimento di proprietà è consentita.

Utilizzo:
======
Questo consente di definire le interfacce che mostra l'esplicito trasferimento di proprietà.

boost::scoped_ptr<T>

Singola persona possiede l'oggetto.
Il trasferimento di proprietà NON è consentito.

Utilizzo:
======
Utilizzato per mostrare esplicito proprietà.
Oggetto verrà distrutto da un distruttore o quando esplicitamente reset.

boost::shared_ptr<T> (std::tr1::shared_ptr<T>)

Proprietà Multiple.
Questo è un semplice riferimento contato puntatore.Quando il conteggio di riferimento raggiunge lo zero, l'oggetto viene distrutto.

Utilizzo:
======
Quando un oggetto può avere più di ori, con una durata che non può essere determinato al momento della compilazione.

boost::weak_ptr<T>

Utilizzato con shared_ptr<T>.
In situazioni In cui un ciclo di puntatori può accadere.

Utilizzo:
======
Utilizzato per interrompere cicli per il fissaggio di oggetti solo quando il ciclo di gestione di un conteggio dei riferimenti.

È stato utile?

Soluzione

Per me, questi 3 tipi di coprire la maggior parte delle mie esigenze:

shared_ptr - riferimento contati, la deallocazione quando il contatore raggiunge lo zero

weak_ptr - come sopra, ma è un 'slave' per un shared_ptr, non può deallocare

auto_ptr - quando la creazione e la deallocazione accade all'interno della stessa funzione, o quando l'oggetto deve essere considerato uno-proprietario-sempre e solo.Quando si assegna un puntatore ad un altro, il secondo 'ruba' l'oggetto dal primo.

Io ho la mia attuazione per questi, ma sono disponibili anche in Boost.

Ho ancora passare gli oggetti da riferimento (const quando possibile), in questo caso, il metodo deve assumere l'oggetto è vivo solo durante il tempo di chiamata.

C'è un altro tipo di puntatore che uso io che l'ho chiamata hub_ptr.Quando si dispone di un oggetto che deve essere accessibile da oggetti nidificati in (di solito come classe base virtuale).Questo potrebbe essere risolto con il passaggio di un weak_ptr a loro, ma non hanno un shared_ptr a se stessa.Come si sa questi oggetti non vivono più a lungo di lui, passa una hub_ptr a loro (è solo un wrapper di modello per un normale puntatore).

Altri suggerimenti

Semplice C++ Modello

Nella maggior parte dei moduli che ho visto, per impostazione predefinita, è stato ipotizzato che la ricezione di puntatori è stato non la ricezione di proprietà.Infatti, le funzioni/metodi di abbandonare la proprietà di un puntatore erano entrambi molto rari e esplicitamente espresso che fatto nella loro documentazione.

Questo modello presuppone che l'utente è proprietario solo di quello che lui/lei esplicitamente alloca.Tutto il resto è automaticamente eliminati (in ambito di uscita, o attraverso RAII).Si tratta di un C-come modello, estesa dal fatto che la maggior parte dei puntatori sono di proprietà di oggetti che potranno rilasciare automaticamente o quando necessario (a detto di distruzione di oggetti, per lo più), e che la durata di vita degli oggetti sono prevedibili (RAII è il tuo amico, di nuovo).

In questo modello, raw puntatori sono liberamente circolanti e soprattutto non pericoloso (ma se lo sviluppatore è abbastanza intelligente, sarà lui/lei a usare i riferimenti, invece, quando possibile).

  • raw puntatori
  • std::auto_ptr
  • boost::scoped_ptr

Smart Punta C++ Modello

In un codice pieno di puntatori intelligenti, l'utente può sperare di ignorare il ciclo di vita degli oggetti.Il proprietario non è mai il codice utente:È il puntatore intelligente stesso (RAII, di nuovo). Il problema è che i riferimenti circolari, mescolato con riferimento contato i puntatori intelligenti può essere mortale, così hai a che fare sia con sia condivisa puntatori e debole puntatori.Così si sono ancora di proprietà di considerare i deboli puntatore può puntare a nulla, anche se il suo vantaggio sulle materie puntatore è che si può dire così).

  • boost::shared_ptr
  • boost::weak_ptr

Conclusione

Non importa i modelli che descrivono, salvo eccezioni, la ricezione di un puntatore non la ricezione di sua proprietà e ancora oggi è molto importante sapere chi è il proprietario che.Anche per il codice C++ usando pesantemente riferimenti e/o puntatori intelligenti.

Non hanno proprietà condivisa.Se lo fai, assicurati solo con codice non hai il controllo.

Che risolve il 100% dei problemi, dal momento che ti costringe a capire come tutto interagisce.

  • Proprietà Condivisa
  • boost::shared_ptr

Quando una risorsa è condivisa tra più oggetti.La spinta shared_ptr utilizza il conteggio dei riferimenti per assicurarsi che la risorsa è de-allocata quando tutti finsihed.

std::tr1::shared_ptr<Blah> è, molto spesso, la vostra scommessa migliore.

Da boost, c'è anche la puntatore contenitore biblioteca.Questi sono un po ' più efficiente e più facile da usare di un normale contenitore di puntatori intelligenti, se sarete solo utilizzando gli oggetti nel contesto del loro contenitore.

Su Windows, ci sono il COM puntatori (IUnknown, IDispatch e amici), e vari puntatori intelligenti per la loro gestione (ad es.l'ATL CComPtr e puntatori smart auto-generati dalla "importare" istruzione in Visual Studio, in base all' _com_ptr di classe).

  • Unico Proprietario
  • boost::scoped_ptr

Quando è necessario allocare dinamicamente la memoria, ma vuole essere sicuro che viene deallocato su ogni punto di uscita del blocco.

Trovo che questo sia utile, in quanto può essere facilmente riposizionata, e rilasciato senza mai doversi preoccupare di una perdita di

Non penso di essere mai stato in grado di avere la proprietà condivisa nel mio design.Infatti, dall'alto della mia testa l'valido solo caso che posso pensare è pattern Flyweight.

yasper::ptr è un leggero boost::shared_ptr come alternativa.Funziona bene nel mio (per ora) piccolo progetto.

Nella pagina web http://yasper.sourceforge.net/ e ' descritto come segue:

Perché scrivere un altro C++ puntatore intelligente?Esistono già diversi qualità puntatore intelligente implementazioni per il C++, più prominente il Boost puntatore del pantheon e di Loki SmartPtr.Per un buon confronto di smart pointer implementazioni e se il loro uso è appropriato, si prega di leggere Herb Sutter s Il Nuovo C++:Smart(er) Puntatori.In contrasto con l'ampia funzionalità di altre biblioteche, Yasper è un strettamente focalizzato il conteggio dei riferimenti puntatore.Corrisponde a stretto contatto con Aumentare la shared_ptr e di Loki RefCounted/Mouseallowconversion politiche.Yasper consente ai programmatori C++ per dimenticare circa la gestione della memoria senza introducendo la Spinta di grandi dimensioni dipendenze o di dover imparare Loki complicato modelli di policy.Filosofia

* small (contained in single header)
* simple (nothing fancy in the code, easy to understand)
* maximum compatibility (drop in replacement for dumb pointers)

L'ultimo punto può essere pericoloso, dal momento che yasper permette rischioso (ma utile) azioni (come l'assegnazione a raw puntatori e sblocco manuale) consentiti da altre implementazioni.Attenzione, usare solo quelle caratteristiche, se si sa cosa si sta facendo!

C'è un'altra frequentemente utilizzato singolo trasferibile-proprietario, ed è preferibile auto_ptr perché evita i problemi causati da auto_ptr's insane corruzione di assegnazione semantica.

Io parlo di altro che swap.Qualsiasi tipo con un adeguato swap la funzione può essere concepito come un smart riferimento per alcuni contenuti, di cui è proprietaria, fino al momento del trasferimento di proprietà di un'altra istanza dello stesso tipo, scambiando loro.Ogni istanza mantiene la sua identità, ma non ottiene legata ai nuovi contenuti.È come un sicuro rebindable di riferimento.

(È una smart di riferimento piuttosto che un puntatore intelligente, perché non hai modo esplicito riferimento ad esso per ottenere il contenuto.)

Questo significa che auto_ptr diventa meno necessario, è solo bisogno di riempire i "vuoti" in cui i tipi non hanno una buona swap funzione.Ma tutti std contenitori fare.

  • Un Proprietario:Aka eliminare su Copia
  • std::auto_ptr

Quando il creatore dell'oggetto che vuole esplicitamente mano la proprietà a qualcun altro.Questo è anche un modo per documentare il codice mi sto dando a voi e io non sono più tracce in modo da assicurarsi si elimina quando si è finito.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top