CHAR szStr[]="中国";
WCHAR sezStr[]=L"中国";
TCHAR stzStr[]=TEXT("中国");//这种方式只要修改项目设置，就可以全部修改ASCII和宽字符

PSTR pszStr="中国";
PWSTR pwszStr=L"中国";
PTSTR ptszStr=TEXT("中国");

//返回值表示是否创建成功
BOOL CreateProcessA(
  LPCSTR                lpApplicationName,//全路径对象名称
  LPSTR                 lpCommandLine,//命令行参数
  LPSECURITY_ATTRIBUTES lpProcessAttributes,//安全属性结构体指针，是否可继承进程句柄
  LPSECURITY_ATTRIBUTES lpThreadAttributes,//安全属性结构体指针，是否可继承线程句柄
  BOOL                  bInheritHandles,//是否继承父进程的句柄表
  DWORD                 dwCreationFlags,//创建标志（可以指定是否开新的控制台，是否挂起启动等等）
  LPVOID                lpEnvironment,//进程环境变量（填空就好，没什么用）
  LPCSTR                lpCurrentDirectory,//工作目录，即进程工作路径
  LPSTARTUPINFOA        lpStartupInfo,//[IN参数]启动信息结构体指针(必填)
  LPPROCESS_INFORMATION lpProcessInformation//[OUT参数]进程信息结构体
);
BOOL CreateProcessW(
  LPCWSTR               lpApplicationName,
  LPWSTR                lpCommandLine,
  LPSECURITY_ATTRIBUTES lpProcessAttributes,
  LPSECURITY_ATTRIBUTES lpThreadAttributes,
  BOOL                  bInheritHandles,
  DWORD                 dwCreationFlags,
  LPVOID                lpEnvironment,
  LPCWSTR               lpCurrentDirectory,
  LPSTARTUPINFOW        lpStartupInfo,
  LPPROCESS_INFORMATION lpProcessInformation
);

typedef struct _STARTUPINFOA {
  DWORD  cb;//存当前结构体的大小，目的是为了以后程序的拓展(必填)
  LPSTR  lpReserved;//保留，置为NULL
  LPSTR  lpDesktop;//指定一个字符串，包括该进程的桌面名或窗口位置名
  LPSTR  lpTitle;//指定控制台进程创建的新控制台窗口标题
  DWORD  dwX;//指定新窗口左上角的x和y偏移量（以像素为单位）
  DWORD  dwY;
  DWORD  dwXSize;//指定新窗口的宽度和高度
  DWORD  dwYSize;
  DWORD  dwXCountChars;//指定新窗口的屏幕缓冲区的宽度和高度
  DWORD  dwYCountChars;
  DWORD  dwFillAttribute;//指定新窗口的初始文字和背景颜色
  DWORD  dwFlags;//创建窗口标志
  WORD   wShowWindow;//新窗口的显示状态
  WORD   cbReserved2;//保留，必须置为0
  LPBYTE lpReserved2;//保留，必须置为NULL
  HANDLE hStdInput;//指定一个句柄，该句柄用作进程的标准输入句柄
  HANDLE hStdOutput;//指定一个句柄，该句柄用作进程的标准输出句柄
  HANDLE hStdError;//指定一个句柄，句柄用作进程的标准错误句柄
} STARTUPINFOA, *LPSTARTUPINFOA;
typedef struct _STARTUPINFOW {
  DWORD  cb;
  LPWSTR lpReserved;
  LPWSTR lpDesktop;
  LPWSTR lpTitle;
  DWORD  dwX;
  DWORD  dwY;
  DWORD  dwXSize;
  DWORD  dwYSize;
  DWORD  dwXCountChars;
  DWORD  dwYCountChars;
  DWORD  dwFillAttribute;
  DWORD  dwFlags;
  WORD   wShowWindow;
  WORD   cbReserved2;
  LPBYTE lpReserved2;
  HANDLE hStdInput;
  HANDLE hStdOutput;
  HANDLE hStdError;
} STARTUPINFOW, *LPSTARTUPINFOW;

typedef struct _PROCESS_INFORMATION {
  HANDLE hProcess;//进程句柄
  HANDLE hThread;//线程句柄
  DWORD  dwProcessId;//进程ID
  DWORD  dwThreadId;//线程ID
} PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;

typedef struct _SECURITY_ATTRIBUTES {
  DWORD  nLength;//该结构体的长度（必填）
  LPVOID lpSecurityDescriptor;//指向一个安全描述符结构体的指针，表明当前内核对象，哪个用户能访问（写代码时不需要关注，因为不设置的时候，默认表示安全设置与父进程一样）
  BOOL   bInheritHandle;//当前内核对象是否允许继承（重点）决定了后面有张图中父进程句柄表中的字段是0还是1，允许被继承填1，不允许填0
} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;

BOOL CreateChildProcess(PTCHAR szChildProcssName,PTCHAR szCommandLine)
{
    STARTUPINFO si;
	PROCESS_INFORMATION pi;
	ZeroMemory(&pi,sizeof(pi));
	ZeroMemory(&pi,sizeof(si));
	si.cb=sizeof(si);//必填
	//创建进程，返回成功与失败
	if(!CreateProcess(
    	szChildProcssName,//对象名称
        szCommandLine,//命令行
        NULL,//不继承进程句柄
        NULL,//不继承线程句柄
        FALSE,//不继承父进程的句柄表
        0,//没有创建标志
        NULL,//使用父进程环境变量
        NULL,//使用父进程工作路径作为当前进程工作路径
        &si,//_STARTUPINFOW结构体详细信息
	    &pi)//LPPROCESS_INFORMATION结构体详细信息
      )
    {
        printf("创建子进程失败,错误：%d\n",GetLastError());
        return FALSE;
    }
    //释放句柄
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
    return TRUE;
}

void main(int argc,char* argv[])
{
	//argc是命令行参数的个数，argv是存命令行参数的指针。
}

//返回值为线程句柄
HANDLE CreateThread(
  LPSECURITY_ATTRIBUTES   lpThreadAttributes,//安全属性，决定是否可被继承
  SIZE_T                  dwStackSize,//初始堆栈（0表示系统默认）
  LPTHREAD_START_ROUTINE  lpStartAddress,//线程回调函数
  __drv_aliasesMem LPVOID lpParameter,//线程回调函数的参数
  DWORD                   dwCreationFlags,//创建线程的标识，0表示立即执行，CREATE_SUSPENDED表示挂起
  LPDWORD                 lpThreadId//[out]返回线程id，不接受填NULL
);

