C++windows消息通信

已于 2022-11-18 13:14:44 修改
阅读量856 收藏 4
点赞数
分类专栏： 进程通信 文章标签： c++ windows
于 2022-10-03 11:56:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41489640/article/details/127150591
版权

概述

  • 消息队列是存储在内核中的
  • GUI线程才有消息队列
  • 一开始创建的都是非GUI线程，指向的是SSDT表（Thread.ServiceTable-> KeServiceDescriptorTable）
  • 当线程第一次调用Win32k.sys时，会调用一个函数：PsConvertToGuiThread，我们知道在3环进0环的过程中会取得一个调用号，当调用号在100以下的时候，在ntosknl.exe里面，当调用号大于100则是图形处理函数，调用Win32k.sys
    如果是一个GUI线程，win32Thread指向的就是THREADINFO结构，如果是普通线程，这里就是一个空指针
    底层实现主要看ETHREAD->ServiceTable是指向SSDT还是Shadow SSDT，详细介绍
  • 0x0000-0x03ff(WM_USER-1)为系统定义消息，用户自定义消息范围为0x0400(WM_USER)-0x7fff
  • 进程间消息通信，一般会通过CWnd::FindWindow()找到接收进程的窗口句柄，然后通过PostMessage()发送，接收的UI线程就会按消息进行处理

windows消息机制

消息机制

重要结构体和API说明

内核层对象KTHREAD

