Wie um zu testen, ob ein shared_ptr ist leer oder hat nichts

Einer C++ - std::shared_ptr<..> werden kann leer und es kann auch sein null. Diese beiden Konzepte existieren, und Sie sind nicht entspricht. Darüber hinaus werden weder die Implikation ist immer wahr, zwischen diesen Fällen.

Letzteren Fall ist trivial zu erkennen, weil operator bool bietet genau das testen. Laut der docs, es "prüft, ob *this speichert einen nicht-null-Zeiger ist, d.h. ob get() != nullptr."

Gibt es einen test für den ersten Fall, der Fall, wo das Ding leer?

Mein Einsatz für diesen ist Recht einfach. Ich habe eine Klasse, die eine statische factory-Methode. Innerhalb der statischen factory-Methode ist eine statische lokale shared_ptr zu einer Instanz der Klasse initialisiert, um nullptr. Der erste Aufruf dieser factory-Methode erstellt eine Instanz der Klasse und initialisiert die statischen lokalen shared_ptr vor der Rücksendung eine Kopie - es wird bewacht von einem mutex. Dass shared_ptr gehalten werden kann durch etwas, kopiert und weitergegeben zu, weitere Exemplare können erworben werden, durch zusätzliche Aufrufe der statischen Fabrik, und schließlich, wenn alle Kopien zerstört werden, die shared_ptr's deleter zerstört die Instanz.

Die Instanz selbst wird erstellt und zerstört mit einem legacy-C-API, umhüllt von meiner Klasse, und das, obwohl diese Instanzen gemeinsam genutzt werden sollen, wie singletons, aber auch Sie müssen gereinigt werden, wenn Sie nicht mehr benötigt werden - im Gegensatz zu singletons.

Im moment bin ich mit einem null-check, um zu entscheiden, ob die statische lokale shared_ptr sollte initialisiert werden oder lediglich kopiert. Ich fürchte, dass dieser test nicht zu erkennen, der Fall, wo die re-Initialisierung erforderlich ist - zum Beispiel, wenn etwas versucht zu erwerben, eine Instanz an, einige Zeit nachdem alle bisherigen Nutzer Gaben Ihre Referenzen und die gemeinsame Instanz wurde gelöscht.

Ist oder ist es wahr, dass shared_ptr zurückgesetzt nullptr wenn der Verweiszähler auf null fällt und die deleter aufgerufen wird? Auch für custom-deleters?

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

Wie etwa die überprüfung, ob the counter gleich null ist?
Da der Hinweis: "dies ist Jedoch nicht garantiert, in einer multithreaded Umgebung."
Wenn ich das Lesen, es klingt wie es wird immer einen reference count von 1 für einige shared_ptr-Objekts, nachdem die erste Initialisierung stattfindet. Wenn nicht, für welches Objekt würden Sie in diesem hypothetischen rufen, um zu bestimmen, Ihren aktuellen Zustand? Es klingt wie Sie vielleicht möchten weak_ptr Verhalten. Oder vielleicht könnten Sie kurz erläutern und die Frage, um diesen Punkt deutlicher (d.h. den Fall "wenn etwas versucht zu erwerben, eine Instanz an, einige Zeit nachdem alle bisherigen Nutzer Gaben Ihre Referenzen und die gemeinsame Instanz gelöscht wurde").
Dein Anwendungsfall klingt nicht richtig. Sie haben eine statische shared_ptr und Sie die aushändigung von Kopien zu. Dieses eigentlich macht es so singelton die statische Instanz wird nie aufgeräumt. Wenn Sie ein singleton-Sie können auch std::unique_ptr für die Instanz und die Rückkehr der raw-pointer durch Ihre Fabrik.

InformationsquelleAutor Xharlie | 2017-02-08

c++shared-ptr

6

Die statische Instanz der shared_ptr halten eine Referenz, so wird das Objekt immer einen ref-count >= 1 ist, und wird nicht gelöscht werden, bis die statische Bereinigung passiert. Als cnettel sagt in den Kommentaren, die Sie benötigen std::weak_ptr hier.

weak_ptr ist im Grunde ein shared_ptr die nicht dazu beitragen, die ref zu zählen. Es hat eine Atomare Besetzung zu std::shared_ptr über die .lock() Methode. Die daraus resultierende std::shared_ptr konvertieren wird zu false, wenn es nicht initialisiert, so dass Sie wissen, neu zu initialisieren (oder intialize für die erste Zeit).

Beispiel:
```
std::shared_ptr<Obj> instance() {
    static std::weak_ptr<Obj> instance;
    static std::mutex lock;

    std::lock_guard<std::mutex> guard(lock);

    auto result = instance.lock();
    if (!result) {
        result = std::make_shared<Obj>();
        instance = result;
    }

    return result;
}
```
- Alrighty werden. Ich denke, ich habe jetzt, was ich derzeit brauche. Ich weiß immer noch nicht die Antwort auf die eigentliche Frage, die ich gefragt obwohl. Es scheint, wie es ist nicht thread-sichere Lösung, um das problem... die ist ganz fein von mir, da ich nicht mehr brauchen. Ta.
- Das problem mit der Frage, wie festgestellt worden ist, dass ein shared_ptr, einmal initialisiert, kann niemals eine Zahl <= 0, so sind die Voraussetzungen in Frage, die niemals auftreten werden. Die überprüfung, ob der Zähler null ist nur eine Prüfung, wenn er initialisiert wurde, ich denke, die Warnung ist im Grunde sagen, dass if(ptr.use_count() == 0) ptr = new Obj(); ist nicht thread-sicher, und Sie brauchen einen mutex.
- auch, null (d.h. Standard-operator bool) sollte immer Ihre Gültigkeit überprüfen. Sollten Sie nicht (in der Regel) egal, was die shared_ptr besitzt. Es könnte selbst mit einem Objekt, oder gar nichts besitzen (z.B. Punkt in den stack), aber wenn es jemals dereferenziert zu nullptr, können Sie es nicht verwenden, so sollten Sie handeln, wie es ist unwirksam. Technisch, denke ich, Sie hätte einen Zeiger besitzen etwas, aber eigentlich Dereferenzierung auf null, aber das wäre zu explizit konstruiert sehr merkwürdig und ich kann mir persönlich nicht vorstellen, eine Verwendung für Sie.
InformationsquelleAutor Joseph Ireland

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.