win32下 多线程（多一个线程）GDI 坦克大战

最新推荐文章于 2021-06-27 21:46:01 发布
最新推荐文章于 2021-06-27 21:46:01 发布
阅读量652 收藏 5
点赞数 3
文章标签： win32 编程 坦克大战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gamers/article/details/85042904
版权

一个字。累并快乐，兴趣索然。。。。追回梦想

学习WINDOWS编程2个月。下一步：DIrectX9...

自己加载资源：素材在下面自行下载（修改成BMP格式）

resource.h

//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ 生成的包含文件。
// 供 Tanker.rc 使用
//
#define IDB_ENEMY                       101
#define IDB_HERO                        103
#define IDI_ICON                        105
#define IDB_ARMS                        107
#define IDB_BOOMENM                     108
#define IDB_HEROBOOM                    109

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        110
#define _APS_NEXT_COMMAND_VALUE         40001
#define _APS_NEXT_CONTROL_VALUE         1001
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif

 

 

main.cpp:

#include <Windows.h>
#include <stdio.h>
#include <stdlib.h>
#include "resource.h"
#include <math.h>
#include <process.h>
#pragma comment (lib,"msimg32.lib") //处理BMP背景色函数

//常量。
#define MAX_STR 32
#define HERO_SPEED 3
#define ARM_NUM 50
#define ARM_SPEED 5
#define  ENM_NUM  8
#define ENM_SPEED 1
#define ENM_CHANGDIR 4  //enemy changdir probability 。

//全局变量。
TCHAR wndclassname[MAX_STR] = TEXT("TankerWar");
TCHAR wndtitlename[MAX_STR] = TEXT("小坦克大战");
HINSTANCE hInst;
HWND hwnd;
HDC hdc, memdc, bufdc;
RECT wndrect;
HBITMAP hHeroBMP, hEnemyBMP, hNullBMP, hArmBMP, hEnemyboomBMP, hHeroBoombmp;

//游戏各类SPRITE参数。
enum MOVEDIR { left, up, down, right };
enum ISDIE { die, nodie };
enum ARMTYPE { heroarm, enemyarm };
struct TKPOINT
{
	INT x; INT y;
};
struct HERO
{
	ISDIE isdie;
	MOVEDIR movedir;
	TKPOINT pstn;

};
struct ENEMY
{
	ISDIE isdie;
	MOVEDIR movedir;
	TKPOINT pstn;
};
struct ARMS
{
	ISDIE isdie;
	MOVEDIR movedir;
	TKPOINT pstn;
	ARMTYPE armtp;
};

//创建对象。（可惜了还不会用抽象成对象）
ARMS arms[ARM_NUM];
HERO hero;
ENEMY enemy[ENM_NUM];

//函数声明
LRESULT WINAPI WndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam); //消息主函数
void GameInit();  //游戏初始化
void DispalyScreen();  //显示SPRITE
void Fire(ENEMY &enemy, ARMTYPE armstype);//敌人开火
void HeroFire(ARMTYPE);//主角开火
void EnemyAutoMove(LPVOID param);

