Was ist der Unterschied zwischen einer leeren und einer null-std::shared_ptr in C++?

Den cplusplus.com shared_ptr - Seite ruft eine Unterscheidung zwischen einem leer std::shared_ptr und ein null shared_ptr. Die cppreference.com Seite nicht explizit aufrufen, aus der Unterscheidung verwendet wird, sondern beide "leer" und der Vergleich zu nullptr in seiner Beschreibung der std::shared_ptr Verhalten.

Gibt es einen Unterschied zwischen einem leeren und einem null -shared_ptr? Gibt es eine Verwendung für solche mixed-Verhalten Zeiger? Hat eine nicht-leere null shared_ptr überhaupt Sinn? Würde es jemals einen Fall, bei normaler Nutzung (d.h. wenn Sie nicht explizit konstruieren eins), wo Sie könnten am Ende mit einem empty-aber-nicht-null -shared_ptr?

Und diese Antworten ändern sich, wenn Sie die Boost-version statt des C++11-version?

InformationsquelleAutor R.M. | 2014-09-18
  1. 77

    Es ist eine komische Ecke shared_ptr Verhalten. Es hat einen Konstruktor, der erlaubt Ihnen, eine shared_ptr dass besitzt etwas und Punkte zu etwas anderes:

    template< class Y > 
shared_ptr( const shared_ptr<Y>& r, T *ptr );

    Den shared_ptr konstruiert mit diesem Konstruktor Aktien Eigentum mit r, aber Punkte zu was ptr Punkte auf (D. H., Aufruf get() oder operator->() zurück ptr). Dies ist nützlich für Fälle, in denen ptr Punkte zu einem Unterobjekt (z.B. ein Daten-member) der das Objekt im Besitz von r.

    Die Seite, die du verlinkt fordert eine shared_ptr besitzt nichts leer, und ein shared_ptr dass Punkte nichts (d.h., deren get() == nullptr) null. (Leer in diesem Sinne gebraucht wird, indem der standard; null nicht.) Können Sie konstruieren eine null-aber-nicht-leer shared_ptr, aber es wird nicht sehr sein nützlich. Eine leere-aber-nicht-null - shared_ptr ist im wesentlichen ein nicht-besitzende Zeiger, die verwendet werden können, zu tun einige seltsame Dinge, wie übergeben Sie einen Zeiger auf etwas auf dem Stapel reserviert, um eine Funktion erwartet einen shared_ptr (aber ich würde vorschlagen, Stanz-wer legte shared_ptr innerhalb der API zuerst).

    boost::shared_ptr auch dieser Konstruktor hat, die Sie rufen die aliasing Konstruktor.

    • Erwähnenswert: C++11 § 20.7.2.2.1 (p16) "Hinweis: Dieser Konstruktor erlaubt die Erstellung einer leeren shared_ptr Instanz, die einen nicht-NULL-Zeiger gespeichert." Erwähnenswert ist auch der vorhergehende Hinweis (p15), "um Zu vermeiden, die Möglichkeit, einen dangling pointer, der Benutzer dieser Konstruktor muss sicherstellen, dass p gültig bleibt, zumindest solange das Eigentum Gruppe von r ist zerstört." Eine selten verwendete Konstruktion in der Tat.
    • Ein shared_ptr deren get() zurück nullptr nicht vergleichen Sie gleich nullptr unabhängig davon, ob er etwas besitzt.
    • Eine null-aber-nicht leerer shared_ptrs kann nützlich sein, um sicherzustellen, dass eine Funktion ausgeführt, sobald alle besitzenden Zeiger laufen out of scope (auch im Fall einer Ausnahme!). Nicht sicher, ob es nun eine spezielle Klasse für diese.
    • Was kann eine null-aber-nicht leerer shared_ptr tun, dass ein nicht-null-und-nicht leer shared_ptr nicht kann?
    • Sie können es verwenden, um eine Funktion aufzurufen, die mit einem null-Zeiger als erstes argument:P. Auch wenn Sie nur über eine Funktion (oder lambda) immer ausgeführt, zu einer bestimmten Zeit und weiß nicht, jedes Objekt zu übergeben, verwenden Sie null, um das explizite. Ich gebe zu, durch eine dedizierte Klasse ohne Zeiger-Funktionalität wäre noch deutlicher und besser, aber auch mehr Arbeit für kleine Projekte;). Siehe Verwendung von shared_ptr für die Ausführung von code auf dem block exit
    • Es scheint mir, dass, während Sie können erstellen Sie eine null-aber-nicht leerer shared pointer, es muss piggy back auf einem nicht-null nicht leerer zu bekommen sein Verweiszähler. Oder ist die übergabe eines nicht-nullptr null zu shared_ptr erstellen Sie ein "reference counting" - block?
    • Es scheint, dass die übergabe an einen custom deleter (oder eine nicht-nullptr null) ist ausreichend, um Ursache ein "reference counting" - block erstellt werden, angesichts der Art und Weise die spec geschrieben.
    • Die aliasing-Konstruktor stammt von Bloomberg und wurde vorgeschlagen für den standard-bevor es implementiert wurde, Erhöhen (siehe N1851). Ich bevorzuge den standard-Begriff "Aktien Eigentums mit r" um die Formulierung "besitzt, was r besitzt"
    • gezwickt. Ich bin eigentlich nur zitieren boost für den Namen "aliasing-Konstruktor", da es nicht im standard.

    InformationsquelleAutor T.C.
  2. 6

    Gibt es einen Unterschied zwischen leer und null shared_ptr?

    Leer shared_ptr muss nicht die Kontrolle haben block und seine Verwendung Zählung als 0 ist. Kopieren von leeren shared_ptr ist ein weiteres leeres shared_ptr. Sie sind sowohl in separaten shared_ptrs, keine gemeinsamen Steuerblock, weil Sie es nicht haben. Leer shared_ptr konstruiert werden können, die mit Standard-Konstruktor oder mit Konstruktor nullptr.

    Nicht-leere null shared_ptr hat control-block, der geteilt werden kann mit anderen shared_ptrs. Kopieren von nicht-leeren null shared_ptr ist shared_ptr mit demselben control-block als original shared_ptr so verwenden Sie count nicht 0 ist. Es kann gesagt werden, dass alle Kopien von shared_ptr teilen die gleichen nullptr. Nicht-leere null shared_ptr konstruiert werden können, die mit null-pointer-Objekt-Typ (nicht nullptr)

    Hier ist ein Beispiel:

    #include <iostream>
