shared_ptr büyü :)

Bay Lidström ve ben tartıştık :)

Bay Lidström'ün iddiası, bir yapının Base'in shared_ptr<Base> p(new Derived);sanal bir yıkıcıya sahip olmasını gerektirmediğidir:

Armen Tsirunyan : "Gerçekten Will Shared_ptr ? Eğer etkileyen nasıl yansıdığını gösteren bu durumda lütfen Could doğru temizlemek"

Daniel Lidström : " shared_ptr , Concrete örneğini silmek için kendi yıkıcısını kullanır. Bu, C ++ topluluğu içinde RAII olarak bilinir. Benim tavsiyem, RAII hakkında öğrenebileceğiniz her şeyi öğrenmenizdir. Kullandığınızda C ++ kodlamanızı çok daha kolay hale getirecektir. Her durumda RAII. "

Armen Tsirunyan : " RAII'yi biliyorum ve sonunda, paylaşılan_ptr yıkıcısının, pn 0'a ulaştığında depolanan px'i silebileceğini de biliyorum. Ama eğer px statik tip işaretçisi Baseve dinamik tip işaretçisi varsa Derived, o zaman Basesanal bir yıkıcı yoksa , bu tanımlanmamış davranışlara neden olur. Hatalıysam düzeltin. "

Daniel Lidström : " shared_ptr statik tipin Beton olduğunu biliyor. Bunu yapıcısında geçtiğimden beri biliyor! Biraz sihir gibi görünüyor, ancak tasarım gereği ve son derece güzel olduğunu size temin ederim."

Bizi yargıla. Polimorfik sınıfların sanal yıkıcıya sahip olmasını gerektirmeden paylaşılan_tr'yi uygulamak (eğer öyleyse) nasıl mümkün olabilir ? Şimdiden teşekkürler

Evet, bu şekilde shared_ptr uygulamak mümkündür. Boost yapar ve C ++ 11 standardı da bu davranışı gerektirir. Ek bir esneklik olarak shared_ptr bir referans sayacından daha fazlasını yönetir. Sözde silme, genellikle referans sayaçlarını da içeren aynı bellek bloğuna yerleştirilir. Ancak işin eğlenceli yanı, bu silicinin türünün shared_ptr türünün bir parçası olmamasıdır. Bu, "tür silme" olarak adlandırılır ve temelde "polimorfik işlevler" boost :: işlevi veya std :: işlevini gerçek işlevin türünü gizlemek için uygulamak için kullanılan teknikle aynıdır. Örneğinizin işe yaraması için şablonlu bir kurucuya ihtiyacımız var:

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

Yani, bunu Base ve Derived sınıflarınızla kullanırsanız ...

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

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

... Y = Türetilmiş şablonlu yapıcı, shared_ptr nesnesini oluşturmak için kullanılır. Yapıcı böylece uygun silme nesnesini ve referans sayaçlarını yaratma şansına sahiptir ve bu kontrol bloğuna bir gösterici bir veri üyesi olarak depolar. Referans sayacı sıfıra ulaşırsa, nesneyi elden çıkarmak için önceden oluşturulmuş ve Türetilmiş farkında olan silici kullanılacaktır.

C ++ 11 standardı, bu kurucu hakkında şunları söyler (20.7.2.2.1):

Gerektirir: p dönüştürülebilir olmalıdır T*. Ytam bir tip olacaktır. İfade delete piyi biçimlendirilecek, iyi tanımlanmış davranışa sahip olacak ve istisnalar yaratmayacaktır.

Efektler: İşaretçiye sahip olan bir shared_ptrnesne oluşturur .p

…

Ve yıkıcı için (20.7.2.2.2):

Etkileri: Eğer *thisbir boş diğeriyle veya hisse sahiplik shared_ptrörneğine ( use_count() > 1), hiçbir yan etkileri vardır. Aksi takdirde, *thisbir nesnenin sahibi pve bir deleter d, d(p)denir. Aksi takdirde, *thisbir işaretçiye sahipse pve delete pçağrılırsa.

(kalın yazı tipini vurgulamak benimdir).

Shared_ptr oluşturulduğunda, kendi içinde bir silme nesnesi depolar . Bu nesne, shared_ptr işaretli kaynağı serbest bırakmak üzereyken çağrılır. Kaynağın yapım aşamasında nasıl yok edileceğini bildiğiniz için, tamamlanmamış türlerle shared_ptr kullanabilirsiniz. Shared_ptr'yi her kim yarattıysa orada doğru bir siler.

Örneğin, özel bir silici oluşturabilirsiniz:

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

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

p, sivri uçlu nesneyi yok etmek için DeleteDerived'i çağırır. Uygulama bunu otomatik olarak yapar.

Basitçe,

shared_ptr Base'in yıkıcısını değil, her zaman verilen nesnenin yıkıcısını kullanan kurucu tarafından oluşturulan özel silme işlevini kullanır; bu, şablon meta programlamayla biraz çalışma gerektirir, ancak işe yarar.

Bunun gibi bir şey

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