ich möchte eine Funktion einer C Api benutzen. Als Argument wird die Addresse eines pointers erwartet. Normalerweise wird die Funktion so aufgerufen:

some_type * x;

function(&x);

Ich habe jetzt einen unique_ptr, der mein x verwaltet:

std::unique_ptr<some_type, decltype(&my_deleter)> ptr(x, my_deleter);

Wenn ich jetzt versuche, die Funktion aufzurufen, gibt es einen Fehler:

function(&ptr.get())
//Fehler: Addressoperator auf R-Value angewendet

Das klingt eigentlich nach einem Standardproblem. Gibt es eine Möglichkeit, das als Einzeiler zu lösen? Direkt an den Internen Pointer kommt man ja nicht...

Gutes Argument. Dann halt ohne unique pointer

Und guck dir unbedingt an, was die Funktion überhaupt genau macht. Klingt so, als wäre dir das im Moment selbst nicht so ganz klar.

Ist das eine Art Konstruktor, der dir ein Handle zurück gibt, das du dann in dem unique_ptr speichern möchtest?

//C Api
void do_something(some_type **);

some_type* allocate_some_type(args...);

void delete_some_type(some_type*);

//C++ part - so wollte ich es machen
class Class
{
public:
    unique_ptr<some_type, decltype(&delete_some_type)> ptr;

    Class(args)
        : ptr(allocate_some_type(args), delete_some_type)
    {}
};

// irgendwann speater im code:
Class c(args);
do_sutff( &c.ptr.get() );

// C++ part - so mache ich es jetzt
class Class
{
public:
    some_type* ptr;

    Class(args)
        : ptr(allocate_some_type(args))
    {}
    // freigabe der ressource im Destruktor anstatt ueber unique_ptr
    ~Class() { delete_some_type(ptr); }
}

// irgendwann speater im code:
Class c(args);
do_sutff( &c.ptr );

Ich denke das wird der Aufgabe so gerechet.

Das do_stuff soll doch sicherlich ein Member der Class sein.

Denk bei deiner Lösung ohne unique_ptr an die Regel der großen Drei.

class Class
{
    some_type* ptr = nullptr;

public:
    Class(args)
        : ptr(allocate_some_type(args))
    {}

    // der "Wrapper"
    void print() { do_something(&ptr); }

    // freigabe der ressource im Destruktor anstatt ueber unique_ptr
    ~Class()
    {
        if(ptr)
            delete_some_type(ptr);
    }

    // ist nur eine Uebung. Regel der grossen drei/fuenf nicht wichtig :D
    Class& operator=(const Class&) = delete;
    Class& operator=(Class&&) = delete;
    Class(const Class&) = delete;
    Class(Class&&) = delete;
}

// irgendwann speater im code:
Class c(args);
c.print();

Meinst du so?

Aufgabe ist, den pointer als Member einer C++-Klasse zu machen und mit einem C-Interface zu interagieren.

her würde ich annehmen, dass das so gemeint ist.

PS: Die Regel der großem Drei/Fünf ist immer wichtig, wenn du Ressourcen verwaltest. Das Kopieren zu verbieten, wie du es hier machst, kann eine richtige und sinnvolle Anwendung der Regel sein. Jedenfalls ist es sehr wichtig, dass dein Code die Problematik irgendwie handhabt, sonst kommst du ganz schnell in Probleme.