1
2
3
4
5

char x = '中';	//使用拓展ASCII编码
wchar_t x1 = L'中';	//L指宽字符Unicode编码

char x[] = "中国";    //A
wchar_t x1[] = L"中国";  //W

1
2
3

setlocale(LC_ALL, "");	//默认本地操作系统地域
printf("%s\n", x);	//使用控制台默认编码
wprintf(L"%s\n", x1);	//默认使用英文，可通过setlocale修改地域

1
2

strlen(x);	//取得多字符编码字符串长度
wcslen(x1);	//取得宽字符编码字符串长度

1
2
3
4
5
6

char x[] = "china";
char x1[] = "123";
strcpy(x, x1);
wchar_t y[] = L"中国";
wchar_t y1[] = L"好";
wcscpy(y, y1);

1
2
3
4
5
6
7
8

C	-- Win32
char -- CHAR	//F12可跟进查看类型
wchar_t -- WCHAR
宏 -- TCHAR	//若当前项目设置为ASCII编码，则相当于CHAR；若为Unicode编码，则相当于WCHAR，在Win32中推荐使用
	//用法
CHAR cha[] = "中国";
WCHAR chw[] = L"中国";
TCHAR cht[] = TEXT("中国");

1
2
3
4
5
6
7

PSTR(LPSTR)	//指向多字节字符串
PWSTR(LPWSTR)	//指向宽字符串
宏 -- PTSTR(LPTSTR)
	//用法
PSTR pszC = "China";
PWSTR pszWC = L"china";
PTSTR pszTC = TEXT("china");

1
2
3

MessageBoxA(0, "多字节", "标题", MB_OK);
MessageBoxW(0, L"宽字符", L"标题", MB_OK);
MessageBox(0, TEXT("内容"), TEXT("标题"), MB_OK);

1
2
3

WCHAR strTitle[] = L"Title";
WCHAR strContent[] = L"Hello World!";
MessageBoxW(0, strContent, strTitle, MB_OK);

1
2
3
4
5
6

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <windows.h>

// 使用 OutputDebugString 输出调试信息
void PrintDebugMessage(LPCWSTR message) {
    OutputDebugString(message);  // 在调试器输出窗口显示
    // OutputDebugString(L"Debug message\n"); // 示例
}

// 带格式化输出
void PrintDebugFormat(LPCWSTR format, ...) {
    wchar_t buffer[256];
    va_list args;
    va_start(args, format);
    vswprintf_s(buffer, 256, format, args);
    va_end(args);
    OutputDebugString(buffer);
}

// 使用示例：
PrintDebugFormat(L"鼠标位置: X=%d, Y=%d\n", xPos, yPos);

1
2
3
4
5

#include <Windows.h>
#include <cstdarg>
#include <string>
void __cdecl outputStringF(_In_z_ _Printf_format_string_ const char* format, ...);
void __cdecl outputStringWF(_In_z_ _Printf_format_string_ const wchar_t* format, ...);

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111