unsigned long _beginthread(
  void(_cdecl *start_address)(void *), //声明为void (*start_address)(void *)形式
  unsigned stack_size, //是线程堆栈大小，一般默认为0
  void *arglist //向线程传递的参数，一般为结构体
);
 
unsigned long _beginthreadex( //推荐使用
  void *security,    //安全属性，NULL表示默认安全性
  unsigned stack_size, //是线程堆栈大小，一般默认为0
  unsigned(_stdcall  *start_address)(void *),    //声明为unsigned(*start_address)(void *)形式
  void *argilist,    //向线程传递的参数，一般为结构体
  unsigned initflag, //新线程的初始状态，0表示立即执行，CREATE_SUSPEND表示创建后挂起（可用ResumeThread唤醒）。
  unsigned *thrdaddr //该变量存放线程标识符，它是CreateThread函数中的线程ID。
); //创建成功条件下的将线程句柄转化为unsigned long型返回，创建失败条件下返回0

DWORD WINAPI ThreadProc(
  _In_ LPVOID lpParameter
);

Sleep()

SuspendThread(线程句柄)

ResumeThread()

//当前线程阻塞状态，等待指定对象状态发生变更（执行完毕也属于状态发生变更）或超时间隔结束才继续执行。
DWORD WaitForSingleObject(
  HANDLE hHandle,//什么内核对象句柄都可以
  DWORD  dwMilliseconds//超时时间，最多等多久，INFINITE表示等无限久
);

DWORD WaitForMultipleObjects(
  DWORD        nCount,//等几个内核对象
  const HANDLE *lpHandles,//内核对象指针，什么内核对象句柄都可以
  BOOL         bWaitAll,//等待模式，1表示等所有对象状态变更，0表示等任一个对象状态变更
  DWORD        dwMilliseconds//超时时间，最多等多久，INFINITE表示等无限久
);

//获取线程回调函数的返回结果
//返回值：函数成功，则返回值非零。失败为零
BOOL GetExitCodeThread(
  HANDLE  hThread,//线程句柄
  LPDWORD lpExitCode//[out]存返回结果的指针
);

//64位
typedef struct DECLSPEC_ALIGN(16) _CONTEXT {

    //
    // Register parameter home addresses.
    //
    // N.B. These fields are for convience - they could be used to extend the
    //      context record in the future.
    //

    DWORD64 P1Home;
    DWORD64 P2Home;
    DWORD64 P3Home;
    DWORD64 P4Home;
    DWORD64 P5Home;
    DWORD64 P6Home;

    //
    // Control flags.
    //

    DWORD ContextFlags;
    DWORD MxCsr;

    //
    // Segment Registers and processor flags.
    //

    WORD   SegCs;
    WORD   SegDs;
    WORD   SegEs;
    WORD   SegFs;
    WORD   SegGs;
    WORD   SegSs;
    DWORD EFlags;

    //
    // Debug registers
    //

    DWORD64 Dr0;
    DWORD64 Dr1;
    DWORD64 Dr2;
    DWORD64 Dr3;
    DWORD64 Dr6;
    DWORD64 Dr7;

    //
    // Integer registers.
    //

    DWORD64 Rax;
    DWORD64 Rcx;
    DWORD64 Rdx;
    DWORD64 Rbx;
    DWORD64 Rsp;
    DWORD64 Rbp;
    DWORD64 Rsi;
    DWORD64 Rdi;
    DWORD64 R8;
    DWORD64 R9;
    DWORD64 R10;
    DWORD64 R11;
    DWORD64 R12;
    DWORD64 R13;
    DWORD64 R14;
    DWORD64 R15;

    //
    // Program counter.
    //

    DWORD64 Rip;

    //
    // Floating point state.
    //

    union {
        XMM_SAVE_AREA32 FltSave;
        struct {
            M128A Header[2];
            M128A Legacy[8];
            M128A Xmm0;
            M128A Xmm1;
            M128A Xmm2;
            M128A Xmm3;
            M128A Xmm4;
            M128A Xmm5;
            M128A Xmm6;
            M128A Xmm7;
            M128A Xmm8;
            M128A Xmm9;
            M128A Xmm10;
            M128A Xmm11;
            M128A Xmm12;
            M128A Xmm13;
            M128A Xmm14;
            M128A Xmm15;
        } DUMMYSTRUCTNAME;
    } DUMMYUNIONNAME;

    //
    // Vector registers.
    //

    M128A VectorRegister[26];
    DWORD64 VectorControl;

    //
    // Special debug control registers.
    //

    DWORD64 DebugControl;
    DWORD64 LastBranchToRip;
    DWORD64 LastBranchFromRip;
    DWORD64 LastExceptionToRip;
    DWORD64 LastExceptionFromRip;
} CONTEXT, *PCONTEXT;

//32位
typedef struct _WOW64_CONTEXT {

    //
    // The flags values within this flag control the contents of
    // a CONTEXT record.
    //
    // If the context record is used as an input parameter, then
    // for each portion of the context record controlled by a flag
    // whose value is set, it is assumed that that portion of the
    // context record contains valid context. If the context record
    // is being used to modify a threads context, then only that
    // portion of the threads context will be modified.
    //
    // If the context record is used as an IN OUT parameter to capture
    // the context of a thread, then only those portions of the thread's
    // context corresponding to set flags will be returned.
    //
    // The context record is never used as an OUT only parameter.
    //

    DWORD ContextFlags;//在查询的时候需要设置该字段，表示查询哪些其他的CONTEXT结构字段。

    //
    // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is
    // set in ContextFlags.  Note that CONTEXT_DEBUG_REGISTERS is NOT
    // included in CONTEXT_FULL.
    //

    DWORD   Dr0;
    DWORD   Dr1;
    DWORD   Dr2;
    DWORD   Dr3;
    DWORD   Dr6;
    DWORD   Dr7;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_FLOATING_POINT.
    //

    WOW64_FLOATING_SAVE_AREA FloatSave;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_SEGMENTS.
    //

    DWORD   SegGs;
    DWORD   SegFs;
    DWORD   SegEs;
    DWORD   SegDs;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_INTEGER.
    //

    DWORD   Edi;
    DWORD   Esi;
    DWORD   Ebx;
    DWORD   Edx;
    DWORD   Ecx;
    DWORD   Eax;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_CONTROL.
    //

    DWORD   Ebp;
    DWORD   Eip;
    DWORD   SegCs;              // MUST BE SANITIZED
    DWORD   EFlags;             // MUST BE SANITIZED
    DWORD   Esp;
    DWORD   SegSs;

    //
    // This section is specified/returned if the ContextFlags word
    // contains the flag CONTEXT_EXTENDED_REGISTERS.
    // The format and contexts are processor specific
    //

    BYTE    ExtendedRegisters[WOW64_MAXIMUM_SUPPORTED_EXTENSION];

} WOW64_CONTEXT;