void DispalyScreen() {
	hdc = GetDC(hwnd);
	memdc = CreateCompatibleDC(hdc);
	bufdc = CreateCompatibleDC(hdc);
	hNullBMP = CreateCompatibleBitmap(hdc, wndrect.right, wndrect.bottom);
	SelectObject(memdc, hNullBMP); //设定CreateCompatibleBitmap的大小，否则不会显示在HDC上。
	//Display arms（没有死亡的子弹）
	hArmBMP = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_ARMS));
	SelectObject(bufdc, hArmBMP);
	for (int i = 0; i < ARM_NUM; i++)
	{
		if (arms[i].isdie == nodie)
		{
			TransparentBlt(memdc, arms[i].pstn.x, arms[i].pstn.y, 7, 7, bufdc, 0, 0, 7, 7, RGB(255, 255, 255));
			switch (arms[i].movedir)
			{
			case left:
				arms[i].pstn.x > 0 ?
					arms[i].pstn.x -= ARM_SPEED : arms[i].isdie = die;
				break;
			case up:
				arms[i].pstn.y > 0 ?
					arms[i].pstn.y -= ARM_SPEED : arms[i].isdie = die;
				break;
			case right:
				arms[i].pstn.x < wndrect.right ?
					arms[i].pstn.x += ARM_SPEED : arms[i].isdie = die;
				break;
			case down:
				arms[i].pstn.y < wndrect.bottom ?
					arms[i].pstn.y += ARM_SPEED : arms[i].isdie = die;
				break;
			}
		}
	}
	//enemy display and move 
	hEnemyBMP = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_ENEMY));
	SelectObject(bufdc, hEnemyBMP);
	for (int j = 0; j < ENM_NUM; j++)
	{
		if (enemy[j].isdie == nodie)
		{
			switch (enemy[j].movedir)
			{
			case left:
				enemy[j].pstn.x > 0 ?
					enemy[j].pstn.x -= ENM_SPEED : enemy[j].pstn.x = 0;
				TransparentBlt(memdc, enemy[j].pstn.x, enemy[j].pstn.y, 33, 33, bufdc, 0, 0, 33, 33, RGB(0, 0, 0));

				break;
			case up:
				enemy[j].pstn.y > 0 ?
					enemy[j].pstn.y -= ENM_SPEED : enemy[j].pstn.y = 0;
				TransparentBlt(memdc, enemy[j].pstn.x, enemy[j].pstn.y, 33, 33, bufdc, 33, 0, 33, 33, RGB(0, 0, 0));
				break;
			case right:
				enemy[j].pstn.x < wndrect.right - 33 ?
					enemy[j].pstn.x += ENM_SPEED : enemy[j].pstn.x = wndrect.right - 33;
				TransparentBlt(memdc, enemy[j].pstn.x, enemy[j].pstn.y, 33, 33, bufdc, 66, 0, 33, 33, RGB(0, 0, 0));
				break;
			case down:
				enemy[j].pstn.y < wndrect.bottom - 33 ?
					enemy[j].pstn.y += ENM_SPEED : enemy[j].pstn.y = wndrect.bottom - 33;
				TransparentBlt(memdc, enemy[j].pstn.x, enemy[j].pstn.y, 33, 33, bufdc, 99, 0, 33, 33, RGB(0, 0, 0));
				break;
			}
		}
	}
	// display hero（这里可以将主角调整成自动移动）
	hHeroBMP = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_HERO));
	SelectObject(bufdc, hHeroBMP);
	if (hero.isdie == nodie)
	{
		switch (hero.movedir)
		{
		case left:
			TransparentBlt(memdc, hero.pstn.x, hero.pstn.y, 33, 33, bufdc, 0, 0, 33, 33, RGB(0, 0, 0));
			break;
		case up:
			TransparentBlt(memdc, hero.pstn.x, hero.pstn.y, 33, 33, bufdc, 33, 0, 33, 33, RGB(0, 0, 0));
			break;
		case right:
			TransparentBlt(memdc, hero.pstn.x, hero.pstn.y, 33, 33, bufdc, 66, 0, 33, 33, RGB(0, 0, 0));
			break;
		case down:
			TransparentBlt(memdc, hero.pstn.x, hero.pstn.y, 33, 33, bufdc, 99, 0, 33, 33, RGB(0, 0, 0));
			break;
		}
	}
	//碰撞检测
	hEnemyboomBMP = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_BOOMENM));
	hHeroBoombmp = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_HEROBOOM));
	for (int i = 0; i < ARM_NUM; i++)
	{
		if (arms[i].isdie == nodie)
		{	//检测敌人中弹
			for (int j = 0; j < ENM_NUM; j++)
			{
				if (arms[i].armtp == heroarm && enemy[j].isdie == nodie && abs(enemy[j].pstn.x + 13 - arms[i].pstn.x) < 18 && abs(enemy[j].pstn.y + 13 - arms[i].pstn.y) < 18)
				{   
					SelectObject(bufdc, hEnemyboomBMP);
					TransparentBlt(memdc, enemy[j].pstn.x - 3, enemy[j].pstn.y - 3, 40, 40, bufdc, 120, 0, 40, 40, RGB(0, 0, 0));
					BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
					TransparentBlt(memdc, enemy[j].pstn.x - 3, enemy[j].pstn.y - 3, 40, 40, bufdc, 80, 0, 40, 40, RGB(0, 0, 0));
					BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
					TransparentBlt(memdc, enemy[j].pstn.x - 3, enemy[j].pstn.y - 3, 40, 40, bufdc, 40, 0, 40, 40, RGB(0, 0, 0));
					BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
					TransparentBlt(memdc, enemy[j].pstn.x - 3, enemy[j].pstn.y - 3, 40, 40, bufdc, 0, 0, 40, 40, RGB(0, 0, 0));
					BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
					arms[i] = { };
					enemy[j] = {  };
				}
			}
			//检测主角中弹
			if (arms[i].armtp == enemyarm && hero.isdie == nodie
				&& abs(hero.pstn.x + 13 - arms[i].pstn.x) < 18 && abs(hero.pstn.y + 13 - arms[i].pstn.y) < 18)
			{
				SelectObject(bufdc, hHeroBoombmp);
				TransparentBlt(memdc, hero.pstn.x - 8, hero.pstn.y - 8, 50, 50, bufdc, 300, 0, 50, 50, RGB(0, 0, 0));
				BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
				TransparentBlt(memdc, hero.pstn.x - 8, hero.pstn.y - 8, 50, 50, bufdc, 250, 0, 50, 50, RGB(0, 0, 0));
				BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
				TransparentBlt(memdc, hero.pstn.x - 8, hero.pstn.y - 8, 50, 50, bufdc, 200, 0, 50, 50, RGB(0, 0, 0));
				BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
				TransparentBlt(memdc, hero.pstn.x - 8, hero.pstn.y - 8, 50, 50, bufdc, 150, 0, 50, 50, RGB(0, 0, 0));
				BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
				TransparentBlt(memdc, hero.pstn.x - 8, hero.pstn.y - 8, 50, 50, bufdc, 100, 0, 50, 50, RGB(0, 0, 0));
				BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
				TransparentBlt(memdc, hero.pstn.x - 8, hero.pstn.y - 8, 50, 50, bufdc, 50, 0, 50, 50, RGB(0, 0, 0));
				BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
				TransparentBlt(memdc, hero.pstn.x - 8, hero.pstn.y - 8, 50, 50, bufdc, 0, 0, 50, 50, RGB(0, 0, 0));
				BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
				hero.isdie = die;

				MessageBox(NULL, TEXT("you falt"), TEXT("loser"), MB_OK);
			}
		}
	}
	BitBlt(hdc, 0, 0, wndrect.right, wndrect.bottom, memdc, 0, 0, SRCCOPY);
	DeleteObject(hHeroBoombmp);
	DeleteObject(hEnemyboomBMP);
	DeleteObject(hEnemyBMP);
	DeleteObject(hHeroBMP);
	DeleteObject(hNullBMP);
	DeleteObject(hArmBMP);
	DeleteDC(bufdc);
	DeleteDC(memdc);
	ReleaseDC(hwnd, hdc);
}