typedef struct _KTHREAD
{
     DISPATCHER_HEADER Header;	//说明该对象是一个分发器对象，可以被等待。线程结束时，等待被满足
     UINT64 CycleTime;	
     ULONG HighCycleTime;
     UINT64 QuantumTarget;
     PVOID InitialStack;	//原始栈位置（高地址）
     PVOID StackLimit;		//栈低地址
     PVOID KernelStack;		//内核调用栈开始位置
     ULONG ThreadLock;
     union
     {
          KAPC_STATE ApcState;
          UCHAR ApcStateFill[23];
     };
     CHAR Priority;
     WORD NextProcessor;
     WORD DeferredProcessor;
     ULONG ApcQueueLock;
     ULONG ContextSwitches;
     UCHAR State;
     UCHAR NpxState;
     UCHAR WaitIrql;
     CHAR WaitMode;
     LONG WaitStatus;
     union
     {
          PKWAIT_BLOCK WaitBlockList;
          PKGATE GateObject;
     };
     union
     {
          ULONG KernelStackResident: 1;
          ULONG ReadyTransition: 1;
          ULONG ProcessReadyQueue: 1;
          ULONG WaitNext: 1;
          ULONG SystemAffinityActive: 1;
          ULONG Alertable: 1;
          ULONG GdiFlushActive: 1;
          ULONG Reserved: 25;
          LONG MiscFlags;
     };
     UCHAR WaitReason;
     UCHAR SwapBusy;
     UCHAR Alerted[2];
     union
     {
          LIST_ENTRY WaitListEntry;
          SINGLE_LIST_ENTRY SwapListEntry;
     };
     PKQUEUE Queue;
     ULONG WaitTime;
     union
     {
          struct
          {
               SHORT KernelApcDisable;
               SHORT SpecialApcDisable;
          };
          ULONG CombinedApcDisable;
     };
     PVOID Teb;
     union
     {
          KTIMER Timer;
          UCHAR TimerFill[40];
     };
     union
     {
          ULONG AutoAlignment: 1;
          ULONG DisableBoost: 1;
          ULONG EtwStackTraceApc1Inserted: 1;
          ULONG EtwStackTraceApc2Inserted: 1;
          ULONG CycleChargePending: 1;
          ULONG CalloutActive: 1;
          ULONG ApcQueueable: 1;
          ULONG EnableStackSwap: 1;
          ULONG GuiThread: 1;
          ULONG ReservedFlags: 23;
          LONG ThreadFlags;
     };
     union
     {
          KWAIT_BLOCK WaitBlock[4];
          struct
          {
               UCHAR WaitBlockFill0[23];
               UCHAR IdealProcessor;
          };
          struct
          {
               UCHAR WaitBlockFill1[47];
               CHAR PreviousMode;
          };
          struct
          {
               UCHAR WaitBlockFill2[71];
               UCHAR ResourceIndex;
          };
          UCHAR WaitBlockFill3[95];
     };
     UCHAR LargeStack;
     LIST_ENTRY QueueListEntry;
     PKTRAP_FRAME TrapFrame;
     PVOID FirstArgument;
     union
     {
          PVOID CallbackStack;
          ULONG CallbackDepth;
     };
     PVOID ServiceTable;	/*****************/
     UCHAR ApcStateIndex;
     CHAR BasePriority;
     CHAR PriorityDecrement;
     UCHAR Preempted;
     UCHAR AdjustReason;
     CHAR AdjustIncrement;
     UCHAR Spare01;
     CHAR Saturation;
     ULONG SystemCallNumber;
     ULONG Spare02;
     ULONG UserAffinity;
     PKPROCESS Process;
     ULONG Affinity;
     PKAPC_STATE ApcStatePointer[2];
     union
     {
          KAPC_STATE SavedApcState;
          UCHAR SavedApcStateFill[23];
     };
     CHAR FreezeCount;
     CHAR SuspendCount;
     UCHAR UserIdealProcessor;
     UCHAR Spare03;
     UCHAR Iopl;
     PVOID Win32Thread;		/*****************/
     PVOID StackBase;
     union
     {
          KAPC SuspendApc;
          struct
          {
               UCHAR SuspendApcFill0[1];
               CHAR Spare04;
          };
          struct
          {
               UCHAR SuspendApcFill1[3];
               UCHAR QuantumReset;
          };
          struct
          {
               UCHAR SuspendApcFill2[4];
               ULONG KernelTime;
          };
          struct
          {
               UCHAR SuspendApcFill3[36];
               PKPRCB WaitPrcb;
          };
          struct
          {
               UCHAR SuspendApcFill4[40];
               PVOID LegoData;
          };
          UCHAR SuspendApcFill5[47];
     };
     UCHAR PowerState;
     ULONG UserTime;
     union
     {
          KSEMAPHORE SuspendSemaphore;
          UCHAR SuspendSemaphorefill[20];
     };
     ULONG SListFaultCount;
     LIST_ENTRY ThreadListEntry;
     LIST_ENTRY MutantListHead;
     PVOID SListFaultAddress;
     PVOID MdlForLockedTeb;
} KTHREAD, *PKTHREAD;

