ich habe folgendes Problem. Ich habe eine (okay sind mehrere) Klassen mit denen ich die Strukturen der WinAPI etwas "erweitern" wollte. Da ich jedoch auch Platformübergreifend bleiben will, leite ich diese nicht von den WinAPI Strukturen ab.

Zum setzen (eher konvertieren der Struktur in die für die Windowsfunktionen verständliche Strukturen) habe ich einen Operator geschrieben, das geht auch mehr als nur wunderbar!

Jedoch benötige ich nun einen Operator zum holen der Daten. Doch dort weiß ich nicht mehr weiter. Zur not geh ich da mit einem reinterpret_cast ran, doch das ist nicht das wahre

Hat jemand eine Idee wie ich das machen kann ohne die Klasse zu vererben von den WinAPO Grunstrukturen?

Hier schon mal was code:

#include <iostream>
#include <windows.h>

class point
{
public:
    point (long x, long y) : x(x), y(y) {}

        // Operator zum Setzen auf POINT
    inline operator POINT (void)
    {
        POINT pt = {x, y};
        return pt;
    }

    long x, y;
};

int main (void)
{
    point pt (0,0);

    GetCursorPos (reinterpret_cast<POINT*>(&pt)); // Kann man hierfür keinen Operator schreiben, wenn ja? WIE?

    return 0;
}

Schau lieber noch mal im google ob es sowas überhaupt gibt

So hab ich das schlüsselwort operator noch nie benutzt.
So weit ich weis ist das nur zum überladen bereits vorhandener operatoren.

Schau lieber noch mal im google ob es sowas überhaupt gibt

Man kann mittels operator implizite Typkonvertierung anbieten, wie im Code oben demonstriert, allerdings wird von deren Verwendung in den meisten Fällen abgeraten, da sie nicht unerhebliche Probleme mit sich bringen.

@'#': Den reinterpret_cast kannst du im Prinzip in einen ähnlichen Operator auslagern:

operator POINT* (void)
{
  return (reinterpret_cast <POINT*> (this));
}

Allerdings offenbart sich mir noch nicht der Sinn deines Anliegens. Ein reinterpret_cast ist jedenfalls nicht die Lösung für Plattformunabhängigkeit, auch wenn es in diesem Fall problemlos funktionieren dürfte. In den meisten anderen Fällen sollten solche Klassen, die einfach Windows-Strukturen wrappen, nicht wesentlich zur Plattformunabhängigkeit beitragen, denn ich möchte mal bezweifeln, daß es zu allen WinAPI-Strukturen unter anderen Betriebssysteme gleichwertige Pendants gibt.

das mit der platformunabhängigkeit lassen wir mal links liegen, mir geht es nur darum ob sowas geht ohne einen cast.

Das geht, wenn du in deiner Klasse eine Variable des Typs POINT deklarierst, auf die du dann einen Zeiger zurückgeben kannst:

class point
{
    POINT p;
public:
    point (long x, long y) : x(x), y(y) {}

    operator POINT* (void)
    {
        return &p;
    }
};

Allerdings ist die Lösung nicht sehr sauber, da du 1. dem Benutzer deiner Klasse direkten Zugriff auf klasseninterne Daten gewährst und 2. eine implizite Typkonvertierung verwendest.

Point MyGetCursorPos()
{
    POINT point;
    GetCursorPos(&point);
    return Point(point);
}

ergo gibt es keine sauberere lösung als ein reinterpret_cast?

Ich hab doch eine gepostet!

ergo gibt es keine sauberere lösung als ein reinterpret_cast?

Naja, du könntest ja den unären op & überladen. Bekommst dann damit aber kein point* mehr.
Grundsätzlich ist es korrekt, dass dort ein Cast steht. Auch wenn dir das vielleicht nicht gefällt. POINT und point sind nunmal zwei unterschiedliche Typen. Deshalb verweisen POINT* und point* auch auf unterschiedliche Objekte. Implizite Umwandlungen führen bei solchen Sachen nicht selten zu unschönen Fallstricken und ist daher nicht zu empfehlen. Mach dir deshalb keine Gedanken, wie du den Cast wegbekommst, sondern versuche sinnvoll zu kapseln, damit du nicht immer den Cast schreben musst. Ein Beispiel wurde ja schon gepostet.