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

Auf der Seite cplusplus.comshared_ptr wird zwischen einer leeren std::shared_ptr und einer Null unterschieden shared_ptr . Die Seite cppreference.com ruft die Unterscheidung nicht explizit auf, sondern verwendet nullptrin ihrer Beschreibung des std::shared_ptrVerhaltens sowohl "leer" als auch Vergleich mit .

Gibt es einen Unterschied zwischen einer leeren und einer Null shared_ptr? Gibt es einen Anwendungsfall für solche Zeiger mit gemischtem Verhalten? Ist eine nicht leere Null shared_ptrüberhaupt sinnvoll? Würde es im normalen Gebrauch jemals einen Fall geben (dh wenn Sie keinen explizit konstruiert hätten), in dem Sie am Ende eine leere, aber nicht null haben könnten shared_ptr?

Und ändert sich eine dieser Antworten, wenn Sie die Boost-Version anstelle der C ++ 11-Version verwenden?

Es ist eine seltsame Ecke des shared_ptrVerhaltens. Es hat einen Konstruktor, der Sie eine machen können , shared_ptrdie besitzt etwas und zeigt auf etwas anderes:

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

Der shared_ptrkonstruierte mit diesem Konstruktor Aktien Eigentum mit r, sondern verweist auf was auch immer ptrPunkte zu (dh, Berufung get()oder operator->()kehrt ptr). Dies ist praktisch für Fälle, in denen ptrauf ein Unterobjekt (z. B. ein Datenelement) des Objekts verwiesen wird, dessen Eigentümer es ist r.

Die gewünschte Seite verlinkt sind Anrufe ein , shared_ptrdie nichts besitzt leer , und shared_ptrdass Punkte auf nichts (dh deren get() == nullptr) null . ( Leer wird in diesem Sinne vom Standard verwendet; null ist nicht.) Sie können eine Null shared_ptrerstellen, aber nicht leer , aber es ist nicht sehr nützlich. Eine leere, aber nicht null shared_ptrist im Wesentlichen ein nicht besitzender Zeiger, der verwendet werden kann, um einige seltsame Dinge zu tun, z. B. einen Zeiger auf etwas zu übergeben, das auf dem Stapel einer Funktion zugewiesen ist, die eine erwartetshared_ptr (aber ich würde vorschlagen, jeden zu schlagen, der shared_ptrhineingesteckt hat die API zuerst).

boost::shared_ptrauch hat diesen Konstruktor , die sie den Anruf Aliasing Konstruktor .

Gibt es einen Unterschied zwischen einem leeren und einem null shared_ptr?

Leer shared_ptrhat keinen Steuerblock und seine Verwendungsanzahl wird als 0 betrachtet. Eine Kopie von leer shared_ptrist eine weitere leere shared_ptr. Sie sind beide separate shared_ptrs, die keinen gemeinsamen Steuerblock haben, weil sie ihn nicht haben. Leer shared_ptrkann mit dem Standardkonstruktor oder mit einem Konstruktor erstellt werden, der benötigt nullptr.

Nicht leere Null shared_ptrhat einen Steuerblock, der mit anderen shared_ptrs geteilt werden kann. Eine Kopie der nicht leeren Null shared_ptrhat shared_ptrdenselben Steuerblock wie das Original, shared_ptrsodass die Verwendungsanzahl nicht 0 ist. Es kann gesagt werden, dass alle Kopien shared_ptrdieselbenullptr Null haben . Nicht leere Null shared_ptrkann mit einem Nullzeiger vom Objekttyp (nicht nullptr) erstellt werden.

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;
}

Es gibt aus:

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