/*
Header：说明该对象是一个分发器对象，可以被等待。线程结束时，等待被满足。

MutantListHead：指向一个链表头。链表中包含所有属于该线程的突变体对象（mutant，对应互斥体对象）。

InitialStack：原始栈位置（高地址）

StackLimit：栈低地址

KernelStack：内核调用栈开始位置

StackBase：当前栈的基地址。

ThreadLock：自旋锁，用于保护线程数据成员。

ApcState：KAPC_STATE结构，指定线程的APC信息，包括APC链表，是否有APC正在等待，是否正在处理APC。

ApcQueueable：是否可插入APC

NextProcessor：关于处理器调度的选择。

DeferredProcessor：关于处理器调度的选择。

AdjustReason：优先级调整原因

AdjustIncrement：优先级调整调整量

ApcQueueLock：保护APC队列的自旋锁。

ContextSwitches：记录线程进行了多少次切换。

State：线程当前状态。

NpxState：浮点处理器状态。

Alertable：线程是否可以被唤醒。

WaitNext：

WaitIrql：原先的IRQL。

WaitReason：等待原因

WaitMode：线程等待时的处理器模式，内核or用户

WaitStatus：等待的结果状态。

WaitBlockList：KWAIT_BLOCK为元素的链表，记录线程所有等待的分发器对象。每个分发器对象也有一个KWAIT_BLOCK组成的链表，记录所有等待在该对象的线程。

GateObject：等待的门对象，等待门对象和等待分发器对象不会同时发生。

Priority：动态优先级。

BasePriority：基本优先级。

PriorityDecrement：优先级动态调整过程中的递减值。

Saturation：线程基本优先级调整相对于进程基本优先级是否超过了区间的一半。

EnableStackSwap：内核栈是否准许被换出。

SwapBusy：当前是否正在进程上下文切换。

Alerted：线程在警告模式下是否可以被唤醒。

WaitListEntry：双向链表节点，等待被执行时，作为节点加入某链表

SwapListEntry：单链表节点，内核栈需要被换出时，加入KiStackInSwapListHead为头的链表。另外，线程处于DeferredReady状态时加入DeferredReadyListHead为头的链表。

Queue：队列分发器对象，线程正在处理此队列中的项。

WaitTime：线程进入等待时刻的时间点。

KernelApcDisable/SpecialApcDisable：内核APC和特殊内核APC是否被禁止。

TEB：进程地址空间的一个TEB域

Timer：定时器。

AutoAlignment：与KPROCESS相同

DisableBoost：与KPROCESS相同

WaitBlock：4个KWAIT_BLOCK成员的数组，线程等待的分发器少于4个时，使用这里的空间，不分配新空间。

QueueListEntry：线程处理一个队列项时，加入到队列对象的线程链表中的地址。

TrapFrame：指向KTRAP_FRAME类型的指针。用户保存执行现场。

CallbackStack：线程的回调栈地址，在从内核模式返回用户模式时用。

ServiceTable： 指向系统使用的系统服务表，非GUI线程为KeServiceDescriptorTable，GUI线程为KeServiceDescriptorTableShadow。

IdealProcess：理想处理器

Preempted：是否被高优先级线程抢占了。

ProcessReadyQueue：是否在进程对象的ReadyListHead列表中。

KernelStackResident：线程的内核栈是否驻留在线程中。

Affinity：处理器亲和性，为线程指定的处理器集合必须是该集合的子集。

UserAffinity：线程的用户亲和性。

Process：执行线程的进程对象。

ApcStateIndex：指明当前APC状态在ApcStatePointer域中的索引。

Win32Thread：指向Windows子系统管理的区域的指针。

SuspendApc/SuspendSemaphore：用于支持线程挂起的域。

ThreadListEntry：双链表的节点，线程被创建时，加入到进程的ThreadListHead链表中。

SListFaultAddress：上一次用户模式互锁单链表POP操作发生页面错误的地址。

SuspendSemaphore：与上面有关。
*/

THREADINFO结构体，该结构体拥有4个消息队列，以及一些标志

  1. Sent Message Queue 发送消息队列，储存SendMessage()不同线程时发送来的消息，是一个指针数组
  2. Posted Message Queue 登记消息队列，储存PostMessage()发送来的消息（同线程也进队列），是一个指针数组
  3. Virtualized Input Queue 输入消息队列，接收键盘等虚拟输入信息和系统内部消息队列，是一个指针数组
  4. Reply Message Queue 响应消息队列，不同线程时，发送线程使用SendMessage函数发送信息后线程被挂起，接收线程处理完后返回的信息存放于此，发送线程被唤醒，发送线程从该队列取出返回信息，是一个指针数组
  5. nExitCode:确定线程退出状态，是一个int型，不同数值说明线程处于不同状态
  6. 唤醒标志:判断是否处于唤醒状态

MSG结构

