Warum ist shared_ptr <void> legal, während unique_ptr <void> schlecht geformt ist?

Die Frage passt wirklich in den Titel: Ich bin gespannt, was der technische Grund für diesen Unterschied ist, aber auch die Gründe?

std::shared_ptr<void> sharedToVoid; // legal;
std::unique_ptr<void> uniqueToVoid; // ill-formed;

Dies liegt daran, dass std::shared_ptrdie Typlöschung implementiert wird, dies std::unique_ptrjedoch nicht.

Da std::shared_ptrdie Typlöschung implementiert wird, unterstützt sie auch eine andere interessante Eigenschaft, nämlich Der Typ des Löschers als Argument für den Vorlagentyp für die Klassenvorlage ist nicht erforderlich . Schauen Sie sich ihre Erklärungen an:

template<class T,class Deleter = std::default_delete<T> > 
class unique_ptr;

welches Deleterals Typparameter hat, während

template<class T> 
class shared_ptr;

hat es nicht.

Die Frage ist nun, warum die Typlöschung shared_ptrimplementiert wird. Nun, es tut so, weil sie Unterstützung Referenzzählung hat, und dies zu unterstützen, hat es Speicher von Heap zu reservieren , und da es zu hat Speicher ohnehin zuweisen, geht noch einen Schritt weiter und Geräte - Typ-Löschung - die braucht Heap Zuordnung auch. Im Grunde ist es also nur opportunistisch!

Kann aufgrund der Typlöschung std::shared_ptrzwei Dinge unterstützen:

• Es kann Objekte jeglicher Art zu speichern , wie void*, aber es ist noch in der Lage , die Objekte auf Zerstörung ordnungsgemäß zu löschen , indem korrekt Aufrufe ihren destructor .
• Der Typ des Löschers wird nicht als Typargument an die Klassenvorlage übergeben, was ein wenig Freiheit bedeutet, ohne die Typensicherheit zu beeinträchtigen .

In Ordung. So std::shared_ptrfunktioniert es.

Nun stellt sich die Frage, std::unique_ptrob Objekte gespeichert werden können als void* ? Die Antwort lautet: Ja - vorausgesetzt, Sie übergeben einen geeigneten Deleter als Argument. Hier ist eine solche Demonstration:

int main()
{
    auto deleter = [](void const * data ) {
        int const * p = static_cast<int const*>(data);
        std::cout << *p << " located at " << p <<  " is being deleted";
        delete p;
    };

    std::unique_ptr<void, decltype(deleter)> p(new int(959), deleter);

} //p will be deleted here, both p ;-)

Ausgabe ( Online-Demo ):

959 located at 0x18aec20 is being deleted

Sie haben im Kommentar eine sehr interessante Frage gestellt:

In meinem Fall benötige ich einen Löscher zum Löschen von Typen, aber dies scheint auch möglich zu sein (auf Kosten einer Heap-Zuweisung). Bedeutet dies im Grunde, dass es tatsächlich eine Nische für einen dritten Typ eines intelligenten Zeigers gibt: einen intelligenten Zeiger mit exklusivem Besitz und Typlöschung.

zu dem @Steve Jessop die folgende Lösung vorschlug:

Ich habe das noch nie versucht, aber vielleicht könnten Sie das erreichen, indem Sie einen geeigneten std::functionTyp als Deleter verwenden unique_ptr? Angenommen, das funktioniert tatsächlich, dann sind Sie fertig, exklusives Eigentum und ein vom Typ gelöschter Löscher.

Nach diesem Vorschlag habe ich dies implementiert (obwohl es nicht verwendet wird, std::functionda es nicht notwendig erscheint):

using unique_void_ptr = std::unique_ptr<void, void(*)(void const*)>;

template<typename T>
auto unique_void(T * ptr) -> unique_void_ptr
{
    return unique_void_ptr(ptr, [](void const * data) {
         T const * p = static_cast<T const*>(data);
         std::cout << "{" << *p << "} located at [" << p <<  "] is being deleted.\n";
         delete p;
    });
}

int main()
{
    auto p1 = unique_void(new int(959));
    auto p2 = unique_void(new double(595.5));
    auto p3 = unique_void(new std::string("Hello World"));
}  

Ausgabe ( Online-Demo ):

{Hello World} located at [0x2364c60] is being deleted.
{595.5} located at [0x2364c40] is being deleted.
{959} located at [0x2364c20] is being deleted.

Hoffentlich hilft das.

Eine der Begründungen liegt in einem der vielen Anwendungsfälle von a shared_ptr- nämlich als Lebenszeitindikator oder Sentinel.

Dies wurde in der ursprünglichen Boost-Dokumentation erwähnt:

auto register_callback(std::function<void()> closure, std::shared_ptr<void> pv)
{
    auto closure_target = { closure, std::weak_ptr<void>(pv) };
    ...
    // store the target somewhere, and later....
}

void call_closure(closure_target target)
{
    // test whether target of the closure still exists
    auto lock = target.sentinel.lock();
    if (lock) {
        // if so, call the closure
        target.closure();
    }
}

Wo closure_targetist so etwas:

struct closure_target {
    std::function<void()> closure;
    std::weak_ptr<void> sentinel;
};

Der Anrufer würde einen Rückruf wie folgt registrieren:

struct active_object : std::enable_shared_from_this<active_object>
{
    void start() {
      event_emitter_.register_callback([this] { this->on_callback(); }, 
                                       shared_from_this());
    }

    void on_callback()
    {
        // this is only ever called if we still exist 
    }
};

Da event_emitter shared_ptr<X>immer in konvertierbar ist shared_ptr<void>, kann es sein, dass er sich des Objekttyps, in den er zurückruft, glücklicherweise nicht bewusst ist.

Diese Vereinbarung entbindet den Event-Emittenten von der Verpflichtung, Crossing-Fälle zu bearbeiten (was ist, wenn der Rückruf in einer Warteschlange wartet und darauf wartet, ausgeführt zu werden, während active_object verschwindet?), Und bedeutet auch, dass keine Abmeldung synchronisiert werden muss. weak_ptr<void>::lockist eine synchronisierte Operation.