WINAPI -我想让消息泵在一个单独的线程中进行

在非main线程上使用消息泵是完全可以的。但是，消息泵必须位于创建窗口的线程上。在您的示例中，这意味着必须从同一个线程调用CreateAWindow和startMessageLoop。

现在，编写消息泵由一个while循环组成，它支配整个程序，不允许执行其他事情

传统的 消息循环可能是这样工作的，但是在消息之间编写一个可以做其他事情的消息循环当然是可能的。谁说你不能用信息本身来做事情。你可能有一个阻塞调用线程的循环，但是你可以控制这个循环在每次迭代中实际做什么，所以它可以代表它的调用线程做一些事情。不需要仅 处理消息。

换句话说，我希望可以创建CFrame的多个实例，以便显示多个窗口，并且消息循环不会在创建第一个窗口后停止窗口。

任何类型的消息循环都可以在同一个线程中处理多个窗口。

我为函数ThreadExecution()创建了一个新线程，由于某种原因程序终止了，为什么?

因为你的窗口管理是完全错误的。您对窗口和线程如何协同工作有一个根本性的误解。您不需要为每个窗口创建一个单独的线程(虽然从技术上讲可以这样做，但是这样做很浪费)。你创建一个线程(或者只使用主线程)来创建多个窗口，然后使用一个消息循环来为它们服务。

试试这样写:

#ifndef CFrameH
#define CFrameH
#include <windows.h>
class Size { // Size of the window
private:
    int width;
    int height;
public:
    Size(int width, int height);
    int getWidth() const;
    int getHeight() const;
};
class CFrame {
private:
    HINSTANCE hInstance;
    Size size;
    HWND hwnd;
    virtual LRESULT WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam);
    static void RegisterDetails(HINSTANCE);
    static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
public:
    CFrame(LPCWSTR title, Size size, HINSTANCE hInstance);
    ~CFrame();
};
#endif

CFrame.cpp

#include "CFrame.h"
static LPCWSTR CLASS_NAME = L"Window Class";
Size::Size(int width, int height)
    : width(width), height(height)
{
}
int Size::getWidth() const {
    return width;
}
int Size::getHeight() const {
    return height;
}
CFrame::CFrame(LPCWSTR title, Size size, HINSTANCE hInstance)
    : size(size), hInstance(hInstance) 
{ 
    RegisterDetails(hInstance);
    hwnd = CreateWindowExW(0, CLASS_NAME, title, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, size.getWidth(), size.getHeight(), NULL, NULL, hInstance, this);
    if (hwnd) {
        ShowWindow(hwnd, SW_SHOW);
    }
}
CFrame::~CFrame()
{ 
    if (hwnd)
        DestroyWindow(hwnd);
}
void CFrame::RegisterDetails(HINSTANCE hInstance) { // Registers WNDCLASS
    WNDCLASSW wc = {};
    BOOL bRegistered = GetClassInfoW(hInstance, CLASS_NAME, &wc);
    if ((!bRegisterd) || (wc.lpfnWndProc != &WindowProc)) {
        if (bRegistered) {
          UnregisterClassW(CLASS_NAME, hInstance);
        }
        wc.lpfnWndProc = &WindowProc;
        wc.hInstance = hInstance;
        wc.lpszClassName = CLASS_NAME;
        RegisterClassW(&wc);
    }
}
LRESULT CALLBACK CFrame::WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    CFrame *pThis;
    if (uMsg == WM_CREATE) {
        pThis = (CFrame*) ((CREATESTRUCT*)lParam)->lpCreateParams;
        SetWindowLongPtr(hwnd, GWL_USERDATA, (LONG_PTR) pThis);
    } else {
        pThis = (CFrame*) GetWindowLongPtr(hwnd, GWL_USERDATA);
    }
    if (pThis)
        return pThis->WndProc(uMsg, wParam, lParam);
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}        
LRESULT CFrame::WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    if (uMsg == WM_NCDESTROY) {
        hwnd = NULL;
    }
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

那么你可以在线程中做这样的事情:

void ThreadExecution(HINSTANCE hInstance) {
    CFrame frame1(L"frame1", Size(10, 10), hInstance);
    CFrame frame2(L"frame2", Size(20, 20), hInstance);
    MSG msg;
    while (...) {
        if (GetMessage(&msg, NULL, 0, 0)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
}

void ThreadExecution(HINSTANCE hInstance) {
    CFrame frame1(L"frame1", Size(10, 10), hInstance);
    CFrame frame2(L"frame2", Size(20, 20), hInstance);
    MSG msg;
    while (...) {
        if (PeekMessage(&msg, NULL, 0, 0)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else {
            // do something else
        }
    }
}

void ThreadExecution(HINSTANCE hInstance) {
    CFrame frame1(L"frame1", Size(10, 10), hInstance);
    CFrame frame2(L"frame2", Size(20, 20), hInstance);
    // array of event/IO objects that are signaled
    // when things needs to be done...
    HANDLE hObjects[...];
    DWORD dwNumObjects = ...;
    ...
    MSG msg;
    while (...) {
        DWORD dwRet = MsgWaitForMultipleObjects(dwNumObjects, hObjects, FALSE, INFINITE, QS_ALLINPUT);
        if ((dwRet >= WAIT_OBJECT_0) && (dwRet < (WAIT_OBJECT_0+dwNumObjects))) {
            dwRet -= WAIT_OBJECT_0;
            // do something with hObjects[dwRet] ...
        }
        else if (dwRet == (WAIT_OBJECT_0+dwNumObjects)) {
            while (PeekMessage(&msg, NULL, 0, 0)) {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        ...
    }
}

你可以移动

<
• 创建窗口/gh>
• 运行消息循环

放入一个方法中，并使用线程来执行这个方法

• std::thread似乎不工作，你需要CreateThread代替

• 当然，你可以把它封装在类中

当你创建游戏API时，也许你可以使用PeekMessage(非块)并做自己的计时器或其他东西?

std::thread似乎不工作，您可以使用CreateThread代替

(简单)示例代码

#define UNICODE
#include <windows.h>
const wchar_t CLASS_NAME[] = L"Window Class";
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
DWORD WINAPI CreateWindowAndRunUseMesageLoop(LPVOID* id){
    WCHAR className[] = L"XCLASSSSS";
    WCHAR title[] = L"XTITLE";
    title[0] = *(WCHAR*)id;
    className[0] = *(WCHAR*)id;
    WNDCLASS wc = {};
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = GetModuleHandle(NULL);
    wc.lpszClassName = className;
    RegisterClass(&wc);
    auto hwnd = CreateWindowEx(0, className, title, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT
        , 300, 300, NULL, NULL, GetModuleHandle(NULL), NULL);
    ShowWindow(hwnd, SW_SHOW);
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return 0;
}
int main(){
    HANDLE handle[2];
    WCHAR i = L'0';
    handle[0] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)CreateWindowAndRunUseMesageLoop, &i, 0, NULL);
    WCHAR j = L'1';
    handle[1] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)CreateWindowAndRunUseMesageLoop, &j, 0, NULL);
    WaitForMultipleObjects(2, handle, TRUE, INFINITE);
}