void GameInit() {
	//hero init
	hero.isdie = nodie;
	hero.pstn.x = (int)wndrect.right / 2 - 17;
	hero.pstn.y = (int)wndrect.bottom - 33;
	hero.movedir = up;

	for (int i = 0; i < ENM_NUM; i++)
	{
		srand((UINT)GetTickCount()*i);
		int trand = rand();
		if (enemy[i].isdie != nodie)
		{
			enemy[i].isdie = nodie;
			enemy[i].movedir = (MOVEDIR)(trand % 4);
			enemy[i].pstn = { trand % (wndrect.right - 33),trand % (wndrect.bottom - 33) };
		}
	}
}
void Fire(ENEMY &enemy, ARMTYPE armstype) {
	for (int i = 0; i < ARM_NUM; i++)
	{
		if (arms[i].isdie != nodie)
		{
			arms[i].isdie = nodie;
			arms[i].movedir = enemy.movedir;
			arms[i].armtp = armstype;
			if (arms[i].armtp == enemyarm)
			{
				switch (enemy.movedir)
				{
				case left:
					arms[i].pstn.x = enemy.pstn.x + 3;
					arms[i].pstn.y = enemy.pstn.y + 13;
					break;
				case up:
					arms[i].pstn.x = enemy.pstn.x + 13;
					arms[i].pstn.y = enemy.pstn.y + 3;
					break;
				case right:
					arms[i].pstn.x = enemy.pstn.x + 29;
					arms[i].pstn.y = enemy.pstn.y + 13;
					break;
				case down:
					arms[i].pstn.x = enemy.pstn.x + 13;
					arms[i].pstn.y = enemy.pstn.y + 29;
					break;
				}
				break;

			}
		}
	}
}
void HeroFire(ARMTYPE armstype) {
	for (int i = 0; i < ARM_NUM; i++)
	{
		if (hero.isdie == die)
		{
			break;
		}
		if (arms[i].isdie != nodie)
		{
			arms[i].isdie = nodie;
			arms[i].movedir = hero.movedir;
			//arms[i].pstn.x = hero.pstn.x;
			arms[i].armtp = armstype;
			if (arms[i].armtp == heroarm)
			{
				switch (hero.movedir)
				{
				case left:
					arms[i].pstn.x = hero.pstn.x + 3;
					arms[i].pstn.y = hero.pstn.y + 13;
					break;
				case up:
					arms[i].pstn.x = hero.pstn.x + 13;
					arms[i].pstn.y = hero.pstn.y + 3;
					break;
				case right:
					arms[i].pstn.x = hero.pstn.x + 29;
					arms[i].pstn.y = hero.pstn.y + 13;
					break;
				case down:
					arms[i].pstn.x = hero.pstn.x + 13;
					arms[i].pstn.y = hero.pstn.y + 29;
					break;
				}
			}
			break;
		}
	}
}
void EnemyAutoMove(LPVOID param) {
	while (TRUE)
	{
		Sleep(800);//否则CPU会飙
		srand(UINT(GetTickCount() * 1101));
		MOVEDIR dir;
		dir = (MOVEDIR)(rand() % 4);
		for (int p = 0; p < ENM_NUM; p++)
		{
			if (enemy[p].pstn.x<ENM_SPEED || enemy[p].pstn.y<ENM_SPEED ||
				enemy[p].pstn.x>wndrect.right - 40 || enemy[p].pstn.y>wndrect.bottom - 40)
			{
				enemy[p].movedir = dir;
			}
		}
		if (enemy[rand() % ENM_NUM].isdie == nodie)
			enemy[rand() % ENM_NUM].movedir = dir;
		int f = rand() % ENM_NUM;
		if (enemy[f].isdie == nodie)
			Fire(enemy[f], enemyarm);
	}
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE prehInstance, LPSTR lpCmdLine, int nCmdShow) {
	WNDCLASS wcs = { CS_HREDRAW | CS_VREDRAW,WndProc,0,0,hInstance,LoadIcon(hInstance,MAKEINTRESOURCE(IDI_ICON)),LoadCursor(NULL,IDC_UPARROW),HBRUSH(BLACK_BRUSH),NULL,wndclassname };
	hInst = hInstance;
	if (!RegisterClass(&wcs))
	{
		return 0;
	}
	hwnd = CreateWindow(wndclassname, wndtitlename, WS_OVERLAPPEDWINDOW&~WS_THICKFRAME, CW_USEDEFAULT, 0, 500, 500, NULL, NULL, hInstance, NULL);
	if (hwnd == NULL)
	{
		return 0;
	}
	ShowWindow(hwnd, nCmdShow);
	UpdateWindow(hwnd);
	GameInit(); //角色类初始化
	MSG msg = { 0 };
	while (msg.message != WM_QUIT)
	{
		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		else
		{
			Sleep(30);//否则CPU会飙
			DispalyScreen();
		}
	}
	UnregisterClass(wndclassname, hInstance);
	return 0;
}
LRESULT WINAPI WndProc(HWND hwnd, UINT mesage, WPARAM wparam, LPARAM lparam) {
	switch (mesage)
	{
	case WM_LBUTTONUP:
		HeroFire(heroarm);
		break;
	case WM_PAINT:
	{
		PAINTSTRUCT ps;
		HDC whdc = BeginPaint(hwnd, &ps);
		GetClientRect(hwnd, &wndrect);
		EndPaint(hwnd, &ps);
		break;
	}
	case WM_CREATE:
	{
		_beginthread(EnemyAutoMove, 0, NULL);//创建线程（敌人自动随机变向和开火）
		break;
	}
	case WM_RBUTTONDOWN:
		GameInit();
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	case WM_KEYDOWN:
		if (hero.isdie == die)
		{
			break;
		}
		switch (wparam)
		{
		case VK_UP:
			if (hero.pstn.y > 0)
			{
				hero.pstn.y -= HERO_SPEED;
				hero.movedir = up;
			}
			else
			{
				hero.pstn.y = 0;
			}
			break;
		case VK_DOWN:
			if (hero.pstn.y < wndrect.bottom - 33)
			{
				hero.pstn.y += HERO_SPEED;
				hero.movedir = down;
			}
			else
			{
				hero.pstn.y = wndrect.bottom - 33;
			}
			break;
		case VK_LEFT:
			if (hero.pstn.x > 0)
			{
				hero.pstn.x -= HERO_SPEED;
				hero.movedir = left;
			}
			else
			{
				hero.pstn.x = 0;
			}
			break;
		case VK_RIGHT:
			if (hero.pstn.x < wndrect.right - 33)
			{
				hero.pstn.x += HERO_SPEED;
				hero.movedir = right;
			}
			else
			{
				hero.pstn.x = wndrect.right - 33;
			}
			break;
		}
	default:
		return DefWindowProc(hwnd, mesage, wparam, lparam);
		break;
	}
	return 0;
}

 

 