BOOL GetThreadContext(
  HANDLE    hThread,//线程句柄
  LPCONTEXT lpContext//[out]用于接受返回上下文结构体对象的指针
);

BOOL SetThreadContext(
  HANDLE        hThread,//线程句柄
  const CONTEXT *lpContext//上下文结构体对象的指针，用于设置
);

//创建和打开互斥体都是该函数
HANDLE CreateMutexA(
  LPSECURITY_ATTRIBUTES lpMutexAttributes,//安全属性，表示是否可以被子进程继承句柄
  BOOL                  bInitialOwner,//初始有无信号，信号表示其他线程的wait是否会阻塞，无信号表示其他线程会阻塞，有信号表示其他线程不阻塞。true表示初始无信号即其他线程会阻塞，false表示初始有信号即其他线程不阻塞。；下面有详解
  LPCSTR                lpName//内核互斥体的名字，随便起的
);
HANDLE CreateMutexW(
  LPSECURITY_ATTRIBUTES lpMutexAttributes,
  BOOL                  bInitialOwner,
  LPCWSTR               lpName
);

HANDLE hMutex = CreateMutex(NULL, false, TEXT("1"));
WaitForSingleObject(hMutex, INFINITE);
//上面两句代码与下面代码在创建时候是一样的，都会阻塞其他wait的线程；使用时候下面代码填true和false是没有意义的，含义都是打开互斥体
HANDLE hMutex = CreateMutex(NULL, true, TEXT("1"));

CloseHandle(hMutex);

//创建一个互斥体
HANDLE  g_hMutex=CreateMutex(NULL,FALSE,"XYZ");
//获取令牌
WaitForSingleObject(g_hMutex,INFINITE);
//这里面的代码实现原子操作===========
for(int i=0;i<10;i++)
{
    Sleep(1000);
    printf("A进程的x线程：%d\n",i);
}
//=================================
//释放令牌
ReleaseMutex(g_hMutex);

//创建一个互斥体
HANDLE hMutex=CreateMutexA(NULL,FALSE,"防止多开");
if(hMutex)
{
    if(GetLastError()==ERROR_ALREADY_EXISTS)//代表之前已经存在了一个进程了
	{
    	CloseHandle(hMutex);
        return 0;
	}
}
else//程序创建失败
{
    CloseHandle(hMutex);
    return 0;
}
//程序开始点

//创建或打开事件
HANDLE CreateEventA(
  LPSECURITY_ATTRIBUTES lpEventAttributes,//安全属性
  BOOL                  bManualReset,//true表示通知类型，false表示互斥
  BOOL                  bInitialState,//false：初始没信号：wait会阻塞；true：初始有信号：wait会继续执行
  LPCSTR                lpName//给Event起个名字，方便跨进程打开
);
HANDLE CreateEventW(
  LPSECURITY_ATTRIBUTES lpEventAttributes,
  BOOL                  bManualReset,
  BOOL                  bInitialState,
  LPCWSTR               lpName
);

//SetEvent会让cpu分出去时间片（体现不是很直观）
//SetEvent后被唤醒的线程优先级被提升所以会先执行，执行完了它所应有的时间片之后，优先级会被降低，然后其他线程就有机会执行了。
//将指定的事件对象设置为有信号状态。有信号，就是通知其他线程wait可以解除阻塞了
BOOL SetEvent(
  HANDLE hEvent
);
//将指定的事件对象设置为无信号状态
BOOL ResetEvent(
  HANDLE hEvent
);

//生产者与消费者真同步案例(互斥体实现)
int g_time = 10;//生产10次
int g_Number = 0;//生产者将他置1表示生产成功，消费者将他置0表示消费掉了。
HANDLE g_hMutex=NULL;

void thread1()//生产者
{
	int current = 0;//当前生产个数
	for (int i = 0; i < g_time; i++)
	{
		WaitForSingleObject(g_hMutex, INFINITE);//互斥区
		if (g_Number==0)
		{
			g_Number = 1;
			printf("生产者线程生产第%d个\r\n",++current);
		}
		else
		{
			printf("==============\r\n");//1处
			i--;
		}
		ReleaseMutex(g_hMutex);
	}
}
void thread2()//消费者
{
	int current = 0;//当前消费个数
	for (int i = 0; i < g_time; i++)
	{
		WaitForSingleObject(g_hMutex, INFINITE);//互斥区
		if (g_Number == 1)
		{
			g_Number=0;
			printf("消费者线程消费第%d个\r\n", ++current);
		}
		else
		{
			printf("==============\r\n");//2处
			i--;
		}
		ReleaseMutex(g_hMutex);
	}
}

void main()
{
	g_hMutex = CreateMutex(NULL, false, NULL);
	cout << "g_hMutex：" << g_hMutex << endl;
	HANDLE threadHandleArray[2];
	threadHandleArray[0] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread1, NULL, 0, NULL);
	threadHandleArray[1] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread2, NULL, 0, NULL);

	WaitForMultipleObjects(2, threadHandleArray, true, INFINITE);
	printf("测试结束\r\n");
}

//生产者与消费者真同步案例(事件实现)
int g_time = 10;//生产10次
int g_Number = 0;//生产者将他置1表示生产成功，消费者将他置0表示消费掉了。
HANDLE g_hEvent =NULL;

void thread1()//生产者
{
	int current = 0;//当前生产个数
	for (int i = 0; i < g_time; i++)
	{
		WaitForSingleObject(g_hEvent, INFINITE);//互斥区
		if (g_Number == 0)
		{
			g_Number = 1;
			printf("生产者线程生产第%d个\r\n", ++current);
		}
		else
		{
			printf("==============\r\n");
			i--;
		}
        //其实真同步直接用下面代码顶替上面if else就可以了。
		/*g_Number = 1;
		printf("生产者线程生产第%d个\r\n", ++current);*/
		SetEvent(g_hEvent);
	}
}
void thread2()//消费者
{
	int current = 0;//当前消费个数
	for (int i = 0; i < g_time; i++)
	{
		WaitForSingleObject(g_hEvent, INFINITE);//互斥区
		if (g_Number == 1)
		{
			g_Number=0;
			printf("消费者线程消费第%d个\r\n", ++current);
		}
		else
		{
			printf("==============\r\n");
			i--;
		}
        //其实真同步直接用下面代码顶替上面if else就可以了。
		/*g_Number = 0;
		printf("消费者线程消费第%d个\r\n", ++current);*/
		SetEvent(g_hEvent);
	}
}


