Windows消息机制学习笔记（三）—— 消息的接收与分发

最新推荐文章于 2023-09-05 22:53:23 发布
最新推荐文章于 2023-09-05 22:53:23 发布
阅读量1k 收藏 2
点赞数 2
分类专栏： x86内核 文章标签： Windows 消息机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41988448/article/details/118073912
版权

Windows消息机制学习笔记（三）—— 消息的接收与分发

要点回顾

1）一个GUI线程包含一个消息队列

普通线程
↓
GUI线程
↓
THEWAD.W32THREAD
↓
THREADINFO
↓
消息队列

2）一个线程可以包含多个窗口，所有窗口共享一个消息队列

_WINDOW_OBJECT		//0环创建
↓
PTHREADINFO pti		//所属线程
↓
WNDPROC lpfnWndProc	//窗口过程（窗口回调函数）

消息循环

MSG msg;
while(GetMessage(&msg, NULL, 0, 0))	//从消息队列中取出消息
{
	TranslateMessage(&msg);	//加工消息
	DispatchMessage(&msg);	//分发消息
}

思考：使用SendMessage与PostMessage发送的消息位于同一组队列中吗？
答案：不同类型的消息被置于不同队列。

消息队列

描述：消息队列共有七组，用于存放不同类型的消息。
例如：

1）SentMessagesListHead		//接收SendMessage发来的消息
2）PostedMessagesListHead	//接收PostMessage发来的消息
3）HardwareMessagesListHead	//接收键盘、鼠标等硬件设备的消息
...

完整队列：

//ReactOS v3.12
typedef struct _USER_MESSAGE_QUEUE
{
	...
	/* Owner of the message queue */
	struct _ETHREAD *Thread;
	/* Queue of messages sent to the queue. */
	LIST_ENTRY SentMessagesListHead;
	/* Queue of messages posted to the queue. */
	LIST_ENTRY PostedMessagesListHead;
	/* Queue of sent-message notifies for the queue. */
	LIST_ENTRY NotifyMessagesListHead;
	/* Queue for hardware messages for the queue. */
	LIST_ENTRY HardwareMessagesListHead;
	...
	/* messages that are currently dispatched by other threads */
	LIST_ENTRY DispatchingMessagesHead;
	/* messages that are currently dispatched by this message queue, required for cleanup */
	LIST_ENTRY LocalDispatchingMessagesHead;
	...
}

消息的接收

GetMessage

描述：从消息队列中取出消息

BOOL WINAPI GetMessage(
	LPMSG lpMsg,	//返回从队列中取出的消息
	HWND hWnd,		//过滤条件一：窗口句柄
	UINT wMsgFilterMin,	//过滤条件二：最小值
	UINT wMsgFilterMax	//过滤条件三：最大值
);

主要功能：循环判断是否存在属于该窗口的消息，若存在，则将消息存储到MSG指定的结构中，并将消息从列表中删除。

注意：事实上，GetMessage还做了一件很重要的事情，即在接收消息时，将SentMessagesListHead中的消息进行处理

大致流程：

User32!GetMessage
↓
w32k!NtUsrGetMessage
↓
do
{
	//先判断SentMessagesListHead中是否存在消息，若存在则进行处理
	do
	{
		...
		KeUserModeCallback(USER32_CALLBACK_WINDOWPROC,
			Arguments,
			ArgumentLength,
			&ResultPinter,
			&ResultLength);
		...
	}
}while(SentMessagesListHead != NULL)

源码（ReactOS v3.12）：

BOOL APIENTRY
NtUserGetMessage( PNTUSERGETMESSAGEINFO UnsafeInfo,
                  HWND hWnd,
                  UINT MsgFilterMin,
                  UINT MsgFilterMax )
{
   ...

   do
   {
      GotMessage = co_IntPeekMessage(&Msg, Window, MsgFilterMin, MsgFilterMax, PM_REMOVE);
      ...
   }while (! GotMessage);	//对应外层循环

   ...
}

BOOL FASTCALL
co_IntPeekMessage( PUSER_MESSAGE Msg,
                   PWINDOW_OBJECT Window,
                   UINT MsgFilterMin,
                   UINT MsgFilterMax,
                   UINT RemoveMsg )
{
   ...

   /* Dispatch sent messages here. */
   while (co_MsqDispatchOneSentMessage(ThreadQueue));	//对应内层循环

   ...
}