#include "outputstr.h"
void __cdecl outputStringF(_In_z_ _Printf_format_string_ const char* format, ...)
{
    // 使用栈内存避免分配开销（小消息更高效）
    char stackBuffer[512];
    char* dynamicBuffer = nullptr;
    char* bufferPtr = stackBuffer;
    const size_t maxSize = sizeof(stackBuffer);

    va_list args;
    va_start(args, format);

    // 尝试在栈缓冲区格式化
    int result = _vsnprintf_s(stackBuffer, maxSize, _TRUNCATE, format, args);

    // 若栈空间不足，动态分配内存
    if (result < 0) {
        va_end(args);
        va_start(args, format);

        // 获取实际需要的大小
        result = _vscprintf(format, args);
        if (result <= 0) {
            va_end(args);
            OutputDebugStringA("outputStringF: format error\n");
            return;
        }

        const size_t neededSize = static_cast<size_t>(result) + 2; // +换行符+空终止
        dynamicBuffer = static_cast<char*>(malloc(neededSize));
        if (!dynamicBuffer) {
            va_end(args);
            OutputDebugStringA("outputStringF: memory allocation failed\n");
            return;
        }

        _vsnprintf_s(dynamicBuffer, neededSize, _TRUNCATE, format, args);
        bufferPtr = dynamicBuffer;
    }
    va_end(args);

    // 确保添加换行符（安全版）
    const size_t len = strlen(bufferPtr);
    if (len < (maxSize - 1)) {
        bufferPtr[len] = '\n';
        bufferPtr[len + 1] = '\0';
    }
    else {
        // 若已满则替换最后一个字符
        bufferPtr[maxSize - 2] = '\n';
        bufferPtr[maxSize - 1] = '\0';
    }

    OutputDebugStringA(bufferPtr);

    if (dynamicBuffer) {
        free(dynamicBuffer);
    }
}
void __cdecl outputStringWF(_In_z_ _Printf_format_string_ const wchar_t* format, ...)
{
    wchar_t stackBuffer[512];
    wchar_t* dynamicBuffer = nullptr;
    wchar_t* bufferPtr = stackBuffer;
    const size_t maxSize = _countof(stackBuffer);

    va_list args;
    va_start(args, format);

    int result = _vsnwprintf_s(stackBuffer, maxSize, _TRUNCATE, format, args);

    if (result < 0) {
        va_end(args);
        va_start(args, format);

        result = _vscwprintf(format, args);
        if (result <= 0) {
            va_end(args);
            OutputDebugStringW(L"outputStringWF: format error\n");
            return;
        }

        const size_t neededSize = static_cast<size_t>(result) + 2;
        dynamicBuffer = static_cast<wchar_t*>(malloc(neededSize * sizeof(wchar_t)));
        if (!dynamicBuffer) {
            va_end(args);
            OutputDebugStringW(L"outputStringWF: memory allocation failed\n");
            return;
        }

        _vsnwprintf_s(dynamicBuffer, neededSize, _TRUNCATE, format, args);
        bufferPtr = dynamicBuffer;
    }
    va_end(args);

    const size_t len = wcslen(bufferPtr);
    if (len < (maxSize - 1)) {
        bufferPtr[len] = L'\n';
        bufferPtr[len + 1] = L'\0';
    }
    else {
        bufferPtr[maxSize - 2] = L'\n';
        bufferPtr[maxSize - 1] = L'\0';
    }

    OutputDebugStringW(bufferPtr);

    if (dynamicBuffer) {
        free(dynamicBuffer);
    }
}

1
2

outputStringF("Debug message2, %x\n", &wndclass);
outputStringWF(L"Debug message, %x\n", &wndclass);

1
2

MessageBox((HWND)1, 0, 0, 0);
DWORD erro = GetLastError();	//将改代码放在错误语句的后面，在其后设置断点，F5运行到断点，鼠标放在erro上查看错误值

1
2
3
4
5
6
7
8

typedef struct tagMAG {
    HWND hwnd;	//窗口句柄
    UNIT message;	//消息类型
    WPARAM wParam;
    LPARAM lParam;
    DWORD time;	//事件什么时候发生
    POINT pt;	//坐标（鼠标位置）
} MSG, *PMSG;

1
2
3
4
5
6
7