void main()
{
	g_hEvent = CreateEvent(NULL, false,true,NULL);
	HANDLE threadHandleArray[2];
	threadHandleArray[0] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread1, NULL, 0, NULL);
	threadHandleArray[1] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread2, NULL, 0, NULL);

	WaitForMultipleObjects(2, threadHandleArray, true, INFINITE);
	printf("测试结束\r\n");
}

HWND hwnd;
HDC hdc;//设备上下文的句柄
HPEN hpen;//画笔句柄
HBRUSH hBrush;//画刷句柄
//===设备对象，画在哪
hwnd=(HWND)0x000E0244;//某窗口句柄
//===获取设备对象上下文 DC
hdc=GetDC(hwnd);
//===图形对象，画什么,画线，所以使用Pen,PS_SOLID实线,线的宽度为5,颜色为RGB(0xFF,00,00),RGB是个宏
hpen=CreatePen(PS_SOLID,5,RGB(0xFF,00,00));
//直接用系统提供的其他画刷
hBrush=(HBRUSH)GetStockObject(DC_BRUSH);
//===关联图形对象和设备上下文,如果不关联，调用的是默认的笔，每种图像对象都存在对应的默认款。
//===SelectObject返回的是原来默认的图像对象的句柄
SelectObject(hdc,hpen);
//关联画刷
SelectObject(hdc,hBrush);
//===实际的绘制操作
//画线  从哪画到哪
MoveToEx(hdc,0,400,NULL);
LineTo(hdc,400,400);
//DC_BRUSH可以通过下面函数设置颜色
SetDCBrushColor(hdc,RGB(0xFF,0xFF,00));
//画矩形
Rectangle(hdc,0,0,100,100);
//===释放资源
DeleteObject(hpen);
DeleteObject(hBrush);//GetStockObject获得的图像对象可以不用删，但删了也没坏处
ReleaseDC(hwnd,hdc);
//get对象release  create对象delete

int WINAPI WinMain(
	HINSTANCE hInstance,//当前模块句柄（实际上就是当前模块在内存中的位置）
	HINSTANCE hPrevInstance,// 没有任何意义。 它用于16位 Windows，但现在始终为零。
	LPSTR lpCmdLine,//命令行参数，由CreateProcess的lpCommandLine参数决定
	int nCmdShow//是一个标志，用于指示主应用程序窗口是最小化、最大化还是正常显示。由CreateProcess的lpStartupInfo中的显示状态决定
)
{
    //第一步：定义你的窗口是什么样的，并注册窗口类
    TCHAR className[]=TEXT("My First Window");
    WNDCLASS wndclass={0};
    wndclass.hbrBackground=(HBRUSH)COLOR_BACKGROUND;
    wndclass.lpszClassName=className;
    wndclass.hInstance=hInstance;
    wndclass.lpfnWndProc=myWindowProc;//窗口程序回调函数名
    RegisterClass(&wndclass);//注册窗口类，把这个封装好的类给操作系统
    //第二步，创建并显示窗口
    HWND hwnd=CreateWindow(className,TEXT("我的第一个窗口"),WS_OVERLAPPEDWINDOW,10,10,600,300,NULL,NULL,hInstance,NULL);
    if(hwnd==NULL)
    {
        char szOutBuff[0x80];
        sprintf(szOutBuff,"Error:%d",GetLastError());//格式化字符串
		OutputDebugString(szOutBuff);
        return 0;
    }
    ShowWindow(hwnd,SW_SHOW);
    //第三部,接受消息并处理
    MSG msg;
    bool bRet;
    while((bRet=GetMessage(&msg,NULL,0,0))!=0)//循环从消息队列获取消息
    {
        if(bRet==-1)
        {
            //出问题了
            char szOutBuff[0x80];
		   sprintf(szOutBuff,"Error:%d",GetLastError());//格式化字符串
		    OutputDebugString(szOutBuff);
        }
        else
        {
            TranslateMessage(&msg);//转换消息，针对WM_CHAR消息
            DispatchMessage(&msg);//分发消息，该函数就是为了调用消息处理函数，每个窗口都有对应的消息处理函数
		}
	}
}

//告诉我们要创建的窗口是怎么样的
typedef struct tagWNDCLASSA {
    UINT        style;
    WNDPROC     lpfnWndProc;//窗口程序,处理各种消息。
    int         cbClsExtra;
    int         cbWndExtra;
    HINSTANCE   hInstance;//这个窗口是属于哪个模块的，往往是属于自己模块的，所以填WinMain传进来的hInstance
    HICON       hIcon;
    HCURSOR     hCursor;
    HBRUSH      hbrBackground;//背景色,类型是画刷类型
    LPCSTR      lpszMenuName;
    LPCSTR      lpszClassName;//窗口类名
} WNDCLASSA, *PWNDCLASSA, NEAR *NPWNDCLASSA, FAR *LPWNDCLASSA;
typedef struct tagWNDCLASSW {
    UINT        style;
    WNDPROC     lpfnWndProc;
    int         cbClsExtra;
    int         cbWndExtra;
    HINSTANCE   hInstance;
    HICON       hIcon;
    HCURSOR     hCursor;
    HBRUSH      hbrBackground;
    LPCWSTR     lpszMenuName;
    LPCWSTR     lpszClassName;
} WNDCLASSW, *PWNDCLASSW, NEAR *NPWNDCLASSW, FAR *LPWNDCLASSW;

LRESULT CALLBACK myWindowProc(
  _In_ HWND   hwnd,
  _In_ UINT   uMsg,
  _In_ WPARAM wParam,
  _In_ LPARAM lParam
)
{
    return DefWindowProc(hwnd,uMsg,wParam,lParam);//就算你什么也不想做，也要调用默认的消息处理函数,因为系统已经做好了很多基本的消息处理代码，比如说放大窗口，移动窗口等等。
}