#include <memory>

int main()
{
    std::cout << "std::shared_ptr<int> ptr1:" << std::endl;
    {
        std::shared_ptr<int> ptr1;
        std::cout << "\tuse count before copying ptr: " << ptr1.use_count() << std::endl;
        std::shared_ptr<int> ptr2 = ptr1;
        std::cout << "\tuse count  after copying ptr: " << ptr1.use_count() << std::endl;        
        std::cout << "\tptr1 is " << (ptr1 ? "not null" : "null") << std::endl;
    }
    std::cout << std::endl;

    std::cout << "std::shared_ptr<int> ptr1(nullptr):" << std::endl;
    {
        std::shared_ptr<int> ptr1(nullptr);
        std::cout << "\tuse count before copying ptr: " << ptr1.use_count() << std::endl;
        std::shared_ptr<int> ptr2 = ptr1;
        std::cout << "\tuse count  after copying ptr: " << ptr1.use_count() << std::endl;        
        std::cout << "\tptr1 is " << (ptr1 ? "not null" : "null") << std::endl;
    }
    std::cout << std::endl;

    std::cout << "std::shared_ptr<int> ptr1(static_cast<int*>(nullptr))" << std::endl;
    {
        std::shared_ptr<int> ptr1(static_cast<int*>(nullptr));
        std::cout << "\tuse count before copying ptr: " << ptr1.use_count() << std::endl;
        std::shared_ptr<int> ptr2 = ptr1;
        std::cout << "\tuse count  after copying ptr: " << ptr1.use_count() << std::endl;        
        std::cout << "\tptr1 is " << (ptr1 ? "not null" : "null") << std::endl;
    }
    std::cout << std::endl;

    return 0;
}

    It-Ausgänge:

    std::shared_ptr<int> ptr1:
    use count before copying ptr: 0
    use count  after copying ptr: 0
    ptr1 is null

std::shared_ptr<int> ptr1(nullptr):
    use count before copying ptr: 0
    use count  after copying ptr: 0
    ptr1 is null

std::shared_ptr<int> ptr1(static_cast<int*>(nullptr))
    use count before copying ptr: 1
    use count  after copying ptr: 2
    ptr1 is null

    http://coliru.stacked-crooked.com/a/54f59730905ed2ff

    InformationsquelleAutor anton_rh
Schreibe einen Kommentar