In der jüngsten overload journal unter dem Thema Erzwingen der Regel von Null, beschreiben die Autoren, wie wir die Regel von fünf Betreibern Schreiben vermeiden können, da die Gründe für das Schreiben von ihnen sind:C++ Rule of Zero: polymorphen Löschen und unique_ptr Verhalten
- Ressourcenmanagement
- Polymorphe Löschen
Und beide können diese Sorge durch die Verwendung Smart Pointer genommen werden.
Hier interessiert mich speziell der zweite Teil.
Betrachten Sie den folgenden Code-Schnipsel:
class Base
{
public:
virtual void Fun() = 0;
};
class Derived : public Base
{
public:
~Derived()
{
cout << "Derived::~Derived\n";
}
void Fun()
{
cout << "Derived::Fun\n";
}
};
int main()
{
shared_ptr<Base> pB = make_shared<Derived>();
pB->Fun();
}
In diesem Fall, wie die Autoren des Artikels erklären, wir polymorphe Löschen erhalten, indem einen gemeinsamen Zeiger verwenden, und dies funktioniert. Wenn ich die shared_ptr
durch eine unique_ptr
ersetze, kann ich die polymorphe Löschung nicht mehr beobachten.
Jetzt ist meine Frage, warum sind diese beiden Verhaltensweisen unterschiedlich? Warum kümmert sich shared_ptr
polymorphe Löschung, während unique_ptr
nicht?
Wie initialisierst du den 'unique_pointer'? –
Spielt es eine Rolle? Wie immer: unique_ptr pB (new Derived()) –
Arun
Weil 'std :: shared_ptr' einen Zeiger auf die Deleter-Funktion trägt. Wenn Sie einem kompatiblen einen 'std :: shared_ptr 'zuweisen, ist der Zeiger eines der kopierten oder verschobenen Elemente. Dies passiert nicht mit 'std :: unique_ptr' und da Ihre Basisklasse keinen virtuellen Destruktor hat, werden Sie entbeint. –