尝试面向对象
在编写Win32窗口的时候, 创建两个及以上的窗口, 不可避免的需要初始化
WNDCLASS
, 调用
CreateWindow
来获取窗口, 重写
WNDPROC
函数来实现特定的功能, 如果能将以面向对象的思想, 将窗口的共性通过类来表示就能一定程度上简化开发流程, 另外还有一些优势:
- 对一些变量限制访问, 一定程度上能减少对变量的错误操作, 也能实现对变量的访问限制
- 以成员函数的方式, 更能方便的拓展窗口的功能
- 进行一定的抽象, Win32程序的架构更加的清晰
尝试面向对象
窗口的Window Procedure
使用DefWindowProc函数
可以写出一个最简单的Window Procedure函数:
LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
return 0;
}
不过这样写并不能真正使用. 实际上, 这样做的后果就是CreateWindow
1会返回一个NULL
值, 在MSDN查阅CreateWindowExW函数, 可以看到:
This function typically fails for one of the following reasons:
- an invalid parameter value
- the system class was registered by a different module
- The WH_CBT hook is installed and returns a failure code
- if one of the controls in the dialog template is not registered, or its window window procedure fails
WM_CREATE or WM_NCCREATE
其中最有可能的是第四条,窗口的Procedure函数处理WM_CREATE 或者 WM_NCCREATE消息失败了:
If an application processes this message, it should return zero to continue creation of the window.
If the application returns –1, the window is destroyed and the CreateWindowEx or CreateWindow
function returns a NULL handle. ------ WM_CREATE
If an application processes this message, it should return TRUE to continue creation of the window. If
the application returns FALSE, the CreateWindow or CreateWindowEx function will return a NULL
handle. ------ WM_NCCREATE
但是就算是将这两个消息单独拿出来处理, 仍然不能正确显示一个窗口:
LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
if (uMsg == WM_CREATE) return 0;
if (uMsg == WM_NCCREATE) return TRUE;
else return 0;
}
这样做CreateWindow
不会返回NULL
值了, 在任务栏上也能看到窗口, 但是仍然无法在屏幕上看到.
一种编写方式是把每一种会接收到的Windows消息都进行处理, 这样自然不会有问题, 包括WM_CREATE
, WM_NCCREATE
, WM_ACTIVE
, WM_TIMER
, WM_PAINT
, WM_ERASEBKGND
, WM_CLOSE
, WM_POWERBROADCAST
等等, 很多消息都需要处理, 虽然有的很简单, 也许和WM_CREATE
或者WM_NCCREATE
一样, 返回一个值就能正常运行, 但对很多其实并不需要特殊处理的消息, 可以调用DefWindowProc
, 这个函数已经提供了最基础的消息处理:
LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
或者在接收到WM_DESTROY
消息时调用PostQuitMessage
来结束消息循环, 退出程序:
LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
if(uMsg == WM_DESTROY) PostQuitMessage(0);
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
在Window Procedure中处理消息
在一个Window Procedure使用if-else语句时:
LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
if (uMsg == WM_DESTROY) {
PostQuitMessage(0);
return 0;
}
else if (uMsg == WM_CHAR) {
//如果按下空格, ......
if (wParam == ' ') {
//......
return 0;
}
}
else if(uMsg == WM_PAINT){
//绘制窗口
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hwnd, &ps);
//......
EndPaint(hwnd, &ps);
return 0;
}
else if (uMsg == WM_CLOSE) {
if (IDNO == MessageBox(hwnd, TEXT("Quit?"), TEXT("Quit"), MB_YESNO)) {
return 0;
}
}
//else if(......)......
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
或者使用switch语句:
LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
switch (uMsg) {
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_CHAR:
//如果按下空格, ......
if (wParam == ' ') {
//......
return 0;
}
break;
case WM_PAINT:
{
//绘制窗口
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hwnd, &ps);
//......
EndPaint(hwnd, &ps);
}
return 0;
case WM_CLOSE:
if (IDNO == MessageBox(hwnd, TEXT("Quit?"), TEXT("Quit"), MB_YESNO)) {
return 0;
}
break;
//case (......)......
}
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
当窗口功能很多时, 函数可能变得非常大而复杂, 如果能按照对象来调用函数, 使用起来会更简单一些:
LRESULT CALLBACK MyWin::Proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
switch (uMsg) {
case WM_DESTROY:
return this->OnDestroy();
case WM_CHAR:
return this->OnChar(wParam);
case WM_PAINT:
this->OnPaint();
return 0;
case WM_CLOSE:
return this->OnClose();
//case(......)......
}
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
使用CREATESTRUCT
CREATESTRUCT
在调用CreateWindow
时, CreateWindow
宏最终会展开为CreateWindowExA
或者CreateWindowExW
,2 而这两个函数区别不太, 所以这里就引用CreateWindowEx宏:
HWND WINAPI CreateWindowEx(
_In_ DWORD dwExStyle,
_In_opt_ LPCTSTR lpClassName,
_In_opt_ LPCTSTR lpWindowName,
_In_ DWORD dwStyle,
_In_ int x,
_In_ int y,
_In_ int nWidth,
_In_ int nHeight,
_In_opt_ HWND hWndParent,
_In_opt_ HMENU hMenu,
_In_opt_ HINSTANCE hInstance,
_In_opt_ LPVOID lpParam
);
可以看到, 最后的一个形参lpParam
, 它实际上对应WM_CREATE
消息的LPARAM
参数, 不过在WNDPROC
函数中接收的并不是传入的lpParam
, 而是另一个CREATESTRUCTA
/ CREATESTRUCTW
的结构体的指针. CREATESTRUCTA
和 CREATESTRUCTW
同样除了字符串的编码方式之外区别不大, 所以这里引用 CREATESTRUCT
宏:
typedef struct tagCREATESTRUCT {
LPVOID lpCreateParams;
HINSTANCE hInstance;
HMENU hMenu;
HWND hwndParent;
int cy;
int cx;
int y;
int x;
LONG style;
LPCTSTR lpszName;
LPCTSTR lpszClass;
DWORD dwExStyle;
} CREATESTRUCT, *LPCREATESTRUCT;
CREATESTRUCT中的lpCreateParams其实就是创建窗口时传入的lpParam参数.
lpParam参数是个LPVOID
(void*
) 类型, 传入的类型没有限制, 参考MSDN中的说明3, 可以在WNDPROC函数中获取该值, 也可以用它来储存状态, 而不必总在全局声明变量.
typedef struct {
char key;
}StateInfo, *PStateInfo;
//......
StateInfo stateInfo = {' '};
hwnd = CreateWindowExW(
0,
g_wnd_classw.lpszClassName,
L"Main Window",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
NULL, NULL,
g_hInst,
(LPVOID)&stateInfo
);
//.......
case WM_CREATE:
{
LPCREATESTRUCT pCreateStruct = reinterpret_cast<LPCREATESTRUCT>(lParam);
PStateInfo pStateInfo = reinterpret_cast<PStateInfo>(pCreateStruct->lpCreateParams);
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pStateInfo);
}
case WM_CHAR:
{
LONG_PTR ptr = GetWindowLongPtr(hwnd, GWLP_USERDATA);
StateInfo *pStateInfo = reinterpret_cast<StateInfo*>(ptr);
//如果按下key, 就直接退出
if (pStateInfo->key == wParam) {
//......
DestroyWindow(hwnd);
return 0;
}
break;
}
//......
SetWindowLongPtr与GetWindowLongPtr
上述代码中还使用了SetWindowLongPtr4与GetWindowLongPtr这对函数, 它们的作用是将pStateInfo与hwnd所标识的窗口绑定, 并能以hwnd来唯一地取出pStateInfo.
LONG_PTR WINAPI SetWindowLongPtr(
_In_ HWND hWnd,
_In_ int nIndex,
_In_ LONG_PTR dwNewLong
);
SetWindowLongPtr 将dwNewLong存入某个有偏移量nIndex的内存位置, 而这个位置在窗口额外空间中(extra window memory5).
通过pStateInfo来调用
pStateInfo可以接收LPVOID
类型指针, 也就意味着可以实现一个窗口的类, 创建时将自己传入其中:
HINSTANCE g_hInstance;
LRESULT CALLBACK win_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
class MyWin {
public:
MyWin() :m_hwnd(NULL) {}
bool Create(
PCWSTR lpWindowName, DWORD dwStyle, DWORD dwExStyle = 0,
int x = CW_USEDEFAULT, int y = CW_USEDEFAULT,
int nWidth = CW_USEDEFAULT, int nHeight = CW_USEDEFAULT,
HWND hWndParent = 0, HMENU hMenu = 0
) {
WNDCLASS wc = { 0 };
wc.lpfnWndProc = win_proc;
wc.hInstance = g_hInstance;
wc.lpszClassName = L"MyWin Class";
RegisterClass(&wc);
m_hwnd = CreateWindowEx(
dwExStyle, wc.lpszClassName, lpWindowName, dwStyle, x, y,
nWidth, nHeight, hWndParent, hMenu, g_hInstance, this
);
return m_hwnd != NULL;
}
public:
HWND m_hwnd;
LRESULT OnClose() {
if (MessageBox(m_hwnd, L"Quit?", L"Quit", MB_YESNO) == IDYES) DestroyWindow(m_hwnd);
return 0;
}
LRESULT OnDestroy() {
PostQuitMessage(0);
return 0;
}
LRESULT OnPaint() {
PAINTSTRUCT ps;
HDC hdc = BeginPaint(m_hwnd, &ps);
RECT drawRect;
GetClientRect(m_hwnd, &drawRect);
DrawText(hdc, TEXT("HELLO WORLD"),-1, &drawRect,
DT_SINGLELINE | DT_CENTER | DT_VCENTER);
EndPaint(m_hwnd, &ps);
return 0;
}
LRESULT OnCreate() {
}
BOOL Show(int nCmdShow) {
return ShowWindow(m_hwnd, nCmdShow);
}
};
函数指针问题
在编写面向对象的窗口类时, 我有一个一直无法解决的问题, 注册Window Class时需要给lpfnWndProc传入一个WNDPROC类型的函数指针, 但是它不能是成员(非静态的)函数, 也就是说:
LRESULT CALLBACK MyWin::WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam) {
//......
}
即使为lpfnWndProc设计了Window Procedure函数, 也无法传入:
wnd_class.lpfnWndProc = (WNDPROC)this->Proc; //错误, 无法完成对应指针的转换!
参考managing application state的示例实现, 提供了一个思路, 使用模板和静态成员函数, 通过代理的方式调用成员函数类型的Window Procedure.
template <class DERIVED_TYPE>
class BaseWindow
{
public:
static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
DERIVED_TYPE *pThis = NULL;
if (uMsg == WM_NCCREATE)
{
CREATESTRUCT* pCreate = (CREATESTRUCT*)lParam;
pThis = (DERIVED_TYPE*)pCreate->lpCreateParams;
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pThis);
pThis->m_hwnd = hwnd;
}
else
{
pThis = (DERIVED_TYPE*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
}
if (pThis)
{
return pThis->HandleMessage(uMsg, wParam, lParam);
}
else
{
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
}
BOOL Create(
PCWSTR lpWindowName,
DWORD dwStyle,
DWORD dwExStyle = 0,
int x = CW_USEDEFAULT,
int y = CW_USEDEFAULT,
int nWidth = CW_USEDEFAULT,
int nHeight = CW_USEDEFAULT,
HWND hWndParent = 0,
HMENU hMenu = 0
)
{
WNDCLASS wc = {0};
wc.lpfnWndProc = DERIVED_TYPE::WindowProc;
wc.hInstance = GetModuleHandle(NULL);
wc.lpszClassName = ClassName();
//......
}
//......
};
(以上代码引用自managing application state, 删减了部分代码, 详见链接)
通过wc.lpfnWndProc = DERIVED_TYPE::WindowProc;
将对应类型的静态Window Procedure函数DERIVED_TYPE::WindowProc赋值给lpfnWndProc变量, 然后在WindowProc中进行调用pThis->HandleMessage(uMsg, wParam, lParam);
完整代码实现
编写窗口基类
template<typename DerivedType>
class BaseWindow {
typedef DerivedType* PDerivedType;
public:
static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
PDerivedType pCaller = NULL;
if (uMsg == WM_NCCREATE) {
LPCREATESTRUCT lpCreateStruct = reinterpret_cast<LPCREATESTRUCT>(lParam);
pCaller = reinterpret_cast<PDerivedType>(lpCreateStruct->lpCreateParams);
SetWindowLongPtr(hwnd, GWLP_USERDATA,(LONG_PTR) pCaller);
pCaller->m_hwnd = hwnd; //?
}
else {
pCaller = reinterpret_cast<PDerivedType>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
}
if (pCaller) {
switch (uMsg) {
case WM_DESTROY:
{
PAINTSTRUCT ps{};
HDC hdc = ps.hdc;
break;
}
case WM_PAINT:
{
PAINTSTRUCT ps{};
HDC hdc = ps.hdc;
break;
}
}
return pCaller->HandleMessage(uMsg, wParam, lParam);
}
else {
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
}
BaseWindow() :m_hwnd(NULL) {}
BOOL Create(
PCWSTR lpWindowName, DWORD dwStyle, DWORD dwExStyle = 0,
int x = CW_USEDEFAULT, int y = CW_USEDEFAULT,
int nWidth = CW_USEDEFAULT, int nHeight = CW_USEDEFAULT,
HWND hWndParent = 0, HMENU hMenu = 0
) {
WNDCLASS wc = { 0 };
wc.lpfnWndProc = DerivedType::WindowProc;
wc.hInstance = GetModuleHandle(NULL);
wc.lpszClassName = CLASSNAME();
RegisterClass(&wc);
m_hwnd = CreateWindowEx(
dwExStyle, wc.lpszClassName, lpWindowName, dwStyle, x, y,
nWidth, nHeight, hWndParent, hMenu, GetModuleHandle(NULL), this
);
return m_hwnd != NULL ? TRUE:FALSE;
}
HWND GetWindow() { return m_hwnd; }
BOOL ShowWnd(int nCmdShow) {
return ShowWindow(m_hwnd, nCmdShow);
}
BOOL UpdateWnd() {
return UpdateWindow(m_hwnd);
}
protected:
virtual LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) = 0;
virtual PCWSTR CLASSNAME()const = 0;
HWND m_hwnd;
};
简单的面向对象的Win32窗口实现
class SimpleWindow:public BaseWindow<SimpleWindow> {
public:
LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) {
switch (uMsg) {
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_PAINT:
OnPaint();
return 0;
case WM_CLOSE:
return OnClose();
}
return DefWindowProc(m_hwnd, uMsg, wParam, lParam);
}
PCWSTR CLASSNAME()const { return L"simple window class"; };
protected:
void OnPaint() {
PAINTSTRUCT ps;
HDC hdc = BeginPaint(m_hwnd, &ps);
RECT rt;
GetClientRect(m_hwnd, &rt);
DrawText(hdc, L"Hello Window!", -1, &rt, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
EndPaint(m_hwnd, &ps);
}
LRESULT OnClose() {
if (MessageBox(m_hwnd,
L"It will quit the Window, Continue?", L"Quit Tip", MB_YESNO
) == IDYES) {
DestroyWindow(m_hwnd);
}
return 0;
}
};
入口函数编写
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR lpCmdLine, int nCmdShow) {
SimpleWindow smpWin;
if (FALSE == smpWin.Create(L"Simple Window-A", WS_OVERLAPPEDWINDOW) ) return -1;
smpWin.ShowWnd(nCmdShow);
smpWin.UpdateWnd();
MSG msg;
while (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return 0;
}
https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-createwindowexw ↩︎
WinUser.h ↩︎
https://docs.microsoft.com/en-us/windows/win32/learnwin32/managing-application-state- ↩︎
https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-setwindowlongptra?redirectedfrom=MSDN ↩︎
https://docs.microsoft.com/en-us/windows/win32/winmsg/about-window-classes#extra-class-memory ↩︎