BOOLEAN FASTCALL
co_MsqDispatchOneSentMessage(PUSER_MESSAGE_QUEUE MessageQueue)
{
   ...

   if (Message->HookMessage == MSQ_ISHOOK)
   {
      ...
   }
   else if (Message->HookMessage == MSQ_ISEVENT)
   {
      ...
   }
   else
   {
      /* 发送消息 */
      Result = co_IntSendMessage(Message->Msg.hwnd,
                                 Message->Msg.message,
                                 Message->Msg.wParam,
                                 Message->Msg.lParam);
   }
   
   /* 从消息队列中删除该消息 */
   RemoveEntryList(&Message->ListEntry);

   ...
   
   /* 调用回调函数 */
   if (Message->CompletionCallback != NULL)
   {
      co_IntCallSentMessageCallback(Message->CompletionCallback,
                                    Message->Msg.hwnd,
                                    Message->Msg.message,
                                    Message->CompletionCallbackContext,
                                    Result);
   }

   ...
}

VOID APIENTRY
co_IntCallSentMessageCallback(SENDASYNCPROC CompletionCallback,
                              HWND hWnd,
                              UINT Msg,
                              ULONG_PTR CompletionCallbackContext,
                              LRESULT Result)
{
   ...

   /* 回到三环进行处理 */
   Status = KeUserModeCallback(USER32_CALLBACK_SENDASYNCPROC,
                               &Arguments,
                               sizeof(SENDASYNCPROC_CALLBACK_ARGUMENTS),
                               &ResultPointer,
                               &ResultLength);

   ...
}

实验1：理解GetMessage

第一步：编译并运行程序A
#include <windows.h>

LRESULT CALLBACK WindowProc(
	IN HWND hwnd,
	IN UINT uMsg,
	IN WPARAM wParam,
	IN LPARAM lParam
){
	switch(uMsg)
	{
	case 0x401:
		MessageBoxA(NULL, "测试窗口接收到消息", "新消息", MB_OK);
		return false;
	}
	
	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}


int APIENTRY WinMain(
	HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPSTR lpCmdLine,
	int nShowCmd
){
	//窗口的类名
	TCHAR className[] = "My First Window";

	//创建一个自己的窗口
	WNDCLASS wndclass = {0};
	wndclass.hbrBackground = (HBRUSH)COLOR_MENU;
	wndclass.lpfnWndProc = WindowProc;
	wndclass.lpszClassName = className;
	wndclass.hInstance = hInstance;

	//注册
	RegisterClass(&wndclass);

	//创建窗口
	HWND hwnd = CreateWindow(
		className,
		TEXT("测试窗口"),
		WS_OVERLAPPEDWINDOW,
		10,
		10,
		600,
		300,
		NULL,
		NULL,
		hInstance,
		NULL);
	
	if(hwnd == NULL)
		return 0;
	
	//显示窗口
	ShowWindow(hwnd, SW_SHOW);
	
	//消息循环
	MSG msg;
	while(GetMessage(&msg, NULL, 0, 0))
	{
		//TranslateMessage(&msg);
		//DispatchMessage(&msg);
	}
	
	return 0;
}

运行结果：
在这里插入图片描述
注意：不要关闭窗口

第二步：编译并运行程序B
#include <stdio.h>
#include <windows.h>

int main()
{
	HWND hwnd = FindWindow("My First Window", "测试窗口");
	SendMessage(hwnd, 0x401, 0, 0);
	
	return 0;
}

运行结果：
在这里插入图片描述

同步与异步

描述：

  1. 使用SendMessage发送消息时，会等待消息处理之后再返回，这个过程称为同步。
  2. 使用PostMessage发送消息时，不会等待消息处理，直接返回，这种方式称为异步。

实验2：理解同步与异步

第一步：编译并运行实验1中的程序A

运行结果：
在这里插入图片描述

第二步：编译并运行实验1中的程序B

在return处设置断点：
在这里插入图片描述运行结果：
在这里插入图片描述此时，程序B并未继续向下执行。

