Wie gehen deleter zu make_shared?

Seit C++11, da von mehreren Gründen, tendieren Entwickler dazu, den Einsatz von smart-pointer-Klassen für die dynamische Lebenszeit von Objekten. Und mit diesen neuen smart-pointer-Klassen, - standards, auch empfehlen nicht die Verwendung von Operatoren wie new statt, die Sie vorschlagen, zu verwenden make_shared oder make_unique zu vermeiden, dass einige Fehler anfällig.

Wenn wir wie die Verwendung einer smart-pointer-Klasse, wie shared_ptr können wir konstruieren ein wie,

shared_ptr<int> p(new int(12));

Auch wir gerne weitergeben möchte einen custom deleter smart-pointer-Klassen,

shared_ptr<int> p(new int(12), deleter);

Auf der anderen Seite, wenn wir wie zu verwenden make_shared zu reservieren, für die ex. int anstelle der Verwendung new und shared_ptr Konstruktor, wie auf den ersten Ausdruck, den wir verwenden können,

auto ip = make_shared<int>(12);

Aber was ist, wenn wir auch einen custom deleter zu make_shared, gibt es eine richtige Weise, das zu tun? Scheint wie Compiler, zumindest gcc, gibt Fehler zu,

auto ip = make_shared<int>(12, deleter);
  • Schreiben Sie Ihre eigene make_shared(), die dies unterstützt, ist es machbar.
InformationsquelleAutor cavitsinadogru | 2015-12-12
  1. 49

    Wie andere gesagt haben, make_shared kann nicht verwendet werden, mit einem custom deleter. Aber ich will erklären, warum.

    Benutzerdefinierte deleters existieren, weil Sie zugeordnet den Zeiger auf eine Besondere Art und Weise, und deshalb müssen Sie in der Lage sein, um deallocate es in eine entsprechend Besondere Art und Weise. Gut, make_shared weist der Zeiger mit new. Objekte zugewiesen mit new werden sollte, aufgehoben mit delete. Die standard-deleter pflichtbewusst tut.

    Kurz gesagt, wenn Sie Leben können mit den default-Zuweisung Verhalten, Sie Leben können mit den Standard - Freigabe Verhalten zu. Und wenn Sie nicht Leben können mit der Standard-Zuweisung Verhalten, sollten Sie allocate_shared, die mit der vorgesehenen Zuweisung sowohl allocate und deallocate der Lagerung.

    Auch make_shared darf (und fast sicher) den Speicher für T und der Steuerblock für die shared_ptr innerhalb der gleichen Zuweisung. Dies ist etwas, dass Ihr deleter nicht wirklich auskennen, oder befassen sich mit. In der Erwägung, dass allocate_shared ist in der Lage Handhabung, da die Zuweisung die Sie tun können, - Allokation und-Freigabe Pflichten.

    • Von Ihnen positiv bewertet werden, habe ich nie nachgedacht, aber es macht durchaus Sinn. Guter Tipp.
    • +1 aber benutzerdefinierte deleters sind nicht nur für die Steuerung von Freigabe, die Zeiger, die im Besitz einer shared_ptr noch nicht unbedingt "zugewiesen" an alle. Sie möchten möglicherweise verwenden Sie fclose zum schließen einer DATEI* zum Beispiel. Mit allocate_shared ermöglicht Ihnen die Steuerung der Speicherzuweisung, aber nicht beliebige Ressourcen. Sie haben noch zu konstruieren und zu zerstören ein Objekt, nicht erhalten "Ressource" aus einer Funktion und frei, es mit einem anderen (deleter) - Funktion. Auch wenn lwg 2070 wird behoben das immer noch nicht erlauben, benutzerdefinierte deleters mit machen/allocate_shared.
    • Die Quintessenz ist, dass, da machen/allocate_shared nicht erlauben, Sie zu ändern "erhalten Sie eine Ressourcen -" Schritt macht es keinen Sinn für Sie um die Unterstützung benutzerdefinierter Möglichkeiten, um die "freie Ressourcen" entweder. Sie sind für einfache erstellen/zerstören eines Objekts verwendet der shared_ptr.
    • Oder anders gesagt: betrachten Sie ein unvollständiger Typ, der X und Funktionen get() und put(X*). Sie können diese mit shared_ptr<X>(get(), &put) aber es gibt keinen Weg, um make_shared oder allocate_shared denn beide hängen von sizeof(X) ist nicht bekannt.
    • Aber in jenen Fällen, Sie erstellt das Objekt wird hingewiesen. So konnte man nie verwenden make_shared oder allocate_shared, da der primäre Zweck der beiden ist für Ihnen, um das Objekt zu erstellen.
    • Das sollte die Antwort sein 🙂 Über die Zuteilung und die allocate_shared ist eine unnötige Ablenkung. Der Punkt ist, dass make_shared erstellt das Objekt, so sollten Sie auch Vertrauen, dass Sie "uncreate" es.
    • Also sollte ich sagen, "kurz gesagt, wenn Sie Leben können mit den default-Zuweisung Verhalten, Sie Leben können mit der Standard-Freigabe-Verhalten zu?" Mein Punkt mit allocate_shared ist, dass es in vielen Fällen verwendet werden, wo Sie wollen eine explizite deleter. Nicht unbedingt alle, aber viele.
    • Wie gesagt, es gibt noch mehr "uncreate" als Freigabe, gibt es auch einen Destruktor, aber oft, wenn Sie brauchen einen custom deleter es muss nicht unbedingt um jeden Destruktor, oder jede Freigabe.
    • "Gut, make_shared weist der Zeiger mit neue. Objekte mit new zugewiesen wurden, sollten aufgehoben mit löschen. Die standard-deleter pflichtbewusst tut." Es gibt keine Garantie, make_shared verwendet new, könnte es sich um Speicher mit std::allocator (wie meine Implementierung hat), oder malloc. Oder eine benutzerdefinierte Zuweisung, oder etwas anderes. Die Sie nicht kennen, und so Ihre deleter würde nicht wissen, was zu tun ist. make_shared erstellt das Objekt, irgendwie, so sollten Sie Vertrauen, dass Sie uncreate es.

    InformationsquelleAutor Nicol Bolas
  2. 11

    Als von der Dokumentation, make_shared akzeptiert eine Liste der Argumente, mit dem eine Instanz von T konstruiert werden.

    Auch die Dokumentation sagt, dass:

    Diese Funktion wird normalerweise verwendet, um zu ersetzen, den Bau von std::shared_ptr(new T(args...)) eines shared-pointer von der raw-pointer zurückgegeben, der durch einen Aufruf von new.

    Weil das so ist, können Sie ableiten, dass Sie können nicht von einer benutzerdefinierten deleter.

    Um das zu tun, müssen Sie erstellen die shared_ptr für sich selbst, durch die richtige Konstruktor.

    Als ein Beispiel eines Konstruktors aus der vorgeschlagenen Liste, die Sie verwenden können:

    template< class Y, class Deleter > 