//创建窗口成功返回窗口句柄;失败返回NULL。
void CreateWindowA(
   lpClassName,//类名,创建窗口的时候操作系统就是通过calssName关联起来该窗口的WNDCLASS结构体的
   lpWindowName,//窗口名
   dwStyle,//窗口样式（很多种样式，每种样式又有很多子样式组成）
   x,//相对于父窗口的x坐标（像素单位）
   y,//相对于父窗口的y坐标（像素单位）
   nWidth,//窗口宽度（像素单位）
   nHeight,//窗口高度（像素单位）
   hWndParent,//父窗口句柄，没有填空
   hMenu,//若是该窗口是父窗口，该参数表示菜单句柄，没有的话填空；若创建的是子窗口，表示子窗口的id标识编号
   hInstance,//当前应用程序的句柄
   lpParam//附加数据
);
void CreateWindowW(
   lpClassName,
   lpWindowName,
   dwStyle,
   x,
   y,
   nWidth,
   nHeight,
   hWndParent,
   hMenu,
   hInstance,
   lpParam
);

BOOL ShowWindow(
  HWND hWnd,//显示窗口的窗口句柄
  int  nCmdShow//以什么形式显示(例如：最大化等等)
);

//如果函数检索WM_QUIT以外的消息，则返回值非零。
//如果该函数检索WM_QUIT消息，则返回值为零。
//如果有错误，返回值为-1。例如，如果hWnd是无效的窗口句柄或lpMsg是无效的指针，则该函数将失败。要获取扩展错误信息，请调用GetLastError。
BOOL GetMessage(
  LPMSG lpMsg,//从消息队列中取出的消息存放的位置
  //后三个参数全是过滤消息的条件，因为一个消息队列线程同时有多个窗口
  HWND  hWnd,//针对哪个窗口
  //下面两个表示针对不同类型的消息不一样，比如键盘鼠标等
  UINT  wMsgFilterMin,//0表示我全要
  UINT  wMsgFilterMax//0表示我全要
);

//含义取决于正在调度的消息，通常会忽略返回值
LRESULT DispatchMessage(
  const MSG *lpMsg
);

//如果消息被翻译（即，一个字符消息被发送到线程的消息队列），则返回值非零。
//如果消息未翻译（即字符消息未发送到线程的消息队列），则返回值为零。
BOOL TranslateMessage(
  const MSG *lpMsg
);

//窗口回调函数中如下代码：
case WM_KEYDOWN:
	OutputDebugStringA("WM_KEYDOWN");
	break;
case WM_KEYUP:
	OutputDebugStringA("WM_KEYUP");
	break;
case WM_CHAR:
	char szOutBuff[0x80];
	sprintf(szOutBuff, "%c", wParam);//格式化字符串
	OutputDebugStringA(szOutBuff);
	break;

char szOutBuff[0x80];
sprintf(szOutBuff,"Error:%d",GetLastError());//格式化字符串
OutputDebugStringA(szOutBuff);

typedef struct tagMSG {
  HWND   hwnd;//窗口句柄
  UINT   message;//消息类型的编号，用于标识消息是什么类型的
  //下面两个参数存储消息具体的内容，比如说怎么操作了哪个键位。
  WPARAM wParam;
  LPARAM lParam;
  DWORD  time;//消息产生的时间
  POINT  pt;//point发布消息时的光标位置，以屏幕坐标表示。
  DWORD  lPrivate;
} MSG, *PMSG, *NPMSG, *LPMSG;

/*
 * Window Messages
 */
#define WM_NULL                         0x0000
#define WM_CREATE                       0x0001
#define WM_DESTROY                      0x0002
#define WM_MOVE                         0x0003
#define WM_SIZE                         0x0005

#define WM_ACTIVATE                     0x0006

//创建文本框,可以写到窗口过程处理函数的WM_CREATE信息下，创建好父窗口后就创建子窗口
CreatWindow(
    "EDIT",
    "",//编辑子窗口这里是空就可以了
    WS_CHILD|WS_VISIBLE|WS_VSCROLL|ES_MULTILINE,//WS_CHILD必须有表示子窗口;WS_VISIBLE表示初始就是可见状态;WS_VSCROLL表示带滚动条的;ES_MULTILINEL是编辑框的特有属性，表示支持多行编辑
    10,//离父窗口左上角向右偏移10像素
    10,//离父窗口左上角向下偏移10像素
    500,//子窗口宽500像素
    300,//子窗口高300像素
    hWnd,//父窗口的窗口句柄
    (HMENU)1,//子窗口的标识编号
    hInst,//当前窗口属于哪个程序
    NULL//附加数据
);
//按钮子控件
CreatWindow(
    "BUTTON",
    "设置",//按钮子窗口这里代表按钮里的文本
    WS_CHILD|WS_VISIBLE,
    520,//离父窗口左上角向右偏移520像素
    180,//离父窗口左上角向下偏移180像素
    60,//子窗口宽60像素
    30,//子窗口高30像素
    hWnd,//父窗口的窗口句柄
    (HMENU)2,//子窗口的标识编号
    hInst,//当前窗口属于哪个程序
    NULL//附加数据
);
//按钮控件点击给父窗口传的是WM_COMMAND消息，他的wParam的低16位表示子窗口的标识编号可以区分是哪个控件的消息。
//p.s.LOWORD()宏可以直接获得DWORD的低16位。

BOOL SetDlgItemTextA(
  HWND   hDlg,//子窗口句柄
  int    nIDDlgItem,//子窗口标识编号
  LPCSTR lpString//设置的文本
);
BOOL SetDlgItemTextW(
  HWND    hDlg,
  int     nIDDlgItem,
  LPCWSTR lpString
);

//成功的话返回分配的虚拟内存首地址
//失败返回NULL
LPVOID VirtualAlloc(
  LPVOID lpAddress,//要分配的内存区域的地址，如果指定到已经分配的虚拟空间了则一定失败。所以一般填空表示分配到哪个虚拟地址都可以
  SIZE_T dwSize,//分配多大的虚拟内存，哪怕写一个字节也会分配一个页的大小，所以通常写页的整数倍
  DWORD  flAllocationType,//分配的类型，比如MEM_RESERVE表示占用虚拟地址（使用时，操作系统才帮你挂物理页），MEM_COMMIT表示占用虚拟地址并且挂上物理页
  DWORD  flProtect//内存的初始保护属性，比如PAGE_READWRITE可读可写，比如PAGE_READONLY只读，比如PAGE_EXECUTE_READWRITE可读可写可执行
);
//释放私有内存或仅释放物理页
BOOL VirtualFree(
  LPVOID lpAddress,//释放的虚拟内存首地址
  SIZE_T dwSize,//释放多大的内存，通常写页的整数倍。dwFreeType为MEM_RELEASE时，这里必须为0
  DWORD  dwFreeType//释放方式：MEM_DECOMMIT只取消占用物理页，虚拟地址依然保留；MEM_RELEASE表示物理页不占用的同时也释放虚拟地址，如果指定此值，则dwSize必须为 0
);
//VirtualAllocEx只比VirtualAlloc多一个进程句柄，可以给别人申请内存
LPVOID VirtualAllocEx(
  HANDLE hProcess,//申请内存的目标进程句柄
  LPVOID lpAddress,
  SIZE_T dwSize,
  DWORD  flAllocationType,
  DWORD  flProtect
);