第三步：点击确定按钮

执行结果：
在这里插入图片描述程序A处理消息后，程序B继续向下执行。

第四步：修改程序B的代码，再次运行

新代码：

#include <stdio.h>
#include <windows.h>

int main()
{
	HWND hwnd = FindWindow("My First Window", "测试窗口");
	PostMessage(hwnd, 0x401, 0, 0);		//SendMessage改为PostMessage
	
	return 0;
}

执行结果：
在这里插入图片描述程序B发送消息后未等待目标处理继续向下执行，程序A并未处理消息。

消息的分发

描述：GetMessage能够处理SentMessagesListHead队列中的消息，其他队列中的消息则由DispatchMessage进行分发处理。

大致流程：

  1. 根据窗口句柄找到窗口对象。
  2. 根据窗口对象得到窗口过程函数，由0环进行调用。

源码（ReactOS v3.12）：

LRESULT APIENTRY
NtUserDispatchMessage(PMSG UnsafeMsgInfo)
{
  ...
  
  if (!Hit) Res = IntDispatchMessage(&SafeMsg);

  ...
}

LRESULT
FASTCALL
IntDispatchMessage(PMSG pMsg)
{
  ...
  
  retval = co_IntCallWindowProc( Window->Wnd->lpfnWndProc,
                                !Window->Wnd->Unicode,
                                 pMsg->hwnd,
                                 pMsg->message,
                                 pMsg->wParam,
                                 lParamPacked,
                                 lParamBufferSize);

  ...
}

LRESULT APIENTRY
co_IntCallWindowProc(WNDPROC Proc,
                     BOOLEAN IsAnsiProc,
                     HWND Wnd,
                     UINT Message,
                     WPARAM wParam,
                     LPARAM lParam,
                     INT lParamBufferSize)
{
   ...

   /* 回到三环，调用窗口过程函数 */
   Status = KeUserModeCallback(USER32_CALLBACK_WINDOWPROC,
                               Arguments,
                               ArgumentLength,
                               &ResultPointer,
                               &ResultLength);

   ...
}

DispatchMessage

描述：用于消息分发，根据窗口句柄调用相关的窗口过程，通常用于分发由GetMessage函数检索到的消息。

LRESULT DispatchMessage(
  CONST MSG *lpmsg   // message information
);

思考：为什么DispatchMessage要对消息进行分发而不统一处理？
答案：所有窗口共享一个消息队列，且每个窗口都拥有属于自己的回调函数。

MSG结构体成员：

typedef struct tagMSG {
  HWND   hwnd;		//窗口句柄
  UINT   message; 
  WPARAM wParam; 
  LPARAM lParam; 
  DWORD  time; 
  POINT  pt; 
} MSG, *PMSG;

DispatchMessage根据MSG->hwnd调用各句柄对应窗口对象的回调函数。

思考：既然GetMessage已经得到了句柄信息，为什么不能直接调用对应的回调函数而需要分发。
答案：因为句柄指向的是句柄表，而不是窗口对象，需要进入0环通过句柄表找到窗口对象，才能调用对应的回调函数。

实验3：理解DispatchMessage

第一步：编译并运行以下代码
#include <stdio.h>
#include <windows.h>

LRESULT CALLBACK WindowProc(
	IN HWND hwnd,
	IN UINT uMsg,
	IN WPARAM wParam,
	IN LPARAM lParam
){

	switch(uMsg)
	{
	case 0x401:
		{
			MessageBoxA(NULL, "测试窗口接收到消息", "新消息", MB_OK);
			return 0;
		}
	case WM_DESTROY:
		{
			ExitProcess(0);
			return 0;
		}
	}
	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}


