Wie machen Sie std::shared_ptr nicht, rufen Sie delete()

Habe ich-Funktionen, die in std::shared_ptr als argument, so dass ich gezwungen bin, benutze std::shared_ptr, aber die Objekt bin ich der übergabe an die Funktion ist nicht dynamisch zugeteilt. Wie kann ich wickeln Sie das Objekt std::shared_ptr und std::shared_ptr nicht, rufen Sie löschen auf Sie.

mögliche Duplikate von Wie zu release-pointer von boost::shared_ptr?
nicht ein Duplikat ist, diese Frage hat nichts zu tun mit der boost-library.
Außer, dass std::shared_ptr und boost::shared_ptr sind praktisch identisch.
boost::shared_ptr war im Grunde der Prototyp für das, was wurde std::shared_ptr.
Dies ist eine schreckliche Idee. Der einzige Grund für eine Funktion zu akzeptieren shared_ptr ist, wenn er beabsichtigt, zum speichern eines Verweises auf die pointee (d.h., Aktienbesitz). Ungültig, das Objekt, während die Referenz wird irgendwo gespeichert wird nicht gut gehen. Wenn die Funktion in Frage stellt nicht speichern Sie einen Verweis, sollte es nicht akzeptieren, eine besitzende Zeiger-Typ.
Ein Anwendungsfall für diese ist, wo Sie so etwas wie FILE * wo der Typ kann entweder verwaltet werden (z.B. über fopen) oder nicht (z.B. stdin) und Sie haben eine Klasse verwendet, die das Objekt über den Ruf, den Sie erstellt wurden (z.B. die Erstellung einer parser-oder logger). In diesem Fall würden Sie wollen, eine "nichts tun" deleter mit stdin, sondern eine fclose deleter mit einem fopened-Datei.
Eine real life-Anwendung, die ich habe über kommen, wo diese Idee Sinn macht, mit einem shared_ptr<ostream>. Vielleicht habe ich eine Funktion, die einen ostream und speichert einen Verweis, um es als einen freigegebenen Zeiger für die spätere Verwendung. Jetzt sagen wir, ich will die Ausgabe auf std::cout. Ich kann nicht löschen std::cout, aber ich kann garantieren, dass es existiert mindestens so lange wie meine Funktion speichert die shared pointer.

InformationsquelleAutor Ken Li | 2013-11-21

c++c++11 shared-ptr

39
```
MyType t;
nasty_function(std::shared_ptr<MyType>(&t, [](MyType*){}));
```
- Schöner Zufall bei der Namensgebung...
- Kein Zufall. Einfach nur kopieren und einfügen. Zeigt eine weitere C++11ish alternative.
- Hinweis: Jede Funktion übergeben Sie einen shared_ptr zu, könnte auch greifen, Eigentum an das Objekt, also die OP muss sicherstellen, dass entweder (a) das nicht passiert ist, oder (b) die Lebensdauer des Objekts länger ist als die Lebensdauer von allem, was ist geteiltes Eigentum von es.
InformationsquelleAutor ronag

Geben Sie eine no-op-deleter beim erstellen der shared pointer. E. g. wie diese:

void null_deleter(MyType *) {}

int main()
{
  MyType t;
  nasty_function(std::shared_ptr<MyType>(&t, &null_deleter));
}

InformationsquelleAutor Angew

15

Der beste Weg, dies zu tun, ist die Verwendung der aliasing-Konstruktor:
```
nasty_function(std::shared_ptr<MyType>(std::shared_ptr<MyType>{}, &t));
```
Im Vergleich zu den null-deleter Ansatz, diese müssen nicht reserviert einen control block, und ist noexcept.

Wie bereits von @Casey und @Nevin, dies sollte nur durchgeführt werden, wenn Sie sicher sind, dass die Funktion nicht versucht in gemeinsamem Besitz sind, oder wenn das Objekt überlebt alles, könnte "eigenen" haben.
- Große Hinweis. Als ein Hinweis auf Versionen: dies ist eine Funktion von Cx+11, aber auch von boost 1.35 als nasty_function(boost::shared_ptr<MyType> (boost::shared_ptr<MyType>(), &t));
- Ich möchte nur hinzufügen, eine Notiz über @T. C ' s Antwort mit der aliasing-Konstruktor. Wenn Sie diese Technik verwenden, werden Sie nicht in der Lage sein zu nehmen, ein std::weak_ptr auf die daraus resultierenden std::shared_ptr.
- Bedeutet es, dass Sie eine shared_ptr ohne control block?
- Ja.
InformationsquelleAutor T.C.
-1

Können Sie diesen trick:
```
A a;
shared_ptr<A> pa(&a);
foo(pa);
new (&pa) shared_ptr<A>();  //pa "forgets" about a
```
- Die Platzierung der neuen überschreiben Sie den Zeiger, ohne dessen Destruktor aufzurufen. Clever. Rein akademisch (weil die ganze Frage ist ziemlich schrecklich): keine Ahnung, ob das definierte Verhalten?
- Natürlich nicht. Die zweite Zeile ist die UB bereits (für das brechen einer Requires-Klausel auf den Konstruktor); Sie brauchen noch nicht einmal den placement new.
- Auch, ignorieren alles andere, zumindest leak control-block.
InformationsquelleAutor Aharon Abramson
-1

ich war gerade auf der Suche nach einer Lösung, sah diese Frage. fand nichts und machte ein großer, das ist mein code
```
class HBitmap : public shared_ptr<HBITMAP__>
{
public:
    HBitmap();
    HBitmap(HBITMAP Handle);
    bool autoDelete = true;
};

Win32::HBitmap::HBitmap(HBITMAP Handle)
: shared_ptr<HBITMAP__>(Handle, [&](HBITMAP hBitmap)  {if(autoDelete)DeleteObject(hBitmap);})
{
}
```
diese Lösung ist eine Kombination von lambda-Ausdrücken und Vererbung.
sehr gut gebildet. schnell. Sie können nicht erwarten, etwas mehr. nicht nur Sie können die deleter, aber wenn Sie einige änderungen, können Sie eine std::function<void(pointer)> als custom deleter. mit lambdas können Sie frei laufen und tun, was immer Sie wollen.

InformationsquelleAutor TheNegative

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.