//创建内核对象:物理页
HANDLE hMapFile=CreateFileMapping((HANDLE)-1, NULL, PAGE_READWRITE, 0, 0x1000, NULL);
//将物理页与线性地址进行映射
DWORD newMemAddress=(DWORD)MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 0x1000);
//简单使用一下地址
*(DWORD*)newMemAddress = 0x12345678;
printf("%p虚拟地址中的值为：%p\r\n", newMemAddress, *(DWORD*)newMemAddress);
//关闭映射
UnmapViewOfFile((LPCVOID)newMemAddress);
//关闭物理页内核对象句柄
CloseHandle(hMapFile);

//返回文件映射内核对象句柄
//如果对象在函数调用之前存在，则函数返回现有对象的句柄（使用其当前大小，而不是指定大小），并且GetLastError返回ERROR_ALREADY_EXISTS。
//如果函数失败，则返回值为NULL
HANDLE CreateFileMappingA(
  HANDLE                hFile,//文件句柄，如果指定了文件句柄，不仅给你提供物理页，还可以把这个文件映射到物理页上面。填-1表示只要物理页，不需要映射文件。
  LPSECURITY_ATTRIBUTES lpFileMappingAttributes,//安全属性
  DWORD                 flProtect,//保护属性：这个是设置的物理内存的访问权限。PAGE_READONLY,PAGE_READWRITE,PAGE_WRITECOPY等等，设置了该物理内存的访问权限，则其挂到的虚拟内存的访问权限必须小于等于该物理页的访问权限
    //下面两项共同表示你要多大一块物理内存；若关联文件，如果此参数和dwMaximumSizeHigh为 0（零），则文件映射对象的最大大小等于hFile标识的文件的当前大小 。
  DWORD                 dwMaximumSizeHigh,//高32位，32位系统用不上这个成员一定填空
  DWORD                 dwMaximumSizeLow,//低32位
  LPCSTR                lpName//内核对象的名字，其他进程打开该内核对象才需要此标识。
);
HANDLE CreateFileMappingW(
  HANDLE                hFile,
  LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
  DWORD                 flProtect,
  DWORD                 dwMaximumSizeHigh,
  DWORD                 dwMaximumSizeLow,
  LPCWSTR               lpName
);

//成功的话返回物理页映射到的虚拟地址首地址
//如果函数失败，则返回值为NULL
LPVOID MapViewOfFile(
  HANDLE hFileMappingObject,//文件映射内核对象的句柄
  DWORD  dwDesiredAccess,//映射的虚拟内存的权限保护属性，这个权限必须小于被映射的物理页的flProtect权限保护属性(否则该函数失败)。
    //FILE_MAP_ALL_ACCESS可读可写;
    //FILE_MAP_READ只读;
    //FILE_MAP_WRITE只写。
    //前面3个属性唯一一个可与后面属性按位或|组合：
    //FILE_MAP_EXECUTE可执行;
    //FILE_MAP_COPY写拷贝（表示当修改的时候提供副本物理页供修改而不是修改原物理页，下面《内存映射文件实现读写文件的系统文件共享的注意点》有详解）等等。
    //--------------------------------------------------------------------
    //下面两项共同表示从物理页的哪里开始映射到虚拟内存空间，是相对物理页的偏移地址
  DWORD  dwFileOffsetHigh,//高32位，32位系统用不上这个成员一定填空
  DWORD  dwFileOffsetLow,//低32位
  SIZE_T dwNumberOfBytesToMap//映射物理页的多少字节数到虚拟内存空间，必须在CreateFileMapping指定的最大大小范围内。如果此参数为 0，则映射从指定的偏移量扩展到文件映射的末尾（就是整个物理页的大小）。一般与CreateFileMappingA的dwMaximumSizeHigh和dwMaximumSizeLow的组合一致
);
//解除物理页到虚拟内存空间的映射关系，解除完后物理页还是存在的
BOOL UnmapViewOfFile(
  LPCVOID lpBaseAddress//物理页映射出来的虚拟内存首地址，MapViewOfFile返回的地址
);

//如果函数成功，则返回值是表示当前可用磁盘驱动器的位掩码。位位置 0（最低有效位）是驱动器 A，位位置 1 是驱动器 B，位位置 2 是驱动器 C，依此类推。
//如果函数失败，则返回值为零。要获取扩展错误信息，请调用 GetLastError。
DWORD GetLogicalDrives();

//如果函数成功，则返回值是复制到缓冲区的字符串的长度（以字符为单位），不包括终止空字符。请注意，ANSI-ASCII 空字符使用一个字节，而 Unicode (UTF-16) 空字符使用两个字节。
//如果缓冲区不够大，则返回值大于nBufferLength。它是保存驱动器字符串所需的缓冲区大小。
//如果函数失败，则返回值为零。要获取扩展错误信息，请使用 GetLastError函数。
DWORD GetLogicalDriveStringsA(
  DWORD nBufferLength,//缓冲区的最大大小(不包括终止空字符)
  LPSTR lpBuffer//指向缓冲区的指针，该缓冲区接收一系列以空字符结尾的字符串
);
DWORD GetLogicalDriveStringsW(
  DWORD  nBufferLength,
  LPWSTR lpBuffer
);

//确定磁盘驱动器是可移动、固定、CD-ROM、RAM 磁盘还是网络驱动器。
UINT GetDriveTypeA(
  LPCSTR lpRootPathName//驱动器的根目录。需要尾随反斜杠。如果此参数为NULL，则该函数使用当前目录的根目录。
);
UINT GetDriveTypeW(
  LPCWSTR lpRootPathName
);