终于搞定。

 

 

 

 

 

 

 

gamers
关注
WIN32API 坦克大战
11-28
WIN32 API的坦克大战，没有MFC代码
深入浅出Win32多线程程序设计
amanda_123的专栏
11-18 796
深入浅出Win32多线程程序设计之基本概念 2005-12-14 09:48作者：宋宝华出处：天极开发责任编辑：方舟 　　引言 　　从单进程单线程到多进程多线程是操作系统发展的一种必然趋势，当年的DOS系统属于单任务操作系统，最优秀的程序员也只能通过驻留内存的方式实现所谓的"多任务"，而如今的Win32操作系统却可以一边听音乐，一边编程，一边打印文档。 　　理解多线程及其同步、互斥
win32 坦克大战
c++小白的博客
09-12 759
实现效果 解析 几乎都是一些简单的逻辑判断和赋值，碰撞检测也是简单的矩形检测。 链接 百度云链接：https://pan.baidu.com/s/12qiFSPWLiwC16N6uY49ENg 提取码：a5mq ...
Win32多线程编程(6) — 多线程协作及线程的池化管理
曾梦想仗剑走天涯
08-14 3254
多线程协作、并行计算及线程池的一些基础知识
win32 多线程
god_wen的博客
06-19 641
线程是不能但对存在的，其必须存在在进程的地址空间中。一个线程在这段地址空间仅有两样东西 一个线程的内核对象，操作系统使用这个数据结构来管理线程。 一个线程栈，其中存储着所需函数的参数和局部变量 创建线程HANDLE WINAPI CreateThread( _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, _In_ SIZE_
win32坦克大战源码.rar
05-05
通过研究这个"win32坦克大战源码"，我们可以学习到如何利用Win32 API创建图形用户界面，处理用户输入，实现游戏逻辑，并且理解资源管理和多线程在游戏开发中的应用。这对于初学者了解Windows程序设计和游戏开发是一...
坦克大战GDI游戏制作配套代码
10-29
通过深入研究这个项目，开发者不仅可以掌握GDI的使用，还能了解到游戏开发的基本流程，包括游戏逻辑设计、用户界面实现、文件操作（如读取和保存地图）、多线程（处理游戏循环和用户输入）等方面的知识。此外，还能...
VC++编程坦克大战
12-30
7. **多线程编程**：为了实现游戏的实时性和流畅性，可能需要用到多线程技术，比如在一个线程处理游戏逻辑，另一个线程处理用户界面更新。 8. **错误处理与调试**：在开发过程中，学会使用Visual Studio的调试工具...
这是我在VC6.0下设计的一个坦克大战的游戏，很经典。。。程序完整。。你可以先试玩一下。。希望对你有所帮助
05-17
7. **多线程技术**：为了实现游戏的流畅运行，可能会用到多线程技术，如将游戏逻辑和用户界面的更新分别放在不同的线程中执行。 8. **资源管理**：游戏中的音效、图片等资源需要有效管理，避免内存泄漏。可以使用...
win32api写的坦克大战
07-08
自娱自乐专用，代码垃圾，仅供参考
多线程GDI程序
06-15
这是微软的VC6 安装盘中的一个例子，这个例子说明如何在多线程中使用 GDI 绘制。程序可以开 1，10, 25个线程来绘制 圆，矩形，和直线。
VC++6.0 坦克大战（多线程移动）
09-04
以前上传过一个自己做的坦克大战，当时初学，画面做得不流畅，最近在看多线程，把多线程加入到坦克的移动中，现在的画面非常流畅。因为坦克大战以前已经做过了，基本思路差不多，所以这个版本只做了坦克的移动，如果想了解坦克大战的具体实现，请参照以前那个版本。
VC++ 6.0 坦克大战（多线程移动）
09-03
以前上传了一个自己做的坦克大战，当时初学，做的很粗糙，画面不是很流畅，最近看多线程，把多线程应用到坦克大战中，现在的画面非常流畅，可以和小时候玩的红白机坦克大战媲美。因为以前做过了，这个版本仅仅做了坦克的移动，没有重复以前的工作。如果想看具体实现，请参考前面那个版本。
WIN32 API+DirectDraw7开发的坦克大战(C语言)
02-21
1、WIN32 API+DirectDraw7开发的坦克大战(C语言) 2、实现了坦克大战游戏的基本功能，但是没有游戏地图 3、详细请看游戏说明
多线程游戏坦克大战
代码之神
03-18 1332
坦克大战--这款游戏，相信大家小时候都玩过，想当年还在读小学的时候，我和我表哥整个暑假拿着一台小霸王游戏机接上电视，就开始玩坦克大战，通关根本停不下来， 简直打遍天下无敌手。现在我上了大学，学的是软件工程专业，学了java，现在我自己用java做了这款小游戏，和大家分享一下，也说一下我在做这个游戏过程中遇到的一些问题， 希望对大家起到一定的帮助。源代码在附件里，大家可以下载首先简略的说下整...
Win32 多线程编程
EnskDeCode
09-07 598
多线程概述进程和线程都是操作系统的概念 ; 进程是应用程序的执行实例 , 每个进程是由私有的虚拟地址空间 , 代码 , 数据和其它各种系统资源组成 , 进程在运行过程中创建的资源随着进程的终止而被销毁 , 所使用的系统资源在进程终止时被释放或关闭 ;线程是进程内部的一个执行单元 ; 系统创建好进程后 , 实际上就启动执行了该进程的主执行线程 , 主执行线程以函数地址形式 , 比如说 main 或 W
win32 多线程编程
不会写代码的丝丽
06-23 372
#include <iostream> #include <Windows.h> #include<tlhelp32.h> using namespace std; #include <string> DWORD WINAPI myRun( _In_ LPVOID lpParameter ) { cout << "子线程的第一个信息" << endl; Sleep(200); cout << "子线程的第.
win32多线程编程
pkx1993的博客
02-28 141
DWORD WINAPI Thread_InputData(LPVOID lpParameter) { } DWORD WINAPI Thread_GetH264(LPVOID lpParameter) { } int main(){ HANDLE thread_inoutdata = CreateThread(NULL, 0, Thread_InputData, NULL, 0, NULL);...
使用Win32 SDK实现多线程
judshv的博客
06-27 350
使用Win32 SDK实现多线程，一般分为两步： 1）编写线程函数 2）创建一个线程 编写线程函数一般需要用到以下类似的函数原型： DWORD _stdcall ThreadFun1(LPVIOD IpvThreadParm) Win32 SDK提供的线程创建函数是： CreateThread() 以下是一个例子： #include "pch.h" #include <iostream> #include"windows.h" #include"atlstr.h" using
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gamers

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值