int APIENTRY WinMain(
	HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPSTR lpCmdLine,
	int nShowCmd
){
	//窗口的类名
	TCHAR className[] = "My First Window";

	//创建一个自己的窗口
	WNDCLASS wndclass = {0};
	wndclass.hbrBackground = (HBRUSH)COLOR_MENU;
	wndclass.lpfnWndProc = WindowProc;
	wndclass.lpszClassName = className;
	wndclass.hInstance = hInstance;

	//注册
	RegisterClass(&wndclass);

	//创建窗口
	HWND hwnd = CreateWindow(
		className,
		TEXT("测试窗口"),
		WS_OVERLAPPEDWINDOW,
		10,
		10,
		600,
		300,
		NULL,
		NULL,
		hInstance,
		NULL);
	
	if(hwnd == NULL)
		return 0;
	
	//显示窗口
	ShowWindow(hwnd, SW_SHOW);
	
	//消息循环
	MSG msg;
	while(GetMessage(&msg, NULL, 0, 0))
	{
		//TranslateMessage(&msg);
		//DispatchMessage(&msg);
	}
	
	return 0;
}

运行结果：
在这里插入图片描述

第二步：操作窗口

拖动窗口、点击最小化、缩放、关闭按钮均无反应。

第三步：去掉DispatchMessage注释，重新运行
MSG msg;
while(GetMessage(&msg, NULL, 0, 0))
{
	//TranslateMessage(&msg);
	DispatchMessage(&msg);
}
第四步：再次操作窗口

拖动窗口、点击最小化、缩放、关闭按钮均得到相应。

TranslateMessage

描述：用于将虚拟键码转换为字符消息。该字符消息又被发送给对应线程（调用TranslateMessage的线程）的消息队列，当线程再次调用GetMessage函数或PeekMessage函数获取消息的时候被读取。

实验4：理解TranslateMessage

第一步：编译并运行以下代码
#include <stdio.h>
#include <windows.h>

LRESULT CALLBACK WindowProc(
	IN HWND hwnd,
	IN UINT uMsg,
	IN WPARAM wParam,
	IN LPARAM lParam
){
	TCHAR szBuffer[MAX_PATH];

	switch(uMsg)
	{
	/*
	case WM_KEYDOWN:
		{
			sprintf(szBuffer, "键%d被你按下了\x00", wParam);
			MessageBox(NULL, szBuffer, "WM_KEYDOWN", MB_OK);
			return 0;
		}
	*/
	case WM_CHAR:
		{
			sprintf(szBuffer, "你按下了%c键\x00", wParam);
			MessageBox(NULL, szBuffer, "WM_CHAR", MB_OK);
			return 0;
		}
	
	}
	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}


