Wie Smart-Pointer in dieser Situation verwenden

Question

I Smart-Pointer in der folgenden Situation verwendet werden soll:

SOME_STRUCT* ptr = new SOME_STRUCT; 
    ptr->SOME_MEMBER = new BYTE[100]; 
    CallSomeAPI(ptr); 

nun die API kann entweder zurückgeben Fehler oder passiert erfolgreich, aber in diesen beiden Fällen i das Objekt löschen möchte Eine Möglichkeit kann sein, eine Löschanweisung während eines Fehlerausgangs und während eines normalen Ausgangs zu schreiben.

Aber wie kann ich einen intelligenten Zeiger für diese Zeiger verwenden? Mit intelligenten Zeigern meine ich unique_ptr, shared_ptr, etc. was auch immer funktionieren kann!

Danke!

Answer 1

Ich nehme an, Sie können SMOE_STRUCT nicht ändern, um einen Destruktor hinzuzufügen. Damit haben Sie zwei Optionen: einen benutzerdefinierten Löschvorgang und eine Kapselung.

Erstens könnten Sie eine benutzerdefinierte deleter für die Verwendung mit std::unique_ptr erstellen:

struct SOME_STRUCT_Deleter 
{ 
    void operator() (SOME_STRUCT *p) const 
    { 
    delete[] p->SOME_MEMBER; 
    delete p; 
    } 
}; 

std::unique_ptr<SOME_STRUCT, SOME_STRUCT_Deleter> ptr{new SOME_STRUCT}; 
ptr->SOME_MEMBER = new BYTE[100]; 
CallSomeAPI(ptr.get()); 

Wenn Sie feststellen, dass, im Gegensatz zu der Situation in Ihrer Frage beschrieben, Miteigentum Sie passen würde besser als ausschließliches, können Sie die deleter mit einem shared_ptr als auch, wie folgt aus:

std::shared_ptr<SOME_STRUCT> ptr{new SOME_STRUCT, SOME_STRUCT_Deleter{}}; 
ptr->SOME_MEMBER = new BYTE[100]; 
CallSomeAPI(ptr.get()); 

eine zweite Option, die ich bevorzugt zu finden, ist zu wickeln SOME_STRUCT:

struct SOME_STRUCT_plus_plus 
{ 
    SOME_STRUCT s; 
    ~SOME_STRUCT_plus_plus() 
    { 
    delete[] s.SOME_MEMBER; 
    } 

    SOME_STRUCT_plus_plus() 
    { 
    s.SOME_MEMBER = new BYTE[100]; 
    } 
}; 

std::unique_ptr<SOME_STRUCT_plus_plus> ptr{new SOME_STRUCT_plus_plus}; 
CallSomeAPI(&ptr->s); 

Sie könnten sogar „wrap“ es SOME_STRUCT_plus_plus, indem sie stammen aus SOME_STRUCT, anstatt sie zu aggregieren, die Sie ohne die Notwendigkeit, den direkten Zugriff auf Mitglieder durch s gehen würde. Gleichzeitig könnte es zu Speicherlecks kommen, wenn jemand SOME_STRUCT_plus_plus* auf SOME_STRUCT* und dann delete auf ihn wirft.

Answer 2

Sie können einen benutzerdefinierten Deleter für unique_ptr schreiben.

struct my_deleter { 
    void operator()(SOME_STURCT* ptr) const { 
     delete[] ptr->SOME_MEMBER; 
     delete ptr; 
    } 
}; 

using my_ptr = std::unique_ptr<SOME_STRUCT, my_deleter>; 

und ich würde vorschlagen, new SOME_STRUCT; zu new SOME_STRUCT{}; Ändern SOME_MEMBER-nullptr auf Standard zu initialisieren.

Ich bin nicht 100% glücklich mit dieser Lösung, also vielleicht in scope_guard oder schreiben Sie eine Wrapper-Klasse für Ihre Struktur.

Answer 3

Hier, so scheint es, dass alle auf dem Stapel sein kann:

SOME_STRUCT ptr;   // or auto ptr = std::make_unique<SOME_STRUCT>(); 
BYTE bytes[100];   // or std::vector<BYTE> bytes(100); 
ptr.SOME_MEMBER = bytes; // or ptr->SOME_MEMBER = bytes.data(); 
CallSomeAPI(&ptr);  // or CallSomeAPI(ptr.get());