Mit std::make_unique mit einer custom deleter

In mit std::unique_ptr mit einer custom deleter habe ich den Wunsch verwenden std::make_unique eher als eine raw-neue. Ich bin mit VC++2013. Es scheint mir, dass es keine Möglichkeit gibt, zu verwenden std::unique_ptr wenn Sie einen custom deleter. Habe ich irgendwas übersehen oder ist das wirklich der Fall?

Zusätzliche Informationen:

Ich bin mit einem std::unique_ptr<HANDLE, custom_deleter> zu halten, ein Windows-HANDLE des geöffneten COM-port.

Dass ich schreiben konnte, eine benutzerdefinierte RAII-Klasse für diese, und wäre es nicht furchtbar schwer, aber ich war zu sehen, wie hart/schwer/schlecht es wäre std::unique_ptr.

InformationsquelleAutor der Frage Graznarak | 2014-02-14

  1. 19

    Den ganzen Punkt make_unique ist zum einkapseln der Begriff der "Verwendung new zu erstellen T aus gegebenen Argumente im Konstruktor und verwenden delete es zu zerstören".

    Wenn Sie wollten einen custom deleter, Sie würde auch noch angeben, wie erstellen das Objekt, und dann würde es nichts mehr gewonnen, dass die emplacing-maker-Funktion.

    Schrieb ich einige Beispiele für custom maker Funktionen für bestimmte, einzigartige Ressource behandelt in diesem Beitrag.

    InformationsquelleAutor der Antwort Kerrek SB

  2. 0

    Hier ist ein Weg, um wrap-c-Stil-memory-management in einem std::unique_ptr mit einer custom deleter, ruft eine benutzerdefinierte Kostenlose Funktion. Dieser verfügt über die Funktion helper ähnlich std::make_unique LIVE:

    #include <iostream>
#include <functional>
#include <memory>

//Some C style code that has some custom free function ptr...
extern "C" {

struct ABC { };

enum free_type_e {
    FREE_ALL,
    FREE_SOME
};

typedef void (free_f)(enum free_type_e free_type, void *ptr);
struct some_c_ops { free_f* free_op; };

void MY_free(enum free_type_e free_type, void *ptr)
{
    printf("%s:%d ptr=%ld\n", __func__, __LINE__, (long)ptr);
    (void)free_type;
    free(ptr);
}

}; //extern "C"

template<typename T>
using c_unique_ptr = std::unique_ptr<T,std::function<void(T*)>>;

template <typename T>
c_unique_ptr<T> make_c_unique(some_c_ops* op, free_type_e free_type)
{
    return c_unique_ptr<T>(static_cast<T*>(calloc(1, sizeof(T))),
                           std::bind(op->free_op, free_type, std::placeholders::_1));
}

void foo(c_unique_ptr<ABC> ptr)
{
    std::cout << __func__ << ":" << __LINE__
        << " ptr=" << reinterpret_cast<size_t>(ptr.get()) <<     std::endl;
}

int main()
{
    some_c_ops ops = { MY_free };
    c_unique_ptr<ABC> ptr = make_c_unique<ABC>(&ops, FREE_ALL);
    std::cout << __func__ << ":" << __LINE__
        << " ptr=" << reinterpret_cast<size_t>(ptr.get()) << std::endl;

    foo(std::move(ptr));

    std::cout << __func__ << ":" << __LINE__
        << " ptr=" << reinterpret_cast<size_t>(ptr.get()) << std::endl;
}

    Möglich-Ausgang:

    main:48 ptr=50511440
foo:40 ptr=50511440
MY_free:20 ptr=50511440
main:53 ptr=0

    InformationsquelleAutor der Antwort Jon Ringle

  3. -1

    Soweit ich weiß, gibt es keine make_unique - Funktion in der C++11 standard. Sehen

    Also ich würde davon ausgehen, dass die make_unique ist eine Implementierung von Microsoft, zumindest nicht in den standard aufgenommen.

    Aber dennoch können Sie einen custom deleter mit unique_ptr. Bei der Verwendung von unique_ptr müssen Sie die Art von der Streicher als zweites template-argument und übergeben Sie dann ein geeignetes Objekt an den Konstruktor.

    InformationsquelleAutor der Antwort sleepy42

Schreibe einen Kommentar