Objektorientiertes C++ win32?

Question

Ich möchte meine eigene Klasse erstellen, um Fenster und die Fensterprozedur zu erstellen, aber ich habe bemerkt, dass die Fensterprozedur statisch sein muss! Ich frage mich jetzt, ob es möglich ist, die Fensterprozedur objektorientiert zu machen? Ich habe ein paar Tutorials über objektorientierte Fenster gelesen, aber sie machen die Prozedur immer statisch - was ist der Nutzen darin? :/

Alle Links oder Informationen darüber, wie dieses Problem erkannt,

dank

Answer 1

können Sie umgehen, dass die statische WndProc alles delegieren, indem sie an die Mitglieder:

// Forward declarations 
class MyWindowClass; 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) 

std::map<HWND, MyWindowClass *> windowMap; 

// Your class 
class MyWindowClass { 
private: 
    HWND m_handle; 

    // The member WndProc 
    LRESULT MyWndProc(UINT message, WPARAM wParam, LPARAM lParam) { /* ... */ } 

public: 
    MyWindowClass() 
    { 
    /* TODO: Create the window here and assign its handle to m_handle */ 
    /* Pass &WndProc as the pointer to the Window procedure */ 

    // Register the window 
    windowMap[m_handle] = this; 
    } 
}; 

// The delegating WndProc 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) 
{ 
    std::map<HWND, MyWindowClass *>::iterator it = windowMap.find(hWnd); 
    if (it != windowMap.end()) 
    return it->second->MyWndProc(message, wParam, lParam); 
    return 0; 
} 

Answer 2

Wenn Sie objektorientierte Win32-API suchen, dann sollten Sie auf MFC und/oder WTL aussehen würde zu bekommen.

Answer 3

Sie können das WindowProc-Fensterhandle verwenden, um ein Objekt, das Sie für dieses bestimmte Fenster erstellt haben, zu übernehmen und die Ereignisbehandlung an dieses Objekt zu delegieren.

z.B.

IMyWindowInterface* pWnd = getMyWindowObject(hWnd); 
pWnd->ProcessMessage(uMsg, wParam, lParam); 

Answer 4

Die allgemeine Technik ein Fenster Instanz ermöglicht, indem sie als Klasseninstanz dargestellt werden soll, Gebrauch machen SetWindowLongPtr und GetWindowLongPtr, um den Klasseninstanzzeiger mit dem Fensterhandle zu verknüpfen. Unten finden Sie einen Beispielcode, mit dem Sie beginnen können. Es kann nicht ohne ein paar Optimierungen kompilieren. Es soll nur eine Referenz sein.

Ich persönlich habe vor ein paar Jahren aufgehört, meine eigenen Fensterklassen zu erstellen, als ich ATLs CWindow- und CWindowImpl-Vorlagenklasse entdeckte. Sie kümmern sich darum, all diese alltägliche Kodierung für Sie zu tun, und können sich darauf konzentrieren, nur Methoden zu schreiben, die Fenstermeldungen verarbeiten. Siehe den Beispielcode, den ich geschrieben habe here.

Hoffe, das hilft.

class CYourWindowClass 
{ 
private: 
    HWND m_hwnd; 

public: 
    LRESULT WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam) 
    { 
     switch (uMsg) 
     { 
      case WM_CREATE: return OnCreate(wParam, lParam); 
      case wM_PAINT: return OnPaint(wParam, lParam); 
      case WM_DESTROY: 
      { 
       SetWindowLongPtr(m_hwnd, GWLP_USERDATA, NULL); 
       m_hwnd = NULL; 
       return 0; 
      } 
     } 
     return DefWindowProc(m_hwnd, uMsg, wParam, lParam); 

    } 

    CYourWindowClass() 
    { 
     m_hwnd = NULL; 
    } 

    ~CYourWindowClass() 
    { 
     ASSERT(m_hwnd == NULL && "You forgot to destroy your window!"); 
     if (m_hwnd) 
     { 
      SetWindowLong(m_hwnd, GWLP_USERDATA, 0); 
     } 
    } 

    bool Create(...) // add whatever parameters you want 
    { 
     HWND hwnd = CreateWindow("Your Window Class Name", "Your Window title", dwStyle, x, y, width, height, NULL, hMenu, g_hInstance, (LPARAM)this); 
     if (hwnd == NULL) 
      return false; 

     ASSERT(m_hwnd == hwnd); 
     return true; 
    } 


    static LRESULT __stdcall StaticWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) 
    { 
     CYourWindowClass* pWindow = (CYourWindowClass*)GetWindowLongPtr(hwnd, GWLP_USERDATA); 

     if (uMsg == WM_CREATE) 
     { 
      pWindow = ((CREATESTRUCT*)lParam)->lpCreateParams; 
      SetWindowLongPtr(hwnd, GWLP_USERDATA, (void*)pWindow); 
      m_hWnd = hwnd; 
     } 

     if (pWindow != NULL) 
     { 
      return pWindow->WndProc(uMsg, wParam, lParam); 
     } 

     return DefWindowProc(hwnd, uMsg, wParam, lParam); 
    }; 


}; 

Answer 5

Nur um Brians Antwort hinzuzufügen, aber für einen win32-Framework, das auf Win32++ mehr Anfänger freundlich einen Blick ist. Die Bibliothek selbst ist im Vergleich zu MFC oder QT nicht so umfangreich in den Funktionen, aber das ist ein Kompromiss, den der Designer zu Beginn gemacht hat, um die Bibliothek einfach zu verstehen und einfach zu verwenden.

Wenn Sie immer noch an diesem Thema interessiert sind, empfehlen wir Ihnen, einen Blick darauf zu werfen, da es noch eine andere Technik zum Speichern des "This" -Zeichens durch lokalen Threadspeicher verwendet.