shared_ptr magic :)

Il signor Lidström e io abbiamo litigato :)

L'affermazione del signor Lidström è che un costrutto shared_ptr<Base> p(new Derived);non richiede che Base abbia un distruttore virtuale:

Armen Tsirunyan : "Davvero? Shared_ptr ripulirà correttamente? Potresti per favore in questo caso dimostrare come questo effetto potrebbe essere implementato?"

Daniel Lidström : " shared_ptr utilizza il proprio distruttore per eliminare l'istanza Concrete. Questo è noto come RAII all'interno della comunità C ++. Il mio consiglio è che impari tutto ciò che puoi su RAII. Renderà il tuo codice C ++ molto più semplice quando lo usi RAII in tutte le situazioni ".

Armen Tsirunyan : "Conosco RAII, e so anche che alla fine il distruttore shared_ptr potrebbe cancellare il px memorizzato quando pn raggiunge 0. Ma se px avesse un puntatore di tipo statico Basee un puntatore di tipo dinamico a Derived, allora a meno che non Baseabbia un distruttore virtuale, questo risulterà in un comportamento indefinito. Correggimi se sbaglio. "

Daniel Lidström : " shared_ptr sa che il tipo statico è Concrete. Lo sa da quando l'ho passato al suo costruttore! Sembra un po 'magico, ma posso assicurarti che è di design ed estremamente carino."

Quindi, giudicaci. Come è possibile (se lo è) implementare shared_ptr senza richiedere alle classi polimorfiche di avere un distruttore virtuale? Grazie in anticipo

Sì, è possibile implementare shared_ptr in questo modo. Boost lo fa e anche lo standard C ++ 11 richiede questo comportamento. Come ulteriore flessibilità shared_ptr gestisce più di un semplice contatore di riferimento. Un cosiddetto deleter viene solitamente inserito nello stesso blocco di memoria che contiene anche i contatori di riferimento. Ma la parte divertente è che il tipo di questo deleter non fa parte del tipo shared_ptr. Questa è chiamata "cancellazione del tipo" ed è fondamentalmente la stessa tecnica usata per implementare le "funzioni polimorfiche" boost :: function o std :: function per nascondere il tipo effettivo del funtore. Per far funzionare il tuo esempio, abbiamo bisogno di un costruttore basato su modelli:

template<class T>
class shared_ptr
{
public:
   ...
   template<class Y>
   explicit shared_ptr(Y* p);
   ...
};

Quindi, se lo usi con le tue classi Base e Derivato ...

class Base {};
class Derived : public Base {};

int main() {
   shared_ptr<Base> sp (new Derived);
}

... il costruttore basato su modelli con Y = Derived viene utilizzato per costruire l'oggetto shared_ptr. Il costruttore ha quindi la possibilità di creare l'oggetto deleter appropriato e contatori di riferimento e memorizza un puntatore a questo blocco di controllo come membro di dati. Se il contatore dei riferimenti raggiunge lo zero, per eliminare l'oggetto verrà utilizzato il deleter precedentemente creato e in grado di riconoscere Derivati.

Lo standard C ++ 11 ha quanto segue da dire su questo costruttore (20.7.2.2.1):

Richiede: p deve essere convertibile in T*. Ydeve essere un tipo completo. L'espressione delete pdeve essere ben formata, deve avere un comportamento ben definito e non deve generare eccezioni.

Effetti: costruisce un shared_ptroggetto che possiede il puntatore p.

...

E per il distruttore (20.7.2.2.2):

Effetti: se *thisè vuoto o condivide la proprietà con un'altra shared_ptristanza ( use_count() > 1), non ci sono effetti collaterali. Altrimenti, se *thispossiede un oggetto pe un deleter d, d(p)viene chiamato. Altrimenti, if *thispossiede un puntatore pe delete pviene chiamato.

(l'enfasi sull'uso del carattere in grassetto è mia).

Quando shared_ptr viene creato, memorizza un oggetto deleter al suo interno. Questo oggetto viene chiamato quando shared_ptr sta per liberare la risorsa puntata. Dato che sai come distruggere la risorsa nel punto di costruzione, puoi usare shared_ptr con tipi incompleti. Chiunque abbia creato shared_ptr vi ha memorizzato un cancellatore corretto.

Ad esempio, puoi creare un deleter personalizzato:

void DeleteDerived(Derived* d) { delete d; } // EDIT: no conversion needed.

shared_ptr<Base> p(new Derived, DeleteDerived);

p chiamerà DeleteDerived per distruggere l'oggetto appuntito. L'implementazione lo fa automaticamente.

Semplicemente,

shared_ptr usa una speciale funzione deleter che viene creata dal costruttore che usa sempre il distruttore dell'oggetto dato e non il distruttore di Base, questo è un po 'di lavoro con la meta programmazione dei template, ma funziona.

Qualcosa del genere

template<typename SomeType>
shared_ptr(SomeType *p)
{
   this->destroyer = destroyer_function<SomeType>(p);
   ...
}