BOOL GetVolumeInformationA(
  LPCSTR  lpRootPathName,//IN 磁盘驱动器代码字符串
  LPSTR   lpVolumeNameBuffer,//OUT 磁盘驱动器卷标名称(别名)
  DWORD   nVolumeNameSize,//IN 磁盘驱动器卷标名称长度
  LPDWORD lpVolumeSerialNumber,//OUT 磁盘驱动器卷标序列号（不是硬盘序列号，该号是硬盘出厂时生产厂家为区别产品而设置的，就像人的身份证）
  LPDWORD lpMaximumComponentLength,//OUT 系统允许的最大文件名长度
  LPDWORD lpFileSystemFlags,//OUT 文件系统标识
  LPSTR   lpFileSystemNameBuffer,//OUT 文件操作系统名称
  DWORD   nFileSystemNameSize//IN 文件操作系统名称长度
);
BOOL GetVolumeInformationW(
  LPCWSTR lpRootPathName,
  LPWSTR  lpVolumeNameBuffer,
  DWORD   nVolumeNameSize,
  LPDWORD lpVolumeSerialNumber,
  LPDWORD lpMaximumComponentLength,
  LPDWORD lpFileSystemFlags,
  LPWSTR  lpFileSystemNameBuffer,
  DWORD   nFileSystemNameSize
);

TCHAR szVolumneName[260] = { 0 };
DWORD dwVolumneSerial = 0;
DWORD dwMaxLength = 0;
DWORD dwFileSystem = 0;
TCHAR szFileSystem[260] = { 0 };
GetVolumeInformation(TEXT("C://"), szVolumneName, 260, &dwVolumneSerial, &dwMaxLength, &dwFileSystem, szFileSystem, 260);

//如果函数成功，则返回值非零。
//如果函数失败，则返回值为零。要获取扩展错误信息，请调用 GetLastError。
//ERROR_ALREADY_EXISTS	指定的目录已经存在。
//ERROR_PATH_NOT_FOUND	一个或多个中间目录不存在；此函数只会在路径中创建最终目录。
BOOL CreateDirectoryA(
  LPCSTR                lpPathName,//要创建的目录的路径。
  LPSECURITY_ATTRIBUTES lpSecurityAttributes//安全属性
);
BOOL CreateDirectoryW(
  LPCWSTR               lpPathName,
  LPSECURITY_ATTRIBUTES lpSecurityAttributes
);

//如果函数成功，则返回值非零。
//如果函数失败，则返回值为零。
BOOL RemoveDirectoryA(
  LPCSTR lpPathName//要删除的目录的路径。此路径必须指定一个空目录，并且调用进程必须对该目录具有删除权限。
);
BOOL RemoveDirectoryW(
  LPCWSTR lpPathName
);

BOOL MoveFileA(
  LPCSTR lpExistingFileName,//原路径（文件或目录）
  LPCSTR lpNewFileName//新路径（文件或目录）
);
BOOL MoveFileW(
  LPCWSTR lpExistingFileName,
  LPCWSTR lpNewFileName
);

//获取当前进程的当前目录。
DWORD GetCurrentDirectory(
  DWORD  nBufferLength,//当前目录字符串的缓冲区长度，以TCHARs 为单位。缓冲区长度必须包括用于终止空字符的空间。
  LPTSTR lpBuffer//指向接收当前目录字符串的缓冲区的指针。
);
//更改当前进程的当前目录。
BOOL SetCurrentDirectory(
  LPCTSTR lpPathName//新的当前目录的路径
);

//如果函数成功，则返回值是指定文件、设备、命名管道或邮槽的句柄。
//如果函数失败，则返回值为INVALID_HANDLE_VALUE。要获取扩展错误信息，请调用GetLastError。
HANDLE CreateFileA(
  LPCSTR                lpFileName,//文件名
  DWORD                 dwDesiredAccess,//访问模式，权限
  DWORD                 dwShareMode,//分享模式,0表示当前创建的文件使用是排他的，只有当前程序关闭后才能读写该文件;FILE_SHARE_DELETE表示在当前程序使用中，别的程序可以删掉。详情查看说明文档
  LPSECURITY_ATTRIBUTES lpSecurityAttributes,//安全属性
  DWORD                 dwCreationDisposition,//创建的处理方式:
    //CREATE_NEW创建一个新文件，仅当它不存在时；
    //OPEN_EXISTING打开文件或设备，仅当它存在时；
    //TRUNCATE_EXISTING打开一个文件并截断它，使其大小为零字节，仅当它存在时。
    //OPEN_ALWAYS总是打开一个文件。不存在就创建
    //CREATE_ALWAYS不存在的话创建，存在的话覆盖创建
  DWORD                 dwFlagsAndAttributes,//标志和属性，例如：FILE_ATTRIBUTE_HIDDEN文件属性设置为隐藏;FILE_ATTRIBUTE_NORMAL该文件没有设置其他属性，此属性仅在单独使用时有效。还有很多属性参考说明文档
  HANDLE                hTemplateFile//此参数可以为NULL。基本只在加密文件文件时用到该参数。详情看文档
);
HANDLE CreateFileW(
  LPCWSTR               lpFileName,
  DWORD                 dwDesiredAccess,
  DWORD                 dwShareMode,
  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  DWORD                 dwCreationDisposition,
  DWORD                 dwFlagsAndAttributes,
  HANDLE                hTemplateFile
);

//确定C:\\路径没有A.txt的情况下，在C盘下创建A.txt。并且该程序使用该文件时候，其他程序可读可写
HANDLE hFile = CreateFile(
		TEXT("C:\\A.txt"),
		GENERIC_READ|GENERIC_WRITE,
		0,
		NULL,
		CREATE_NEW,
		FILE_ATTRIBUTE_NORMAL,
		NULL
		);

//若成功，返回的是文件大小低位双字
//如果函数失败并且lpFileSizeHigh为NULL，则返回值为INVALID_FILE_SIZE。
DWORD GetFileSize(
  HANDLE  hFile,//文件句柄
  LPDWORD lpFileSizeHigh//指向返回文件大小高位双字的变量的指针，若不需要高位这里设置NULL
);

BOOL GetFileAttributesExA(
  LPCSTR                 lpFileName,//要获取属性的文件或目录路径名
  GET_FILEEX_INFO_LEVELS fInfoLevelId,//GetFileExInfoStandard，所述lpFileInformation参数是一个 WIN32_FILE_ATTRIBUTE_DATA 结构。
  LPVOID                 lpFileInformation//指向接收属性信息的结构体指针。
);
BOOL GetFileAttributesExW(
  LPCWSTR                lpFileName,
  GET_FILEEX_INFO_LEVELS fInfoLevelId,
  LPVOID                 lpFileInformation
);
DWORD GetFileAttributesA(
  LPCSTR lpFileName
);
DWORD GetFileAttributesW(
  LPCWSTR lpFileName
);