//#define CALLBACK	__stdcall
int CALLBACK WinMain(_In_ HINSTANCE hInstance,	//当前实例句柄
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow) {
                     return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

typedef struct tagWNDCLASS {
    UINT      style;          // 窗口类的样式
    WNDPROC   lpfnWndProc;    // 指向窗口过程函数的指针
    int       cbClsExtra;     // 附加的类内存
    int       cbWndExtra;     // 附加的窗口内存
    HINSTANCE hInstance;      // 拥有该类的实例句柄
    HICON     hIcon;          // 类图标的句柄
    HCURSOR   hCursor;        // 类光标的句柄
    HBRUSH    hbrBackground;  // 类背景画刷的句柄
    LPCTSTR   lpszMenuName;   // 菜单资源的名称
    LPCTSTR   lpszClassName;  // 窗口类的名称
} WNDCLASS, *PWNDCLASS;

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103

#include <Windows.h>
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);	//声明窗口过程函数
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow) {
    //定义并注册窗口类
    TCHAR CLASS_NAME[] = L"MyFisrtWindowC";
    WNDCLASS wndclass = { 0 };	//若不初始化所有成员则无法创建
    wndclass.hbrBackground = (HBRUSH)COLOR_MENU;    //背景色
    wndclass.lpfnWndProc = WindowProc;  //事件触发时由该函数处理(窗口过程函数)
    wndclass.lpszClassName = CLASS_NAME; //窗口类名
    wndclass.hInstance = hInstance; //当前窗口绑定的应用程序(当前实例)
    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW); // 箭头光标

    RegisterClass(&wndclass);  //注册窗口类

    //创建窗口
    HWND hwnd = CreateWindowEx(
        0,                      // 扩展样式
        CLASS_NAME,             // 注册的类名
        L"我的Win32窗口",        // 窗口标题
        WS_OVERLAPPEDWINDOW,    // 窗口样式
        // 位置和大小
        CW_USEDEFAULT, CW_USEDEFAULT,
        400, 300,
        NULL,       // 父窗口句柄
        NULL,       // 菜单
        hInstance,  // 实例句柄
        NULL        // 附加数据
    );
    if (hwnd == NULL) return 0;

    //显示窗口
    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    //消息循环
    MSG msg = { 0 };
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return 0;
}
//实现窗口过程函数(回调函数)
LRESULT CALLBACK WindowProc(
    HWND hwnd,        // 窗口句柄
    UINT uMsg,        // 消息类型
    WPARAM wParam,    // 附加信息
    LPARAM lParam)    // 附加信息
{
    switch (uMsg) {
    case WM_CREATE: {
        CREATESTRUCT* p = (CREATESTRUCT*)lParam;
        //PrintDebugFormat(L"WM_CREATE: %xh\nWM_CREATE: %s\n", uMsg, p->lpszClass);
        return 0;
    }
    case WM_MOVE: {
        DWORD x = (int)(short)LOWORD(lParam);   // horizontal position 
        DWORD y = (int)(short)HIWORD(lParam);   // vertical position
        //PrintDebugFormat(L"WM_MOVE: %xh, x: %d, y: %d\n", uMsg, x, y);
        return 0;
    }
    case WM_SIZE: {
        DWORD w = (int)(short)LOWORD(lParam);
        DWORD h = (int)(short)HIWORD(lParam);
        //PrintDebugFormat(L"WM_SIZE: %xh, size_v: %d, wide: %d, high: %d\n", uMsg, wParam, w, h);
        return 0;
    }
        // 处理关闭消息
    case WM_DESTROY: {
        PrintDebugFormat(L"WM_DESTROY: %xh\n", uMsg);
        PostQuitMessage(0);  // 退出消息循环
        return 0;
    }
    case WM_KEYUP: {
        PrintDebugFormat(L"WM_KEYUP: %xh\t\tw l: %d %d\n", uMsg, wParam, lParam);
        return 0;
    }
    case WM_KEYDOWN: {
        PrintDebugFormat(L"WM_KEYDOWN: %xh\tw l: %d %d\n", uMsg, wParam, lParam);
        return 0;
    }
    case WM_LBUTTONDOWN: {
        PrintDebugFormat(L"WM_LBUTTONDOWN: %xh\tw l: %d %d\n", uMsg, wParam, lParam);
        return 0;
    }
        // 处理绘制消息
    case WM_PAINT: {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hwnd, &ps);
        // 在此处绘制内容（例如文字）
        TextOut(hdc, 50, 50, L"Hello, Win32!", 13);
        EndPaint(hwnd, &ps);
        return 0;
    }
        // 默认处理其他消息
    default:
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

void CreateButton(HWND hwnd) {
    HWND hwndPushButton = CreateWindow(
        TEXT("button"), //系统定义的Button类
        TEXT("普通按钮"),	//按钮名称
        WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_DEFPUSHBUTTON,	//窗口样式
        10, 10,		//x, y
        80, 20,		//w, h
        hwnd,		//父窗口句柄，这里是前面创建的窗口
        (HMENU)1001,	//子窗口ID
        hInst,		//实例句柄（当前WinMain句柄）
        NULL
    );
    TCHAR szBuffer[0x20];
    GetClassName(hwndPushButton, szBuffer, 0x20);	//查看当前窗口句柄的类名，存在szBuffer中
    WNDCLASS wc;
    GetClassInfo(hInst, szBuffer, &wc);	//得到当前窗口类地址
    PrintDebugFormat(L"-->%s\n-->%x\n", wc.lpszClassName, wc.lpfnWndProc);
    HWND hwndCheckBox = CreateWindow(
        TEXT("button"),
        TEXT("复选框"),
        WS_CHILD | WS_VISIBLE | BS_CHECKBOX | BS_AUTOCHECKBOX,
        10, 40,
        80, 20,
        hwnd,
        (HMENU)1002,
        hInst,
        NULL
    );
    HWND hwndRadio = CreateWindow(
        TEXT("button"),
        TEXT("单选按钮"),
        WS_CHILD | WS_VISIBLE | BS_RADIOBUTTON,
        10, 70,
        80, 20,
        hwnd,
        (HMENU)1003,
        hInst,
        NULL
    );
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

case WM_COMMAND: {
    switch (LOWORD(wParam)) {	//LOWORD(wParam) -> 子窗口ID
    case 1001:
        MessageBox(hwnd, L"Button1", L"Demo", MB_OK);
        return 0;
    case 1002:
        MessageBox(hwnd, L"Button2", L"Demo", MB_OK);
        return 0;
    case 1003:
        MessageBox(hwnd, L"Button3", L"Demo", MB_OK);
        return 0;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

// 对话框过程函数
INT_PTR CALLBACK DialogProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
        // 对话框初始化
    case WM_INITDIALOG: {
        // 设置对话框图标
        HICON hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_WIN32DIALOG));
        SendMessage(hDlg, WM_SETICON, ICON_BIG, (LPARAM)hIcon);

        // 初始化控件
        SetDlgItemText(hDlg, IDC_STATIC, L"欢迎使用 Win32 对话框");

        // 设置按钮文本
        SetDlgItemText(hDlg, IDOK, L"确定(&O)");
        SetDlgItemText(hDlg, IDCANCEL, L"取消(&C)");

        // 设置编辑框提示文本
        SetDlgItemText(hDlg, IDC_EDIT_NAME, L"请输入姓名");

        // 初始化进度条
        HWND hProgress = GetDlgItem(hDlg, IDC_PROGRESS);
        //SendMessage(hProgress, PBM_SETRANGE, 0, MAKELPARAM(0, 100));
        //SendMessage(hProgress, PBM_SETPOS, 50, 0);

        return TRUE;
    }

                      // 命令处理
    case WM_COMMAND: {
        WORD id = LOWORD(wParam);
        WORD event = HIWORD(wParam);

        switch (id) {
            // 确定按钮
        case IDOK: {
            // 获取编辑框内容
            wchar_t name[100];
            GetDlgItemText(hDlg, IDC_EDIT_NAME, name, ARRAYSIZE(name));

            // 显示消息框
            wchar_t message[256];
            swprintf(message, ARRAYSIZE(message),
                L"您好，%s！\n感谢使用本对话框",
                wcslen(name) > 0 ? name : L"用户");

            MessageBox(hDlg, message, L"问候", MB_ICONINFORMATION);

            // 关闭对话框
            EndDialog(hDlg, IDOK);
            return TRUE;
        }

                 // 取消按钮
        case IDCANCEL:
            EndDialog(hDlg, IDCANCEL);
            return TRUE;

                      // 退出菜单项
        case IDM_EXIT:
            EndDialog(hDlg, IDCANCEL);
            return TRUE;
        }
        break;
    }

                   // 绘制对话框背景
    case WM_CTLCOLORDLG: {
        static HBRUSH hBrush = NULL;
        if (hBrush == NULL) {
            hBrush = CreateSolidBrush(RGB(240, 245, 255)); // 浅蓝色背景
        }
        return (INT_PTR)hBrush;
    }

                       // 关闭对话框
    case WM_CLOSE:
        EndDialog(hDlg, IDCANCEL);
        return TRUE;
    }

    return FALSE;
}

