AKTUALISIEREN
Diese Antwort ist ziemlich alt und beschreibt daher, was zu dieser Zeit „gut“ war, nämlich intelligente Hinweise, die von der Boost-Bibliothek bereitgestellt wurden. Seit C ++ 11 bietet die Standardbibliothek ausreichend Smart-Pointer-Typen. Daher sollten Sie die Verwendung von std::unique_ptr, std::shared_ptrund bevorzugen std::weak_ptr.
Es gab auch std::auto_ptr. Es war einem Zeiger mit Gültigkeitsbereich sehr ähnlich, außer dass es auch die "besondere" gefährliche Fähigkeit hatte, kopiert zu werden - was auch unerwartet das Eigentum überträgt.
Es war in C ++ 11 veraltet und wurde in C ++ 17 entfernt , daher sollten Sie es nicht verwenden.
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.
ALTE ANTWORT
Ein intelligenter Zeiger ist eine Klasse, die einen "rohen" (oder "nackten") C ++ - Zeiger umschließt, um die Lebensdauer des Objekts zu verwalten, auf das verwiesen wird. Es gibt keinen einzigen intelligenten Zeigertyp, aber alle versuchen, einen Rohzeiger auf praktische Weise zu abstrahieren.
Intelligente Zeiger sollten gegenüber rohen Zeigern bevorzugt werden. Wenn Sie der Meinung sind, dass Sie Zeiger verwenden müssen (überlegen Sie zuerst, ob Sie dies wirklich tun), möchten Sie normalerweise einen intelligenten Zeiger verwenden, da dies viele Probleme mit Rohzeigern lindern kann, hauptsächlich das Vergessen, das Objekt zu löschen und Speicher zu verlieren.
Bei rohen Zeigern muss der Programmierer das Objekt explizit zerstören, wenn es nicht mehr nützlich ist.
// 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...?
Ein intelligenter Zeiger definiert im Vergleich eine Richtlinie darüber, wann das Objekt zerstört wird. Sie müssen das Objekt noch erstellen, müssen sich aber nicht mehr darum kümmern, es zu zerstören.
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
Die einfachste verwendete Richtlinie betrifft den Bereich des Smart-Pointer-Wrapper-Objekts, z. B. implementiert von boost::scoped_ptroder 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.
}
Beachten Sie, dass std::unique_ptrInstanzen nicht kopiert werden können. Dies verhindert, dass der Zeiger mehrmals (falsch) gelöscht wird. Sie können jedoch Verweise darauf an andere von Ihnen aufgerufene Funktionen weitergeben.
std::unique_ptrs sind nützlich, wenn Sie die Lebensdauer des Objekts an einen bestimmten Codeblock binden möchten oder wenn Sie es als Elementdaten in ein anderes Objekt eingebettet haben, die Lebensdauer dieses anderen Objekts. Das Objekt existiert, bis der enthaltende Codeblock verlassen wird oder bis das enthaltende Objekt selbst zerstört wird.
Eine komplexere Smart-Pointer-Richtlinie umfasst das Referenzzählen des Zeigers. Dadurch kann der Zeiger kopiert werden. Wenn der letzte "Verweis" auf das Objekt zerstört wird, wird das Objekt gelöscht. Diese Richtlinie wird von boost::shared_ptrund implementiert 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.
Referenzzählzeiger sind sehr nützlich, wenn die Lebensdauer Ihres Objekts viel komplizierter ist und nicht direkt an einen bestimmten Codeabschnitt oder ein anderes Objekt gebunden ist.
Es gibt einen Nachteil bei referenzgezählten Zeigern - die Möglichkeit, eine baumelnde Referenz zu erstellen:
// 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!
Eine andere Möglichkeit ist das Erstellen von Zirkelverweisen:
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!
Um dieses Problem zu umgehen, haben sowohl Boost als auch C ++ 11 a definiert weak_ptr, um einen schwachen (nicht gezählten) Verweis auf a zu definieren shared_ptr.