shared_ptr( Y* ptr, Deleter d );

    So, der code wird so etwas wie:

    auto ptr = std::shared_ptr(new MyClass{arg1, arg2}, myDeleter);

    Statt:

    auto ptr = std::make_shared<MyClass>(arg1, arg2);
    InformationsquelleAutor skypjack
  3. 4

    Können Sie nicht. make_shared<T> leitet die bereitgestellten Argumente an den Konstruktor des Typs T. Es ist für den einfachen Fall, wenn Sie wollen, dass die Standard-deleter.

    InformationsquelleAutor KyleKnoepfel
  4. 3

    Es ist nicht spezifiziert, wie make_shared erhält der Speicher für das Objekt (es könnte operator new oder malloc oder irgendeine Art von Zuweisung), so gibt es keine Möglichkeit einen custom deleter konnte wissen, wie das richtige zu tun. make_shared erstellt das Objekt, so haben Sie auch verlassen sich auf Sie, um das Objekt zu zerstören korrekt und die entsprechenden Aufräumen, was auch immer das ist.

    Auch wir gerne weitergeben möchte einen custom deleter smart-pointer-Klassen,

    shared_ptr<int> p(new int(12), deleter);

    Ich glaube nicht, dass dies ist ein sehr realistisches Beispiel. Einen custom deleter ist in der Regel verwendet, wenn die Ressource erworben wurde, in eine Besondere Art und Weise. Wenn Sie gerade erstellt mit new wie dieses, dann warum brauchen Sie einen custom deleter überhaupt?

    Wenn Sie wollen einfach nur etwas code ausgeführt werden, die auf Zerstörung aus sind, dann legen Sie es in einen Destruktor! So können Sie auch immer noch verwenden Sie es mit make_shared z.B.

    struct RunSomethingOnDestruction {
  RunSomethingOnDestruction(int n) : i(n) { }
  ~RunSomethingOnDestruction() { /* something */ }
  int i;
};

auto px = std::make_shared<RunSomethingOnDestruction>(12);
std:shared_ptr<int> p(px, px->i);

    Dies gibt Ihnen eine shared_ptr<int> erstellt wird make_shared (so bekommt man den Speicher Optimierungen durchgeführt, indem make_shared), die ausgeführt wird, einige benutzerdefinierte code auf Zerstörung.

    InformationsquelleAutor Jonathan Wakely
  5. 0

    Wenn du einen custom deleter Sie nicht verwenden können make_unique oder make_shared Funktionen beim erstellen einer smart-pointer-Objekte . Da müssen wir bieten unseren custom deleter diese Funktionen nicht unterstützen .

    Nicht verwenden make_unique oder make_shared wenn Sie einen custom deleter oder die Annahme einer raw-Zeiger von anderswo.

    Die Idee ist, wenn Sie brauchen eine spezielle Art und Weise löschen Sie Ihr Objekt, das Sie wahrscheinlich brauchen eine spezielle Art und Weise zu schaffen, Sie auch .

    Lassen Sie uns sagen, dass wir eine Test-Klasse

    #include <iostream>    
using namespace std;    
class Test
{
private : 
    int data; 
    public : 
    Test() :data{0}
    {
        cout << "Test constructor (" << data << ")" << endl;
    }
    Test(int d) : data{ d }
    {
        cout << "Test constructor (" << data << ")" << endl; 
    }
    int get_data() const { return data; }
    ~Test()
    { 
        cout << "Test Destructor (" << data << ')' << endl; 
    }
};

//main function. 
int main()
{
   //It's fine if you use  make_shared and custom deleter like this
   std::shared_ptr<Test> ptr(new Test{1000},
            [](Test *ptr)
            {
                cout << "some Code that you want to execute "; 
                delete ptr;
            });
         return 0;
}

    Aber wenn man make_shared-Funktion wird ein compiler-Fehler

    std::shared_ptr<Test> ptr = make_shared<Test>(1000,
            [](Test *ptr){
               cout << "some Code that you want to execute "; 
               delete ptr;
            });

    Grundsätzlich make_shared Funktion ist ein wrapper für new und delete und wenn Sie möchten, eine custom deleter Sie haben, um Sie eigenen new und delete

    InformationsquelleAutor
Schreibe einen Kommentar