1

DialogBox(), DialogBoxParam(), CreateDialog(), CreateDialogParam()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

BOOL CALLBACK DialogProc(
    HWND hwndDlg,	//handle to dialog box
    UINT uMsg,		//message
    WPARAM wParam,	//first message parameter
    LPARAM lParam	//second message parameter
) {
    switch (uMsg) {
    case WM_INITDIALOG:
        return TRUE;
    case WM_COMMAND: {
        switch (LOWORD(wParam)) {
        case IDOK: {
            //获取文本框的句柄
            HWND hEditUser = GetDlgItem(hwndDlg, IDC_EDIT1);
            HWND hEditPwd = GetDlgItem(hwndDlg, IDC_EDIT2);
            //通过句柄得到内容
            TCHAR szUserBuffer[0x50];
            TCHAR szPwdBuffer[0x50];
            GetWindowText(hEditUser, szUserBuffer, 0x50);
            GetWindowText(hEditPwd, szPwdBuffer, 0x50);
            return TRUE;
        }
        case IDCANCEL:
            EndDialog(hwndDlg, IDCANCEL);
            return TRUE;
        }
        break;
    }
    case WM_CLOSE:
        EndDialog(hwndDlg, IDCANCEL);   //关闭对话框
        return TRUE;
    }
    return FALSE;
}

