C-Pointer in C++ Klasse verwalten

[Steffo]

@manni66 sagte in C-Pointer in C++ Klasse verwalten:

@Steffo sagte in C-Pointer in C++ Klasse verwalten:

Das hatte ich auch schon versucht:

auto* data1 = static_cast<char*>(malloc(1000));
std::memset(data1, '-', 1000);
// std::unique_ptr<char*> u(data1); // Kompiliert nicht
std::unique_ptr<char*> u(&data1);// Speicherzugriffsfehler

Wozu soll das gut sein?

Hi Manni,
das ist nur ein minimales Beispiel für mein oben beschriebenes Problem. Mir würde es wirklich weiterhelfen, wenn mir jemand erklären würde, weshalb der obige Code nicht funktioniert.

[Ein ehemaliger Benutzer]

@Steffo
Wenn man Stackadressen löscht, knallt es halt.

[Mechanics]

@manni66 sagte in C-Pointer in C++ Klasse verwalten:

std::unique_ptr<char*> u(&data1);

Du willst eher
std::unique_ptr<char> u(data1);

[Ein ehemaliger Benutzer]

@Mechanics sagte in C-Pointer in C++ Klasse verwalten:

@manni66 sagte in C-Pointer in C++ Klasse verwalten:

std::unique_ptr<char*> u(&data1);

Du willst eher
std::unique_ptr<char> u(data1);

Ich nicht und er auch nicht (zumindest nicht, wenn der Speicher mit malloc angelegt wurde).

[Mechanics]

"eher"

[Ein ehemaliger Benutzer]

Wenn du den smart pointer mit malloc fütterst musst du den Deleter selbst definieren. Siehe den zweiten Template Parameter von unique_ptr

[hustbaer]

@Steffo sagte in C-Pointer in C++ Klasse verwalten:

Das ist eine C-Schnittstelle und ich habe den Speicher indirekt selbst angefordert.

Ein paar Dinge dazu.

1. delete ptr ist falsch wenn es sich um ein Array handelt, in dem Fall müsstest du delete[] ptr schreiben
2. Wenn der Speicher nicht mit new T[] angefordert wurde, dann sollte er auch nicht mit delete[] ptr gelöscht werden.
3. "Indirekt selbst angefordert" kann alles mögliche heissen. Wenn du den Speicher direkt selbst anforderst, dann ist es OK wenn du ihn selbst löscht - auf welchem Weg sollte dann klar sein anhand dessen wie du ihn angefordert hast. Wenn du den Speicher dagegen von der C Library bekommst, dann musst du in der Dokumentation der C Library nachgucken wie du ihn freigeben sollst.

delete ptr ist aber mit an Sicherheit grenzender Wahrscheinlichkeit falsch.

Davon abgesehen:

• Wrapper(Wrapper &other) = delete; ist OK aber nicht nötig, da du ja bereits einen move-Ctor definierst, und dieser verhindert die implizite Definition eines Copy-Ctors. Weiters ist es unüblich beim Copy-Ctor das const wegzulassen.
• Wrapper(char *data); ist recht ungünstig. Du solltest diesen Ctor explicit machen. Sonst kann man nämlich sowas wie Wrapper w = "trallala"; schreiben. Und das sollte vermutlich eher nicht gehen.
• Was deinen Move-Assignment-Operator angeht: Das kann man einfacher Lösen. Stichwort Copy-and-Swap. (Hat seine ursprünge zwar in Zeiten wo es noch kein Move gab, aber man kann es genau so gut für Move-Assignment verwenden.)

Und p.s.: Ja, über unique_ptr wäre es vermutlich noch einfacher. Die oben genannten Dinge zu beheben wäre aber vermutlich trotzdem eine gute Übung.

[wob]

@Steffo sagte in C-Pointer in C++ Klasse verwalten:

#include <memory>
#include <cstring>

int main() {
    auto* data1 = static_cast<char*>(malloc(1000));
    std::memset(data1, '-', 1000);
    std::unique_ptr<char, decltype(&free)> u(data1, &free);
}

Wenn der Speicher mit malloc angefordert wurde, löscht du mit free. Das geht so wie hier gezeigt.

Wenn du eine andere Funktion für das Freigeben aufrufen musst (die C-Funktionen haben ja gerne eigene Wrapper dafür), dann schau dir am besten das close_file-Beispiel auf https://en.cppreference.com/w/cpp/memory/unique_ptr an.

Nimmst du statt unique_ptr einen shared_ptr, wird es etwas einfacher, weil dann der Typ des Löschers typgelöscht ist (brrr... was ist type erasure auf Deutsch?), d.h. du hast nicht den 2. Template-Parameter.

[Steffo]

Danke, für eure Antworten!
Mein Kollege und ich haben nun eine Lösung mit std::unique_ptr und free gebastelt. Geht in die Richtung der Lösung von @wob.

[camper]

@Steffo sagte in C-Pointer in C++ Klasse verwalten:

Danke, für eure Antworten!
Mein Kollege und ich haben nun eine Lösung mit std::unique_ptr und free gebastelt. Geht in die Richtung der Lösung von @wob.

Hoffentlich mit zustandslosem Funktor statt extra Funktionszeiger, der std::unique_ptr nur unnötig groß macht (und u.U. weniger effizienten Code erzeugt).