Akıllı bir işaretçi nedir ve ne zaman kullanmalıyım?

Akıllı bir işaretçi bir sarar bir sınıf " ham (ya da '') C işaretçi, nesnenin işaret olmak yaşam yönetmek için çıplak.' Tek akıllı işaretçi türü yok, ama hepsi soyut bir 'ham' pratik bir yol gösterici. deneyin

Akıllı işaretçiler 'ham' işaretçiler. tercih edilmelidir? İşaretçileri kullanmak için ihtiyacı hissediyorum (ilk olmadığını düşününgerçektenyapmak) normalde bu 'ham' göstericiler, esas nesne silmek unutmak ve bellek sızdırıyor. ilgili sorunların çoğu hafifletmek olabilir gibi akıllı bir işaretçi kullanmak isterim

'Ham' C işaretçileri, programcı açıkça artık yararlı olduğunda nesne yok etmek vardır.

// Need to create the object to achieve some goal
MyObject* ptr = new MyObject(); 
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?

Karşılaştırma akıllı bir işaretçi nesne yok edilir gibi bir politikası tanımlar. Hala nesne oluşturmak zorunda, ama artık yok hakkında endişelenmenize gerek.

SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.

// Destruction of the object happens, depending 
// on the policy the smart pointer class uses.

// Destruction would happen even if DoSomething() 
// raises an exception

Kullanımı en basit ilkesi akıllı işaretçi kapsayıcı nesnesi, boost::scoped_ptr std::unique_ptr tarafından uygulanan gibi kapsamı içerir.

void f()
{
    {
       boost::scoped_ptr<MyObject> ptr(new MyObject());
       ptr->DoSomethingUseful();
    } // boost::scopted_ptr goes out of scope -- 
      // the MyObject is automatically destroyed.

    // ptr->Oops(); // Compile error: "ptr" not defined
                    // since it is no longer in scope.
}

scoped_ptr örnekleri kopyalanamaz unutmayın. Bu birden çok kez (yanlış) silinmiş olan işaretçi engeller. Ancak siz diğer işlevler için başvuruları etrafında iletebilirsiniz.

Kapsamlı işaretçiler belirli bir kod bloğu için nesne ömür boyu bağlamak istediğinizde yararlıdır, ya da başka bir nesnenin içinde üye veri olarak gömülü, diğer yaşam nesne. Nesne kodu içeren blok çıkıldı kadar var, ya da içeren nesne kadar kendi kendini yok etti.

Daha karmaşık akıllı işaretçi bir politika başvuru işaretçisi sayma içerir. Bu işaretçi kopyalanacak izin vermiyor. En son ne zaman" nesne yok nesne silinir. "referans Bu ilke boost::shared_ptr std::shared_ptr tarafından yürütülmektedir.

void f()
{
    typedef std::tr1::shared_ptr<MyObject> MyObjectPtr; // Nice short alias.
    MyObjectPtr p1; // Empty
    {
        MyObjectPtr p2(new MyObject());
        // There is now one "reference" to the created object
        p1=p2; // Copy the pointer.
        // There are now two references to the object.
    } // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero. 
  // The object is deleted.

Referans sayılır işaretçiler nesne ömrü çok daha karmaşık olduğunda çok yararlıdır ve başka bir nesneye doğrudan kod belli bir bölümüne ya da bağlı değil.

Referans sayılır işaretçiler bir dezavantajı — sarkan bir başvuru oluşturma olasılığı vardır:

// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!

Başka bir olasılık döngüsel başvurular yaratıyor:

struct Owner {
   boost::shared_ptr<Owner> other;
};

boost::shared_ptr<Owner> p1 (new Owner());
boost::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1

// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!

Bu soruna geçici bir çözüm bulmak için, Boost 11 ve C her iki weak_ptr shared_ptr zayıf (hesapsız) başvuru tanımlamak için tanımlı.

Bu cevap oldukça eski olduğunu ve bu yüzden 'iyi' akıllı işaretçiler Destek sağladığı kütüphane. hangi zamanda ne olduğunu açıklar C beri 11, standart kütüphane yeterli akıllı işaretçiler türleri sağladı, ve böylece std::unique_ptr, std::shared_ptr std::weak_ptr kullanımı lehine.

Ayrıca std::auto_ptr var. Çok da "" kopyalanacak tehlikeli yeteneği olan da beklenmedik bir şekilde mülkiyet transferleri! özel olması dışında kapsamlı bir işaretçi gibi.En yeni standartları kaldırılmış, bunu kullanmamalısın.

std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership. 
                                 // p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.