int APIENTRY WinMain(
	HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPSTR lpCmdLine,
	int nShowCmd
){
	//窗口的类名
	TCHAR className[] = "My First Window";

	//创建一个自己的窗口
	WNDCLASS wndclass = {0};
	wndclass.hbrBackground = (HBRUSH)COLOR_MENU;
	wndclass.lpfnWndProc = WindowProc;
	wndclass.lpszClassName = className;
	wndclass.hInstance = hInstance;

	//注册
	RegisterClass(&wndclass);

	//创建窗口
	HWND hwnd = CreateWindow(
		className,
		TEXT("测试窗口"),
		WS_OVERLAPPEDWINDOW,
		10,
		10,
		600,
		300,
		NULL,
		NULL,
		hInstance,
		NULL);
	
	if(hwnd == NULL)
		return 0;
	
	//显示窗口
	ShowWindow(hwnd, SW_SHOW);
	
	//消息循环
	MSG msg;
	while(GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	
	return 0;
}

运行结果：
在这里插入图片描述

第二步：敲击不同按键

1）小写模式，按下"A"：
在这里插入图片描述
2）按下大小写键，切换到大写模式：
无弹窗

3）大写模式，按下”A“：
在这里插入图片描述
4）按下shift键：
无弹窗

5）小写模式，按下shift+“A”：
在这里插入图片描述

第三步：修改代码并重新运行程序

新代码：

#include <stdio.h>
#include <windows.h>

LRESULT CALLBACK WindowProc(
	IN HWND hwnd,
	IN UINT uMsg,
	IN WPARAM wParam,
	IN LPARAM lParam
){
	TCHAR szBuffer[MAX_PATH];

	switch(uMsg)
	{
	case WM_KEYDOWN:
		{
			sprintf(szBuffer, "键%d被你按下了\x00", wParam);
			MessageBox(NULL, szBuffer, "WM_KEYDOWN", MB_OK);
			return 0;
		}
	/*
	case WM_CHAR:
		{
			sprintf(szBuffer, "你按下了%c键\x00", wParam);
			MessageBox(NULL, szBuffer, "WM_CHAR", MB_OK);
			return 0;
		}
	*/
	}

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


int APIENTRY WinMain(
	HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPSTR lpCmdLine,
	int nShowCmd
){
	//窗口的类名
	TCHAR className[] = "My First Window";

	//创建一个自己的窗口
	WNDCLASS wndclass = {0};
	wndclass.hbrBackground = (HBRUSH)COLOR_MENU;
	wndclass.lpfnWndProc = WindowProc;
	wndclass.lpszClassName = className;
	wndclass.hInstance = hInstance;

	//注册
	RegisterClass(&wndclass);

	//创建窗口
	HWND hwnd = CreateWindow(
		className,
		TEXT("测试窗口"),
		WS_OVERLAPPEDWINDOW,
		10,
		10,
		600,
		300,
		NULL,
		NULL,
		hInstance,
		NULL);
	
	if(hwnd == NULL)
		return 0;
	
	//显示窗口
	ShowWindow(hwnd, SW_SHOW);
	
	//消息循环
	MSG msg;
	while(GetMessage(&msg, NULL, 0, 0))
	{
		//TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	
	return 0;
}

运行结果：
在这里插入图片描述

第四步：敲击不同按键

1）小写模式，按下"A"：
在这里插入图片描述2）按下大小写键，切换到大写模式：
在这里插入图片描述
3）大写模式，按下”A“：
在这里插入图片描述
4）按下shift键：
在这里插入图片描述

总结

  1. GetMessage的不止能够取出消息，还能够处理消息。
  2. GetMessage处理消息时，从0环回到3环调用窗口过程函数进行处理。
  3. SendMessage发送消息后会等待目标处理完毕，PostMessage不会。
  4. GetMessage只会处理SentMessagesListHead列表中的消息。
  5. DispatchMessage的作用是分发除了SentMessagesListHead队列以外的消息给各窗口对象进行处理。
  6. TranslateMessage只处理键盘消息，将虚拟键码转换为字符消息，再由DispatchMessage进行分发。
  7. 未经过TranslateMessage处理的键盘消息，虚拟键码由WM_KEYDOWN进行处理；经过TranslateMessage处理的键盘消息，字符消息由WM_CHAR进行处理
lzyddf
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入解析Windows窗口创建和消息分发
文洲的专栏
04-17 1万+
在纯粹的Window32 SDK编程时代，人们还可以搞懂整个Windows窗体创建和消息的流通过程，但是在现在各种框架的包装下很多在Window32 SDK下很明显易懂的东西显得不是那么简单了。本文力图去繁求简，教你看懂所有框架的基本构造，希望看完本文，再去看常见的MFC/WTL等框架时，不会再觉得有任何的不适。
关于windows消息的派发
代码改变世界的专栏
10-22 615
while(GetMessage(&msg,NULL,0,0))//从消息队列中取消息      {            TranslateMessage (&msg);              //转换消息            DispatchMessage (&msg);               //派发消息     } 对于以上结构，写过windows程序的都应该熟悉，其
关于Windows消息的发送和接收入门
jgwei的专栏
08-24 1181
关于Windows消息的发送和接收入门  1.     发送消息 PostMessage  函数功能：该函数将一个消息放入（寄送）到与指定窗口创建的线程相联系消息队列里，不等待线程处理消息就返回，是异步消息模式。  消息队列里的消息通过调用GetMessage和PeekMessage取得。  函数原型：  B00L PostMessage（HWND hWnd, UINT Msg, WP
windows 发送消息 投递消息
lljlkjh的博客
09-05 250
【代码】windows 发送消息 投递消息。
SSM实战项目——Java高并发秒杀API，详细流程+学习笔记
12-27
SSM实战项目——Java高并发秒杀API是一个深入学习Java后端开发的重要实践，它涵盖了Spring、SpringMVC和MyBatis三大框架的整合应用，以及如何处理高并发下的秒杀场景。在这个项目中，我们将深入理解如何设计并实现一...
SSM实战项目——Java高并发秒杀API，详细流程+学习笔记.zip
最新发布
01-14
这个Java实战项目提供了详细的步骤和学习笔记，涵盖了从需求分析、架构设计到代码实现的全过程，是提升Java并发编程和分布式系统设计能力的宝贵资源。通过实际操作，你可以深入了解SSM框架的使用以及在高并发场景下...
ActiveMQ学习笔记(二) JMS与Spring
04-07
在本篇ActiveMQ学习笔记中，我们将探讨JMS（Java Message Service）与Spring框架的集成。JMS是一种标准API，用于在分布式环境中进行异步消息传递，而Spring框架则为开发人员提供了强大的依赖注入和管理服务的能力。...
redis源码阅读笔记(10)——事件
04-23
在Redis源码阅读笔记(10)——事件中，我们将探讨Redis如何利用事件模型来实现非阻塞I/O，以及相关的编程模型如Reactor模式和NIO。 Redis使用了一个基于epoll的事件处理器，epoll是Linux系统提供的一种高效I/O多路...
Android学习笔记
12-21
在Android学习笔记中，作者分享了自己深入学习Android开发的过程，旨在帮助初学者构建系统性的学习路径，并通过实践提升技能。Android是一种广泛应用于移动设备的操作系统，由Google主导开发，支持丰富的应用程序...
windows多线程同步--信号量
JustDoIT
04-05 501
windows多线程同步--信号量
[Windows]主线程与子线程之间互发消息并相互响应[含可运行代码]
白浅星
05-30 2396
这是本人今天写的一个关于主线程和子线程交换消息的具体实例。 不仅可以直接运行，也写上了较为详细的注解，希望这对你们有帮助。 注意：线程可以用CreatThread来创建，也可以用更为安全的_beginthreadex创建 在这里的C++只是用于文字输出，如果你习惯于使用C++，也能用C++11标准所支持thread来创建线程。 本文多个实例皆用CreatThread来演示消息传递，但实际使用还请使用_beginthreadex或C++的thread。 主要函数如下：(消息传递需要) 使用GetMessa.
windows message manager
飞鸟的专栏
08-31 1519
SendMessage窗口过程函数的调用有两个入口，一个是自己的线程给自己窗口发通知，这样直接调用内部函数进行调用，使用IntCallMessageProc来调用函数，另一种方式是转换用户消息为内核消息，调用NtUserMessageCall来传递消息。LRESULT WINAPI SendMessageW(HWND Wnd, UINT Msg, WPARAM wParam
reactos操作系统实现(174)
大坡3D软件开发
01-02 2370
DispatchMessage函数主要分发一个消息给窗口处理函数。具体实现代码如下：#001  LRESULT WINAPI#002  DispatchMessageW(CONST MSG *lpmsg)#003  {#004      LRESULT Ret = 0;#005      PWINDOW Wnd;#006   检查是否有窗口，如果有窗口，再判断窗
windows消息分发机制
苏生-苏米沿的专栏
04-25 4002
在TObject类中，有一个Dispatch()方法和一个DefaultHandler()方法，它们都是与消息分发机制相关的。Dispatch()负责将特定的消息分发给合适的消息处理函数。首先它会在对象本身类型的类中寻找该消息的处理函数，如果找到，则调用它；如果没有找到而该类覆盖了TObject的DefaultHandler()，则调用该类的DefaultHandler()；如果两者都不存在，则继
C语言 爱心代码（颜色可改）
热门推荐
SunNang的博客
12-18 3万+
代码： #include<stdio.h> #include <windows.h> #include<tchar.h> int main() { system("color 2");//这里修改颜色码 double x,y,a; for(y=1.5;y>-1.5;y-=0.1214) { for(x=-1.5;x<1.5;x+=0.05) { a=x*x+y*y-1;
数据流向示例(获取、分发、存储、分析、入库)
weixin_33826268的博客
09-11 1263
2019独角兽企业重金招聘Python工程师标准>>> ...
Windows程序设计笔记
11-22
在学习和实践Windows程序设计的过程中，有一系列的知识点需要掌握和理解。 首先，掌握主窗口和子窗口的创建、显示和销毁方法是非常重要的。通过注册窗口类和创建窗口实例，可以创建一个主窗口并在屏幕上显示。同时...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值