typedef struct tagMSG {
    HWND        hwnd;        //该消息所属的窗口句柄
    UINT        message;    //指定消息的类型
    WPARAM      wParam;        //用于指定消息的附加信息，根据消息不同，代表不同意思
    LPARAM      lParam;        //用于指定消息的附加信息，根据消息不同，代表不同意思
    DWORD       time;        //该消息投递到消息列队当中的时间
    POINT       pt;            //该消息投递到消息列队当时，鼠标的当前位置
} MSG, *PMSG, NEAR *NPMSG, FAR *LPMSG;

API

函数原型：LRESULT SendMessage(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM IParam);
hWnd:指定接收消息的窗口；HWND_BROADCAST，则消息将被发送到系统中所有顶层窗口，包括无效或不可见的非自身拥有的窗口、被覆盖的窗口和弹出式窗口，但消息不被发送到子窗口；NULL直接返回
Msg:发送的消息
wParam:消息wParam参数，附加参1
IParam:消息lParam参数，附加参2

/*接收线程与SendMessage调用线程属于同一线程，阻塞至处理返回
  接收线程与SendMessage调用线程不属于同一线程，消息被投放到send message queue，然后返回*/

LRESULT SendMessageTimeout(
  HWND hWnd,           // 同SendMessage
  UINT Msg,            // 同SendMessage
  WPARAM wParam,       // 同SendMessage
  LPARAM lParam,       // 同SendMessage
  UINT fuFlags,        // 消息发送方式
  /*
  SMTO_ABORTIFHUNG    如果接受进程处于挂起状态，那么此函数将直接返回，超时值无效。
  SMTO_BLOCK    以阻塞方式运行
  SMTO_NORMAL    等待函数返回请安，线程可以正常处理其他请求
  SMTO_NOTIMEOUTIFNOTHUNG    如果接受现成没有挂起，知道超时值，函数才返回
  */
  UINT uTimeout,       // 消息超时值，hWnd为HWND_BROADCAST时，在每个窗口超时之前，该函数不会返回。因此，总等待时间可以高达 uTimeout * 顶级窗口数
  LPDWORD lpdwResult   // 消息处理的结果。 此参数的值取决于指定的消息
);

简单demo

server读：

// Win32Server.cpp : 定义应用程序的入口点。
//

#include "stdafx.h"
#include "Win32Server.h"

#define MAX_LOADSTRING 100
#define MSG_CUSTOM_INFO WM_USER+1


// 全局变量: 
HINSTANCE hInst;                                // 当前实例
WCHAR szTitle[MAX_LOADSTRING];                  // 标题栏文本
WCHAR szWindowClass[MAX_LOADSTRING];            // 主窗口类名

// 此代码模块中包含的函数的前向声明: 
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: 在此放置代码。
	OutputDebugStringW(_T("------start------"));
    // 初始化全局字符串
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_WIN32SERVER, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // 执行应用程序初始化: 
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WIN32SERVER));

    MSG msg;

    // 主消息循环: 
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}



//
//  函数: MyRegisterClass()
//
//  目的: 注册窗口类。
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WIN32SERVER));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_WIN32SERVER);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

//
//   函数: InitInstance(HINSTANCE, int)
//
//   目的: 保存实例句柄并创建主窗口
//
//   注释: 
//
//        在此函数中，我们在全局变量中保存实例句柄并
//        创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // 将实例句柄存储在全局变量中

   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

//
//  函数: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  目的:    处理主窗口的消息。
//
//  WM_COMMAND  - 处理应用程序菜单
//  WM_PAINT    - 绘制主窗口
//  WM_DESTROY  - 发送退出消息并返回
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // 分析菜单选择: 
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);
            // TODO: 在此处添加使用 hdc 的任何绘图代码...
            EndPaint(hWnd, &ps);
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
	case MSG_CUSTOM_INFO:
		OutputDebugStringW(_T("new message"));
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// “关于”框的消息处理程序。
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

client写：

// Win32Client.cpp : 定义应用程序的入口点。
//

#include "stdafx.h"
#include "Win32Client.h"

