GÜNCELLEME
Bu cevap oldukça eskidir ve o zaman Boost kütüphanesi tarafından sağlanan akıllı işaretçiler olan 'iyi' olanı açıklar. C ++ 11 yılından bu yana, standart kütüphane yeterli akıllı işaretçileri türlerini sağlamıştır ve böylece kullanma alışkanlığı olmalıdır std::unique_ptr, std::shared_ptrve std::weak_ptr.
Ayrıca vardı std::auto_ptr. Kapsamlı bir işaretçi gibiydi, ancak kopyalanması için "özel" tehlikeli yeteneğe de sahipti - bu da beklenmedik bir şekilde sahipliği devretti.
C ++ 11'de kullanımdan kaldırıldı ve C ++ 17'de kaldırıldı , bu yüzden kullanmamalısınız.
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.
ESKİ CEVAP
Akıllı işaretçi, işaretlenen nesnenin ömrünü yönetmek için 'ham' (veya 'çıplak') C ++ işaretçisini saran bir sınıftır. Tek bir akıllı işaretçi türü yoktur, ancak hepsi pratik bir şekilde ham bir işaretçi soyutlamaya çalışır.
Akıllı işaretçiler ham işaretçiler yerine tercih edilmelidir. İşaretçiler kullanmanız gerektiğini düşünüyorsanız (önce gerçekten yaparsanız düşünün ), normalde akıllı bir işaretçi kullanmak istersiniz, çünkü bu ham işaretçilerle ilgili sorunların çoğunu hafifletebilir, özellikle nesneyi silmeyi ve bellek sızıntısını unutur.
Ham işaretçilerle, programcı artık yararlı olmadığında nesneyi açıkça yok etmek zorundadı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 ile akıllı bir işaretçi, nesnenin ne zaman imha edildiğine ilişkin bir politika tanımlar. Hâlâ nesneyi yaratmanız gerekiyor, ancak artık nesneyi yok etme konusunda endişelenmenize gerek yok.
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ımdaki en basit politika, boost::scoped_ptrveya tarafından uygulanan gibi akıllı işaretçi sarma nesnesinin kapsamını içerir std::unique_ptr.
void f()
{
{
std::unique_ptr<MyObject> ptr(new MyObject());
ptr->DoSomethingUseful();
} // ptr goes out of scope --
// the MyObject is automatically destroyed.
// ptr->Oops(); // Compile error: "ptr" not defined
// since it is no longer in scope.
}
O Not std::unique_ptrörnekleri kopyalanamaz. Bu, işaretçinin birden çok kez silinmesini (yanlış) önler. Bununla birlikte, aradığınız referansları aradığınız diğer işlevlere iletebilirsiniz.
std::unique_ptrnesnenin ömrünü belirli bir kod bloğuna bağlamak istediğinizde veya başka bir nesneye üye verileri olarak gömdüğünüzde, diğer nesnenin ömründe yararlıdır. Nesne, içeren kod bloğundan çıkılıncaya veya içeren nesne yok oluncaya kadar var olur.
Daha karmaşık bir akıllı işaretçi ilkesi, işaretçiyi saymak için başvuru içerir. Bu, işaretçinin kopyalanmasına izin verir. Nesneye son "başvuru" yok edildiğinde, nesne silinir. Bu politika boost::shared_ptrve tarafından uygulanır std::shared_ptr.
void f()
{
typedef std::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ılan işaretçiler, nesnenizin ömrü çok daha karmaşık olduğunda ve kodun belirli bir bölümüne veya başka bir nesneye doğrudan bağlı olmadığında çok kullanışlıdır.
Sayılan işaretçilerin referansı için bir dezavantaj vardır - sarkan bir referans oluşturma olasılığı:
// 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 dairesel referanslar oluşturmaktır:
struct Owner {
std::shared_ptr<Owner> other;
};
std::shared_ptr<Owner> p1 (new Owner());
std::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 <a0> </a0>, Boost ve C ++ 11 weak_ptrzayıf bir (sayılmamış) bir başvuru tanımlamak için bir tanımladı shared_ptr.