1

DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, DialogProc);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

INT_PTR CALLBACK DialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_COMMAND:
        if (LOWORD(wParam) == IDC_BUTTON1) // 按钮ID
        {
            MessageBox(hDlg, L"按钮被点击！", L"提示", MB_OK);
            return (INT_PTR)TRUE;
        }
        break;
    case WM_CLOSE:
        EndDialog(hDlg, 0);
        return (INT_PTR)TRUE;
    }
    return (INT_PTR)FALSE;
}

1

DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, DialogProc);

1
2

HICON hIcon;
hIcon = LoadIcon(hwndDlg, MAKEINTRESOURCE(IDI_ICON1));	//句柄，图标编号

1
2
3
4

case WM_INITDIALOG:
HICON hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICON1));
SendMessage(hwndDlg, WM_SETICON, IDI_ICON1, (DWORD)hIcon);
return TRUE;

1
2
3
4
5
6
7
8

HANDLE CreateThread(	//返回值：线程句柄
  LPSECURITY_ATTRIBUTES   lpThreadAttributes, // 安全属性（通常为 NULL）
  SIZE_T                  dwStackSize,        // 堆栈大小（0=默认）
  LPTHREAD_START_ROUTINE  lpStartAddress,     // 线程函数指针
  LPVOID                  lpParameter,        // 传递给线程的参数
  DWORD                   dwCreationFlags,    // 创建标志（0=立即运行）
  LPDWORD                 lpThreadId          // 接收线程ID（可 NULL）
);

1

DWORD WINAPI ThreadFunction(LPVOID lpParam);

1
2
3
4