typedef struct _WIN32_FILE_ATTRIBUTE_DATA {
  DWORD    dwFileAttributes;//文件或目录的文件系统属性信息。详情见文档
  FILETIME ftCreationTime;//创建时间结构体
  FILETIME ftLastAccessTime;//最后访问时间结构体
  FILETIME ftLastWriteTime;//最后修改时间结构体
  DWORD    nFileSizeHigh;//文件大小的高位 DWORD。
  DWORD    nFileSizeLow;//文件大小的低位 DWORD。
} WIN32_FILE_ATTRIBUTE_DATA, *LPWIN32_FILE_ATTRIBUTE_DATA;

typedef struct _FILETIME {
  DWORD dwLowDateTime;//文件时间的低位部分。
  DWORD dwHighDateTime;//文件时间的高位部分。
} FILETIME, *PFILETIME, *LPFILETIME;

BOOL ReadFile(
  HANDLE       hFile,//读的文件句柄
  LPVOID       lpBuffer,//读到哪去
  DWORD        nNumberOfBytesToRead,//要读多少个字节
  LPDWORD      lpNumberOfBytesRead,//读了多少个
  LPOVERLAPPED lpOverlapped//网络编程的异步模型要关注的参数，暂不管,填NULL
);
BOOL WriteFile(
  HANDLE       hFile,
  LPCVOID      lpBuffer,//写什么
  DWORD        nNumberOfBytesToWrite,
  LPDWORD      lpNumberOfBytesWritten,
  LPOVERLAPPED lpOverlapped
);
BOOL CopyFile(
  LPCTSTR lpExistingFileName,//拷贝哪个文件
  LPCTSTR lpNewFileName,//拷贝到哪里
  BOOL    bFailIfExists//如果此参数为TRUE并且lpNewFileName指定的新文件 已经存在，则函数失败。如果此参数为 FALSE且新文件已存在，则该函数会覆盖现有文件并成功。
);
BOOL DeleteFileA(
  LPCSTR lpFileName//要删除的文件路径
);
BOOL DeleteFileW(
  LPCWSTR lpFileName
);

HANDLE hFile = CreateFile(
		TEXT("C:\\Users\\Administrator\\Desktop\\test.txt"),
		GENERIC_READ | GENERIC_WRITE,
		0,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL
		);
	cout<<hFile<<endl;
	if (hFile)
	{
		//读取文件
		//	分配空间
		char* pszBuffer;
		DWORD lowSize =GetFileSize(hFile, NULL);//文件不能过大
		if (lowSize)
		{
			pszBuffer = (char*)malloc(lowSize+1);
			ZeroMemory(pszBuffer, lowSize + 1);
			//	设置当前读取的位置
			SetFilePointer(hFile, 0, NULL, FILE_BEGIN);//设置hFile对应文件光标为从文件头偏移0个字节的位置
			//读取数据
			DWORD dwReadLength = 0;
			ReadFile(hFile, pszBuffer, lowSize, &dwReadLength, NULL);
			cout<<pszBuffer<<endl;
			//关闭文件句柄
			CloseHandle(hFile);
			//释放内存
			free(pszBuffer);
		}
	}

char szBuffer[] = "中国123";
DWORD dwWritten = 0;
WriteFile(hFile, szBuffer, strlen(szBuffer), &dwWritten, NULL);

//拷贝文件
CopyFileA("C:\\test.txt","C:\\test2.txt",FALSE);
//删除文件
DeleteFileA("C:\\test.txt");

//如果函数成功，则返回值是在随后调用FindNextFile或 FindClose 时使用的搜索句柄 ，并且 lpFindFileData参数包含有关找到的第一个文件或目录的信息。
//如果函数失败或无法从lpFileName参数中的搜索字符串中定位文件 ，则返回值为 INVALID_HANDLE_VALUE并且lpFindFileData的内容不确定。
HANDLE FindFirstFileA(
  LPCSTR             lpFileName,//欲搜索的目录或路径，以及文件名。文件名可以包含通配符，例如星号 (*) 或问号 (?)。
  LPWIN32_FIND_DATAA lpFindFileData//指向WIN32_FIND_DATA结构的指针，该结构接收有关找到的文件或目录的信息。
);
HANDLE FindFirstFileW(
  LPCWSTR            lpFileName,
  LPWIN32_FIND_DATAW lpFindFileData
);
BOOL FindNextFileA(
  HANDLE             hFindFile,//搜索句柄
  LPWIN32_FIND_DATAA lpFindFileData
);
BOOL FindNextFileW(
  HANDLE             hFindFile,
  LPWIN32_FIND_DATAW lpFindFileData
);

//包含有关FindFirstFile、 FindFirstFileEx或 FindNextFile函数找到的文件的信息 。
typedef struct _WIN32_FIND_DATAA {
  DWORD    dwFileAttributes;//文件的文件属性。
  FILETIME ftCreationTime;//创建时间结构体
  FILETIME ftLastAccessTime;//最后访问时间结构体
  FILETIME ftLastWriteTime;//最后修改时间结构体
  DWORD    nFileSizeHigh;//文件大小高DWORD
  DWORD    nFileSizeLow;//文件大小低DWORD
  DWORD    dwReserved0;//如果dwFileAttributes成员包括 FILE_ATTRIBUTE_REPARSE_POINT属性，则该成员指定重新分析点标记。否则，此值未定义且不应使用。
  DWORD    dwReserved1;//保留以备将来使用。
  CHAR     cFileName[MAX_PATH];//文件名。
  CHAR     cAlternateFileName[14];//长文件名才有的文件的替代名称，是截断版本，否则为NULL。
  //下面三个参数开发文档未说明
  DWORD    dwFileType;
  DWORD    dwCreatorType;
  WORD     wFinderFlags;
} WIN32_FIND_DATAA, *PWIN32_FIND_DATAA, *LPWIN32_FIND_DATAA;

●FILE_ATTRIBUTE_ARCHIVE——文件包含归档属性。
●FILE_ATTRIBUTE_COMPRESSED——文件和目录被压缩。
●FILE_ATTRIBUTE_DIRECTORY——找到的是一个目录。
●FILE_ATTRIBUTE_HIDDEN——文件包含隐含属性。
●FILE_ATTRIBUTE_NORMAL——文件没有其他属性。
●FILE_ATTRIBUTE_READONLY——文件包含只读属性。
●FILE_ATTRIBUTE_SYSTEM——文件包含系统属性。
●FILE_ATTRIBUTE_TEMPORARY——文件是一个临时文件。

_WIN32_FIND_DATAA p;
	HANDLE h = FindFirstFileA("C:\\Users\\Administrator\\Desktop\\123\\*.txt", &p);
	puts(p.cFileName);
	while (FindNextFileA(h, &p))
		puts(p.cFileName);