#define MAX_LOADSTRING 100
#define IDC_BUTTON_CLICK 150
#define MSG_CUSTOM_INFO WM_USER+1
// 全局变量: 
HINSTANCE hInst;                                // 当前实例
WCHAR szTitle[MAX_LOADSTRING];                  // 标题栏文本
WCHAR szWindowClass[MAX_LOADSTRING];            // 主窗口类名

// 此代码模块中包含的函数的前向声明: 
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: 在此放置代码。

    // 初始化全局字符串
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_WIN32CLIENT, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // 执行应用程序初始化: 
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WIN32CLIENT));

    MSG msg;

    // 主消息循环: 
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}


void OnButtonClick()
{
	HWND hWnd = FindWindowW(_T("WIN32SERVER"), _T("Win32Server"));
	PostMessageW(hWnd, MSG_CUSTOM_INFO, 123L, 0);	//post是放入到接收线程的队列，这里123以值传递的方式，因此没问题，如果是该进程的堆空间（new出来的），则会导致问题
	::MessageBox(NULL, L"已发送123456给另一个进程", L"提示", MB_OK);
}

//
//  函数: MyRegisterClass()
//
//  目的: 注册窗口类。
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WIN32CLIENT));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_WIN32CLIENT);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

//
//   函数: InitInstance(HINSTANCE, int)
//
//   目的: 保存实例句柄并创建主窗口
//
//   注释: 
//
//        在此函数中，我们在全局变量中保存实例句柄并
//        创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // 将实例句柄存储在全局变量中

   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd)
   {
      return FALSE;
   }
   CreateWindowW(_T("BUTTON"), _T("Click Me"), WS_CHILD | WS_VISIBLE, 10, 40, 80, 20, hWnd, (HMENU)IDC_BUTTON_CLICK, NULL, NULL);

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

//
//  函数: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  目的:    处理主窗口的消息。
//
//  WM_COMMAND  - 处理应用程序菜单
//  WM_PAINT    - 绘制主窗口
//  WM_DESTROY  - 发送退出消息并返回
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // 分析菜单选择: 
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
			case IDC_BUTTON_CLICK:
				//进入按钮点击事件
				OnButtonClick();
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);
            // TODO: 在此处添加使用 hdc 的任何绘图代码...
            EndPaint(hWnd, &ps);
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// “关于”框的消息处理程序。
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

就是两个win32空的窗口程序，server端跟进程通信相关的有

#define MSG_CUSTOM_INFO WM_USER+1	//通信消息ID
.......
case MSG_CUSTOM_INFO:	//是通信消息ID，输出控制台输出
OutputDebugStringW(_T("new message"));

client端跟进程通信相关的有