DWORD WaitForSingleObject(
  HANDLE hHandle,        // 线程句柄
  DWORD  dwMilliseconds   // 超时时间（INFINITE=无限等待）
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include <iostream>
#include <windows.h>
using namespace std;
HANDLE hThread;
DWORD WINAPI ThreadFunction(LPVOID lpParam) {
    // 使用参数（可选）
    int threadId = (int)(INT_PTR)lpParam;
    for (int i = 0; i < 1000; i++) {
        Sleep(1000);
        printf("Thread %d: +++++++++++++\n", threadId);
    }
    return 0;
}
void MyThread() {
    DWORD threadId;
    hThread = CreateThread(		//线程句柄
        NULL,           // 安全属性
        0,              // 堆栈大小（默认）
        ThreadFunction, // 线程函数指针
        (LPVOID)(INT_PTR)1, // 传递给线程的参数（这里也可以用全局变量传）
        0,              // 创建标志（立即运行）
        &threadId       // 接收线程ID
    );
    if (hThread == NULL) {
        cerr << "CreateThread failed! Error: " << GetLastError() << endl;
    }
}
int main() {
    MyThread();
    // 主线程工作
    for (int i = 0; i < 1000; i++) {
        Sleep(1000);
        printf("Main thread: -----------------\n");
    }
    // 等待所有线程完成（实际项目中需要实现）
    if (hThread) {
        WaitForSingleObject(hThread, INFINITE);
        ::CloseHandle(hThread);		//若用"::"代表是全局函数，而不是类成员
        hThread = NULL;
    }
    // 这里简单等待足够长时间让线程完成
    Sleep(1000 * 1000);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include "framework.h"
#include "Win32线程窗口.h"
#include <stdio.h>
HINSTANCE hInst;
HWND hEdit;
HANDLE hThread;
DWORD WINAPI Timer(LPVOID lpParam) {
    TCHAR szBuffer[20] = { 0 };
    GetWindowText(hEdit, szBuffer, 20); //获取文本框内容
    DWORD dwTime;
    swscanf_s(szBuffer, L"%d", &dwTime);    //字符串转整数函数
    while (dwTime > 0) {
        memset(szBuffer, 0, 20);
        Sleep(100);
        swprintf_s(szBuffer, L"%d", --dwTime);  //整数转字符串函数
        SetWindowText(hEdit, szBuffer);
    }
    return 0;
}
INT_PTR CALLBACK DialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
    switch (message) {
    case WM_INITDIALOG: {   //初始化Dialog
        hEdit = GetDlgItem(hDlg, IDC_EDIT1);    //得到资源句柄
        SetWindowText(hEdit, L"1000");  //设置文本框内容
        break;
    }
    case WM_COMMAND:
        if (LOWORD(wParam) == IDC_BUTTON1) {    // 按钮ID
            //MessageBox(hDlg, L"按钮被点击！", L"提示", MB_OK);
            hThread = CreateThread(NULL, 0, Timer, (LPVOID)(INT_PTR)1, 0, 0);
            return (INT_PTR)TRUE;
        }
        break;
    case WM_CLOSE:
        EndDialog(hDlg, 0);
        return (INT_PTR)TRUE;
    }
    return (INT_PTR)FALSE;
}
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow) {
    DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, DialogProc);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

#include "framework.h"
#include "Win32线程窗口.h"
#include <stdio.h>
HINSTANCE hInst;
HWND hEdit;
HANDLE hThread;
DWORD WINAPI ThreadProc1(LPVOID lpParam) {
    TCHAR szBuffer[20] = { 0 };
    DWORD dwIndex = 0;
    DWORD dwCount;
    while (dwIndex < 100) {
        //if (dwIndex == 10) ExitThread(2);
        GetWindowText(hEdit, szBuffer, 20);
        swscanf_s(szBuffer, L"%d", &dwCount);
        memset(szBuffer, 0, 20);
        Sleep(100);
        swprintf_s(szBuffer, L"%d", ++dwCount);
        SetWindowText(hEdit, szBuffer);
        dwIndex++;
    }
    return 0;
}
INT_PTR CALLBACK DialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
    switch (message) {
    case WM_INITDIALOG: {   //初始化Dialog
        hEdit = GetDlgItem(hDlg, IDC_EDIT1);    //得到资源句柄
        SetWindowText(hEdit, L"0");  //设置文本框内容
        break;
    }
    case WM_COMMAND:
        switch (LOWORD(wParam)) {
        case IDC_BUTTON1: {
            hThread = CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
            return true;
        }
        case IDC_BUTTON2: {
            SuspendThread(hThread);     //挂起线程：不分配cpu
            return true;
        }
        case IDC_BUTTON3: {
            ResumeThread(hThread);      //恢复线程：重新分配cpu
            return true;
        }
        case IDC_BUTTON4: {
            TerminateThread(hThread, 2);
            WaitForSingleObject(hThread, INFINITE);
            return true;
        }
        }
        break;
    case WM_CLOSE:
        EndDialog(hDlg, 0);
        return (INT_PTR)TRUE;
    }
    return (INT_PTR)FALSE;
}
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow) {
    DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, DialogProc);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

typedef struct _CONTEXT {
    DWORD ContextFlags;  // 标志位，指定哪些寄存器有效

    // 调试寄存器
    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;

    // 浮点寄存器
    FLOATING_SAVE_AREA FloatSave;

    // 段寄存器
    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;

    // 通用寄存器
    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;

    // 控制寄存器
    DWORD Ebp;
    DWORD Eip;      // 指令指针
    DWORD SegCs;
    DWORD EFlags;   // 标志寄存器
    DWORD Esp;      // 栈指针
    DWORD SegSs;
    
    // 扩展寄存器（如XMM等）
    BYTE ExtendedRegisters[MAXIMUM_SUPPORTED_EXTENSION];
} CONTEXT;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