void OnButtonClick()
{
	HWND hWnd = FindWindowW(_T("WIN32SERVER"), _T("Win32Server"));	//找到窗口句柄
	PostMessageW(hWnd, MSG_CUSTOM_INFO, 123L, 0);	//post通信消息
	::MessageBox(NULL, L"已发送123456给另一个进程", L"提示", MB_OK);
}
qq_41489640
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c/c++ windows hid串口通信
06-20
c/c++ windows 通过hidsdi进行串口通信 GUID InterfaceClassGuid = { 0x4d1e55b2, 0xf16f, 0x11cf, { 0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30 } }; SP_DEVINFO_DATA devinfo_data; SP_DEVICE_INTERFACE_DATA device_interface_data; SP_DEVICE_INTERFACE_DETAIL_DATA_A* device_interface_detail_data = NULL; HDEVINFO device_info_set = INVALID_HANDLE_VALUE; int device_index = 0; HDEVINFO DeviceInfoSet; DeviceInfoSet = SetupDiCreateDeviceInfoList(NULL, NULL); devinfo_data.cbSize = sizeof(SP_DEVINFO_DATA);
c++程序socket通信使用vs生成的exe文件连接失败原因之一
S^S
07-08 493
c++ socket通信程序生成的exe文件运行时，连接失败.
【C/C++实现进程间通信 二】消息队列
wddkxg的博客
07-01 629
本项目主要用于以消息传递机制的方式进行进程间通信的测试。 1.主要包含PublisherDemo和SubscriberDemo两个子项目，分别用于发送信息和接收信息。 2.在PublisherDemo中，程序通过FindWindow函数查找进程2创建的窗口句柄，并将消息发送到窗口中。 消息的数据部分是一个字符串 3.在SubscriberDemo中，程序首先注册一个窗口类，并创建一个窗口。在窗口过程函数WndProc中，通 过捕获WM_COPYDATA消息来接收消息，
C++ 实现即时通信软件（直接运行）
mitongxue的博客
04-26 6366
题目 由于本学期上了网络编程课程，老师要求写使用Socke实现网络编程。于是参考 C++多线程实现即时通信软件 写出了简单版本的没有界面的即时通信软件。 软件：VS 直接上代码，需要讲解原理的，可以参考 C++多线程实现即时通信软件 服务器端 //TcpServer_plus.exe #include<stdio.h> #include <Winsock2.h> #include<WS2tcpip.h> #pragma comment(lib,"ws2_32.lib")
Windows进程间通信方式
caichengji1的博客
07-15 312
匿名管道(Anonymous Pipe)是 在父进程和子进程之间，或同一父进程的两个子进程之间传输数据的无名字的单向管道。邮件槽与命名管道相似，不过它传输数据是通过不可靠的数据报(如TCP/IP协议中的UDP包)完成的，一旦网络发生错误则无法保证消息正确地接收，而命名管道传输数据则是建立在可靠连接基础上的。不同于匿名管道的是命名管道可以在不相关的进程之间和不同计算机之间使用，服务器建立命名管道时给它指定一个名字，任何进程都可以通过该名字打开管道的另一端，根据给定的权限和服务器进程通信。
PTAWindows消息队列c++版——山东科技大学
scorpion_legend的博客
10-21 905
题目： 消息队列是Windows系统的基础。对于每个进程，系统维护一个消息队列。如果在进程中有特定事件发生，如点击鼠标、文字改变等，系统将把这个消息加到队列当中。同时，如果队列不是空的，这一进程循环地从队列中按照优先级获取消息。请注意优先级值低意味着优先级高。请编辑程序模拟消息队列，将消息加到队列中以及从队列中获取消息。 输入格式: 输入首先给出正整数N（≤1e5），随后N行，每行给出一个指令——GET或PUT，分别表示从队列中取出消息或将消息添加到队列中。如果指令是PUT，后面就有一个消息名称、以及一个正
Windows消息队列及C++应用
飞鹤的程序员人生
10-04 2238
Windows是一个消息驱动的操作系统，消息是用一个常量标识符来标记，并且有两个32Bit的消息附加信息。单击鼠标、敲击键盘，都会通过电脑外设向系统发送特定的中断信号，这个中断信息在操作系统中会转化为一个消息，并存储在系统的一个消息队列中。Windows操作系统会根据当前激活的窗口与鼠标、键盘的操作来决定将消息发给相应的窗口线程。 针对非UI线程，可以通过PostThreadMessage来传消息，但是耦合性高。更方便的方式是通过Hook来直接获取指定窗口的消息。
串口通信（windows C++）全代码
02-21
串行通信口简称串口。美国电子工业协会EIA按电气标准及协议来分，包括RS-232C、RS-422、RS-485、USB等。RS-232、RS-422与RS-485标准只对接口的电气特性作出规定，不涉及接插件、电缆或协议。USB是近几年发展起来的...
Windows下C++串口通信
01-23
windows下c++串口通信，包括串口打开、SCB设定、串口事件设定、收发等
c/c++ windows ble 蓝牙操作
06-20
c/c++ windows 通过winrt操作ble 蓝牙 #include <windows.h> #include #include <winrt/Windows.Foundation.h> #include <winrt/Windows.Foundation.Collections.h> #include <winrt/Windows.Devices.Bluetooth.h...
Windows下的tcp通信
09-17
服务端：建立socket，申明自身port和IP，并绑定到socket，使用listen监听， 然后不断用accept查看是否有连接。...send发送消息，等待处理，通信完成后调用closeSocket关闭socket。 记得先运行server端。
C++ 实现一个消息队列
codeofcc的博客
10-29 9923
消息队列在多线程的场景有时会用到，尤其是线程通信跨线程调用的时候，就可以使用消息队列进行通信。C++实现一个能用的消息队列还是比较简单的，只需要一个队列一个互斥变量和一个条件变量，这些在标准库中都有提供。基于曾经写过的项目，总结出来最简单的消息队列的实现将在下文中介绍。
C#--EXE根据C++动态链接库相互传递消息
wlqyyyyy的博客
07-23 570
C#--EXE根据C++动态链接库相互传递消息首先主程序启动EXE通过SendMessage在两个C#窗体中传递消息在上诉完成的基础上，将启动程序，关闭程序，传递消息全部替换成通过动态链接库来实现合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导
C++进程间通信---自定义消息
~探路者~的博客
12-16 3220
在windows中消息分为两种，即系统消息和用户自定义消息，系统消息定义从0到0x3ff，可以使用0x400到0x7fff定义自己的消息。windows把0x400定义为WM_USER，如果想定义自己的一个消息，可以在WM_USER上加上一个值。当然了，还有另外一种方法，这里就不讲了，而是使用RegisterWindowsMessage()函数。 要想用消息实现进程间通信，则需要在这两个程序中定义
Windows(MFC/C++)上进程间通讯的几种简单又实用的方法
学无止尽，谨言慎行！
05-06 1328
前段时间，做了一个项目，涉及数据传输。项目实现方式有很多种，但不同的实现方式，对数据的传输方法不同，且各有优缺点。下文就不同情况来如何选择数据传输(通讯)方式。先说说需求，模块A获取测试数据，模块B将程序A获取的数据进行画图。
C++ ----调用exe的函数
月秀明竹的专栏
08-09 2000
文章从自己的QQ（632846506）7年前的日志中移过来的。https://user.qzone.qq.com/632846506/infocenter。        在开发大型项目的时候，采取的都是把各个功能分开来开发，分开开发可能是生成dll，也有可能生成的是exe文件，而其中有的时候也会调用现成的工具包里面的一些exe文件，这样在项目里面就要通过调用exe文件来使用。这种相互调用e
C++多进程通信、信号量、内存共享
weixin_43158867的博客
05-11 3799
进程间通信、共享内存传递图片
在c++中调用exe程序进行操作
weixin_30670965的博客
04-21 371
#include <Windows.h> #include <iostream> #include <direct.h> #define picNum 228 using namespace std; void main() { char path[]="d:/vs/scene_text"; if (_chdir...
C++进阶（应用篇）——第二章 进程间的通信
Bing_bing_bing_的博客
09-27 6780
2.进程间的通信 2.1进程 本章讲解windows平台下，进程间的通信方式。 进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动，是操作系统动态执行的基本单元。简单的说，进程就是一段程序的执行过程。 进程和线程：进程是系统动态执行的基本单位，也是系统分配资源的基本单位；线程是进程中执行的最小单位，它可以访问进程的共享资源。 进程之间对共享内存等进行读写操作，需要使用互斥机制...
windows c++20 消息传递
最新发布
12-22
Windows C++消息传递是指在Windows操作系统中，通过发送消息来实现不同窗口之间的通信和交互。消息传递是基于消息队列的机制，每个窗口都有一个消息队列，用于存储待处理的消息。当一个窗口需要发送消息给另一个窗口...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值