HANDLE hThread = ...; // 线程句柄
CONTEXT ctx = {0};
ctx.ContextFlags = CONTEXT_FULL; // 指定要获取的寄存器组
// 必须先挂起线程
SuspendThread(hThread);
if(GetThreadContext(hThread, &ctx)) {
    printf("当前EIP: 0x%08X\n", ctx.Eip);
    printf("当前ESP: 0x%08X\n", ctx.Esp);
}
ResumeThread(hThread);

1
2
3
4
5
6
7

CONTEXT ctx = {0};
ctx.ContextFlags = CONTEXT_CONTROL; // 只修改控制寄存器
ctx.Eip = 0x00401000; // 设置新的指令指针
ctx.Esp = 0x0012FF88; // 设置新的栈指针
SuspendThread(hThread);
SetThreadContext(hThread, &ctx);
ResumeThread(hThread);

1
2
3
4
5
6
7
8

LONG WINAPI ExceptionHandler(
    EXCEPTION_POINTERS* pExceptionInfo) {
    CONTEXT* ctx = pExceptionInfo->ContextRecord;
    printf("异常地址: 0x%08X\n", ctx->Eip);
    // 可以修改上下文，例如跳过导致异常的指令
    ctx->Eip += 2; // 假设指令长度为2字节
    return EXCEPTION_CONTINUE_EXECUTION;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

void RedirectThread(HANDLE hThread, LPVOID newAddress) {
    CONTEXT ctx = {0};
    ctx.ContextFlags = CONTEXT_CONTROL;
    
    SuspendThread(hThread);
    if(GetThreadContext(hThread, &ctx)) {
        ctx.Eip = (DWORD)newAddress;
        SetThreadContext(hThread, &ctx);
    }
    ResumeThread(hThread);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

void PrintStackTrace(HANDLE hThread) {
    CONTEXT ctx = {0};
    ctx.ContextFlags = CONTEXT_CONTROL;
    SuspendThread(hThread);
    GetThreadContext(hThread, &ctx);
    DWORD ebp = ctx.Ebp;
    DWORD eip = ctx.Eip;
    printf("Call stack:\n");
    for(int i = 0; i < 10 && ebp != 0; i++) {
        printf("  [%d] 0x%08X\n", i, eip);
        // 读取返回地址 (eip 在 ebp+4)
        ReadProcessMemory(GetCurrentProcess(), (LPCVOID)(ebp + 4), &eip, sizeof(eip), NULL);
        // 读取上一栈帧的 ebp
        ReadProcessMemory(GetCurrentProcess(), (LPCVOID)ebp, &ebp, sizeof(ebp), NULL);
    }
    ResumeThread(hThread);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // 全局互斥锁
long long shared_counter = 0;
void critical_section() {
    mtx.lock();   // 获取锁
    // ... 访问共享资源 ...
    shared_counter++;
    mtx.unlock(); // 释放锁
}
// RAII风格的更安全写法
void increment_safe() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 构造时自动加锁，析构时自动解锁
        shared_counter++;
    } // lock 变量在此处超出作用域，自动解锁
}
int main() {
    std::thread t1(increment_safe);
    std::thread t2(increment_safe);
    t1.join();
    t2.join();
    std::cout << "Final counter: " << shared_counter << std::endl; // 结果总是 200000
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <iostream>
#include <thread>
#include <atomic>
std::atomic_flag lock = ATOMIC_FLAG_INIT;
long long shared_counter_spin = 0;
void critical_section() {
    for (int i = 0; i < 100000; ++i) {
    // 忙等待循环，直到获取锁
    	while (lock.test_and_set(std::memory_order_acquire)) {} // 自旋等待
    // ... 访问共享资源 ...
    	shared_counter_spin++;
    	lock.clear(std::memory_order_release); // 释放锁
    }
}
int main() {
    std::thread t1(increment_spin);
    std::thread t2(increment_spin);

    t1.join();
    t2.join();

    std::cout << "Final counter (spin lock): " << shared_counter_spin << std::endl;
    return 0;
}