VC API常用函数简单例子大全(1-89)
第一个：findwindow根据窗口类名或窗口标题名来获得窗口的句柄，该函数返回窗口的句柄
函数的定义:hwnd winapi findwindow(lpcstr lpclassname ,lpcstr lpwindowname);
第一个参数填窗口的类名，第二个填窗口的标题名，其实是不需要同时填两个参数的，也就是说，你只要知道窗口的类名或窗口的标题就可以了，没有的那个就用null代替。
比如现在有一个窗口名为"无标题.txt - 记事本"的记事本程序。那么我就可以用上面的函数获得这个窗口的句柄，那获得了这个窗口的句柄我可以干什么呢？作用可大了，因为很多操作窗口的函数，都需要窗口句柄作参数，如移动、改变窗口大小的movewindow函数，在这里举个例子，大家就更能体会到这个findwindow的用法、用处。
findwindow例子：已知一个窗口名称，写一个程序关闭该窗口，假设当前电脑正有一个窗口名为"无标题.txt - 记事本"的记事本程序运行
#include<windows.h> //api函数的头文件
int main()
{
hwnd wnd; //定义一个窗口句柄变量，用以存储找到的窗口句柄
wnd=findwindow(null,"无标题.txt - 记事本"); //获得窗口名为"无标题.txt - 记事本"的窗口句柄
sendmessage(wnd,wm_close,0,0); //调用sendmessage函数，发送一个wm_close（关闭）消息给wnd窗口句柄。
return 0;
}
如果要根据窗口类名来获得窗口句柄话，只要给函数的第一个参数填类名，第二个参数窗口名填null，即可，用spy++可查看窗口类名。
第二个：sendmessage根据窗口句柄发送一个消息给窗口
函数定义：lresult sendmessage（hwnd hwnd，uint msg，wparam wparam，lparam iparam）；
第一个参数是窗口句柄，第二参数个是消息类型，下面的消息表列举了所有消息，第三，四个参数是消息附带信息，解释依赖于消息类型，比如一个字符消息（wm_char),那么第三个参数就储存有一个字符的ascii码。
消息机制大家都应该知道吧，windows是基于消息的系统，鼠标移动键盘按键都会产生消息。
接下来举一个例子，发送一个wm_char消息给窗口，也就是模仿键盘按键，接收消息的窗口依旧以"无标题.txt - 记事本"为例：
sendmessage例子：模仿键盘按键
#include<windows.h>
int main()
{
hwnd wnd;
wnd=findwindow(null,"无标题.txt - 记事本");
while(1)
{
sendmessage(wnd,wm_char,wparam('a'),0);
sleep(300);
}
return 0;
}
呵呵上面的例子是不是没用，这是为什么呢，哪里出错了吗？错倒是没有错，只是窗口句柄有问题，消息发送给了主窗口。接收消息的窗口不对。记事本窗口界面有些有什么东西呢？菜单，编辑框， 状态栏等控件，控件也是窗口，既然是窗口，那当然它们也有窗口句柄，而在记事本里是在哪里打字的？编辑框控件里打字的嘛！所以消息应该发送编辑框控件，那如何获得记事本里编辑框控件的窗口句柄呢？用findwindow吗？不知道编辑框窗口标题名，类名也不知道，当然也有其它方法获取编辑框窗口标题名和窗口类名，如spy++。关于如何获得编辑框句柄，将在以后的函数中会有介绍，这里我们就用windowfrompoint这个函数来获取，这个函数获取窗口句柄的方法比较笨，（相对于我这个例子来说），这个函数是根据什么来获取窗口句柄的呢？根据屏幕坐标点，如屏幕坐标点20，20，当前是哪个窗口占有，就返回哪个窗口的句柄。有了这个函数，我们还需要一个函数getcursorpos获取鼠标当前位置（针对于屏幕）；
可行的例子：模仿键盘按键：
#include<windows.h>
int main()
{
point curpos; //一个可储存坐标点的结构体变量，x横坐标，y,纵坐标，如curpos.x curpos.y
while(1)
{
getcursorpos(&curpos); //获取当前鼠标的位置，位置将储存在curpos里。
hwnd hwnd = windowfrompoint(curpos); //根据curpos所指的坐标点获取窗口句柄
sendmessage(hwnd,wm_char,wparam('g'),0); //发送一个字符（按键）消息g给当前鼠标所指向的窗口句柄
sleep(300); //睡眠三百毫秒，相当于等待三分之一秒
}
}
这个程序一运行后，只要把鼠标指向要输入字符的窗口句柄，那么就相当于键盘每三分之一秒按了一个g键，试试吧！
如果这样觉得模仿键盘按键太麻烦的话，那么就用keybd_event这个函数，这个专门用于模仿键盘按键的，关于怎么用，自己百度一搜，就知道了。既然sendmessage能模仿键盘按键的话，那也能模仿鼠标左击，右击。而此时sendmessage函数第三，四个参数的解释就是储存有鼠标左击，右击时的位置。如模仿鼠标右击，想一想，一次鼠标右击有哪几步，分别是鼠标右键按下，鼠标右键松开，如果你按下鼠标右键不松开，那它是不是鼠标右击，不是的，直到你松开鼠标右键，才能算是一次完整的鼠标右击.鼠标右键按下的消息类型是“wm_rbuttondown”，右键松开的消息是“wm_rbuttonup”，那么一次完整的鼠标右击应该是：
sendmessage(wnd,wm_rbuttondown,0,0); //鼠标右键按下,第三，四个参数说明了鼠标按下时的位置
sleep(100); //间隔100毫秒
sendmessage(wnd,wm_rbuttonup,0,0); //鼠标右键松开
同样，也有一个专门模仿鼠标动作的函数，mouse_event这个函数，可以模仿鼠标的移动，单击，双击等。以后会有专门介绍。
第三个：getcursorpos获取鼠标当前位置（屏幕）
这个函数在sendmessage函数有介绍，这里仅举一个例子，在界面里不停的输出鼠标当前位置。
#include<windows.h>
#include<stdio.h>
int main()
{
point curpos;
while(1)
{
getcursorpos(&curpos);
printf("x:%d,y:%d",curpos.x,curpos.y);
sleep(300);
printf("\n");
}
}
第四个：windowfrompoint根据坐标点获得对应的窗口句柄
在sendmessage有解释，这里仅举一个例子，鼠标指向哪个窗口，就关闭哪个窗口。
#include<windows.h>
int main()
{
sleep(2500); //等待一会儿，用于把鼠标移到其它窗口上去，避免指向本身进程的窗口，关掉自己的窗口。
point curpos;
while(1)
{
getcursorpos(&curpos);
hwnd wnd=windowfrompoint(curpos);
sendmessage(wnd,wm_close,0,0);
sleep(300);
}
}
第五个movewindow根据窗口句柄移动窗口，改变窗口大小
函数定义：bool movewindow( hwnd hwnd, int x, int y, int nwidth, int nheight, bool brepaint );
hwnd是要改变大小的窗口的句柄，x,y相对于屏幕的坐标，窗口左上角的位置与之相对应，nwidth和nheight是窗口新的宽高，brepaint指定窗口是否重画。
这里依旧以"无标题.txt - 记事本"为例子，改变这个窗口大小，并把窗口移到左上角去。
#include<windows.h>
int main()
{
hwnd wnd;
wnd=findwindow(null,"无标题.txt - 记事本");
movewindow(wnd,0,0,220,120,null);
return 0;
}
第六个showwindow设置窗口显示状态，如隐藏，最大化，最小化
函数定义bool showwinow(hwnd hwnd,int ncmdshow);
sw_hide：隐藏窗口并激活其他窗口。第一个参数hwnd指明了窗口句柄，第二个参数指明了窗口的状态，现在给出第二个参数常用取值范围：
sw_maximize：最大化指定的窗口。
sw_minimize：最小化指定的窗口并且激活在z序中的下一个顶层窗口。
sw_restore：激活并显示窗口。如果窗口最小化或最大化，则系统将窗口恢复到原来的尺寸和位置。在恢复最小化窗口时，应用程序应该指定这个标志。
sw_show：在窗口原来的位置以原来的尺寸激活和显示窗口。
showwindow例子：程序运行后，在桌面上隐藏一个指定的窗口，并在4秒后再将其显示
#include<windows.h>
int main()
{
hwnd wnd;
wnd=findwindow(null,"无标题.txt - 记事本");
showwindow(wnd,sw_hide);
sleep(5000);
showwindow(wnd,sw_show);
return 0;
}
第七个setcursorpos设置鼠标的位置、把鼠标移动到指定的位置
函数定义：bool setcursorpos(int x,int y);
这个函数的两个参数我想大家应该知道是什么意思吧，屏幕的坐标点。
直接看例子：
#include<windows.h>
int main()
{
int sec=0;
while(sec<200)
{
setcursorpos(rand()%1024,rand()%768); //随机设置鼠标的位置
sleep(20);
sec++;
}
return 0;
}
第八个copyfile复制一个文件
如何复制一个文件，比如，我要把e盘的abb.txt的文本文件复制到d盘的zhengyong.txt,则调用语句
copyfile("e:\\abb.txt","d:\\zhengyong.txt",false);
第三个参数有以下说明：
如果设为true（非零），那么一旦目标文件已经存在，则函数调用会失败。否则目标文件会被覆盖掉。
第九个deletefile删除一个文件
如何删除一个文件，语句：deletefile("e\\abb.txt");既是删除
如果目标为隐藏或只读，则无用。
第十个createdirectory创建一个文件夹（目录）
假如e盘下什么文件也没有
createdirectory("e:\\aaa\\bbb",null);这样是错的，不能同时建两个文件，除非e盘下已经有了个aaa文件夹了。
这样是对的createdirectory("e:\\aaa",null);
第十一个：getclientrect获得窗口大小
看例子：
#include<windows.h>
#include<stdio.h>
int main(int argc, char* argv[])
{
hwnd wnd;
while(1)
{
wnd=findwindow(null,"无标题.txt - 记事本");
rect rect; //专门用来存储窗口大小
getclientrect(wnd,&rect); //获取窗口大小
printf("%d,%d,%d,%d\n",rect.left,rect.top,rect.right,rect.bottom); //输出窗口大小，试着用鼠标改变窗口大小
sleep(300);
}
}
第十二个：getcwindowrect获得窗口大小（相对屏幕）
例子：
#include<windows.h>
#include<stdio.h>
int main(int argc, char* argv[])
{
hwnd wnd;
while(1)
{
wnd=findwindow(null,"无标题.txt - 记事本");
rect rect; //专门用来存储窗口大小
getwindowrect(wnd,&rect); //获取窗口大小
printf("%d,%d,%d,%d\n",rect.left,rect.top,rect.right,rect.bottom); //输出窗口大小，试着用鼠标改变窗口大小
sleep(300);
}
}
试着去找一下getclientrect和getwindowrect之间有什么区别；
第十三个findfirstfile寻找文件以及获得文件的信息
这里举一个例子吧，列举e盘第一目录下的所有文件，包括文件夹，结合findnextfile
#include<windows.h>
#include<stdio.h>
int main()
{
bool done=true;
win32_find_data fd;
handle hfind = findfirstfile("e:\\*.*", &fd); //第一个参数是路径名，可以使用通配符，懂dos的人应该知道吧！fd存储有文件的信息
while (done)
{
printf("%s\n",fd.cfilename);
done=findnextfile(hfind, &fd); //返回的值如果为0则没有文件要寻了
}
return 0;
}
当然也可以直接找一个文件，不使用通配符，但这样有什么意义呢？，如findfirstfile("e:\\aaa.txt",&fd);其实这个可以获取一个文件的信息，如文件是不是隐藏的，或者有没有只读属性等。
当然通过控制通配符，也可以寻找特定类型的文件，比如我只要找文本文件，那么就是这个语句findfirstfile("e:\\*.txt",&fd);就行了，关键看你自己灵活运用。
前面说过fd里存储有文件的信息，那怎么根据fd里面的成员判断这个文件的属性，文件是否隐藏，是不是文件夹。
fd里的dwfileattributes存储有文件的信息，如判断是否为文件夹，只要把这个变量和file_attribute_directory进行按位与运算，如果为1的话，表明为文夹件，如if(fd.dwfileattributes&file_attribute_directory==1) printf("%s是文件夹\n",fd.cfilename);
其它判断也是一样，现在给出文件的属性(常用几个）：file_attribute_hidden（隐藏）
file_attribute_readonly（只读）file_attribute_system（系统）
第十四个findnextfile寻找文件
参照findfirstfile函数的例子!
第十五个movefile移动文件
如把一个盘里的文本移到另一个盘里去:movefile("e:\\a.txt","d:\\abc.txt");即可，意思把e盘下的a.txt移到d盘下去，并改名为abc.txt
第十六个getclassname根据窗口句柄获得窗口类名
函数定义：int getclassname(hwnd hwnd, lptstr ipclassname, int nmaxcount)；
这种函数不需要再解释了吧，前面有太多类似的例子。
第十七个setfileattributes设置文件属性
函数定义：bool setfileattributes( lpctstr lpfilename, dword dwfileattributes);
这个函数的第二个参数dwfileattributes和前面讲过的win32_find_data结构里的dwfileattributes成员相对应。假设e盘第一目录下有一个文本文件a.txt的正常文件，我要把它设为只读和隐藏那要如何做呢？在前面介绍过win32_find_data结构里dwfileattributes成员的几个常用属性，根据这个我们知道隐藏是file_attribute_hidden，只读是file_attribute_readonly。
那么把e盘下文本文件的属性设为隐藏和只读的语句就是：
setfileattributes("e:\\a.txt",file_attribute_hidden|file_attribute_readonly);
(说明：这个函数同样也能设置文件夹属性）
虽然这个语句可以达到要求，但不建议用，因为会覆盖掉文件的原来属性，也就是说如果这个文件之前有系统属性（系统文件）的话，那么这个语句一旦执行后，文件就只有隐藏和只读属性了。
比如一个文件原先就有隐藏属性，依旧以a.txt为例子，那么我把它设为只读，是不是这个语句就可以呢？
setfileattributes("e:\\a.txt",file_attribute_readonly）;这样的话，虽然文件有只读属性了，但隐藏属性却没有了。
那要如何在不覆盖掉原来的属性下，把文件设为只读呢，其实说了这么多的废话，总结起来就一句话：如何增加一个文件的属性！
前提是要获得这个文件的原有属性：获得文件的属性，在findfirstfile函数讲过。好吧！直接看例子：
假设e盘的a.txt文件属性为隐藏，给它增加只读属性：
#include<windows.h>
int main()
{
win32_find_data fd;
findfirstfile("e:\\a.txt",&fd);
fd.dwfileattributes|=file_attribute_readonly; //在原来的属性下增加只读属性
setfileattributes("e:\\a.txt",fd.dwfileattributes); //设置文件的属性
return 0;
}
第二个例子：如何去掉一个文件的属性
（补习一下，懂的人直接跳过）
我想懂这里的按位或、按位与或者按位异或运算的人应该知道该如何去掉一个文件的属性。其实一个文件信息都是以二进制代码说明的。
比如一个八位二进制码：10000010，这里的每一位是不是只有0和1取值，不是0，就是1，正好符合一个文件属性的有无，如这个文件是隐藏的吗？只有是和不是，这样我们规定把这八位二进制码的第一位用于确定文件是否具有隐藏属性，如果为1那便是隐藏，无则没有，以此类推第二位就代表文件的只读，第三位系统。。。但要如何判断呢，或者把某一位的值改变呢，用按位运算就可以，00000010，我要把第2位的值设为0，其它位上的值保持不变，用按位异或运算即可，与00000010进行按位异或运算，但这里并不是与它本身进行运算，不管任何八位二进制数的值是多少只要与00000010进行按位异或运算，那第二位都会变成0，而其它的位保持不变。这样为了方便，我们就把00000010进行宏定义，方便记忆，这个二进制数的十进制为2。宏定义#define file_attribute_readonly 2
明白了这个我们就来清除一个文件的一种属性吧！
清除一个文件的隐藏属性，假设a.txt为隐藏文件：
#include<windows.h>
int main()
{
win32_find_data fd;
findfirstfile("e:\\a.txt",&fd); //获取文件信息
fd.dwfileattributes^=file_attribute_hidden; //在原来的属性下删除隐藏属性
setfileattributes("e:\\a.txt",fd.dwfileattributes); //设置文件的属性
return 0;
}
如果单单只针对文件的属性进行操作的话，可以用getfileattributes函数获取文件的属性，该函数只一个参数，那就是文件的路径，函数返回一个dword值，包含文件属性信息。
第十八个shellexecute运行一个程序
函数定义:shellexecute(hwnd hwnd, lpcstr lpoperation, lpcstr lpfile, lpcstr lpparameters, lpcstr lpdirectory, int nshowcmd);
第一个参数hwnd是父窗口的句柄,可以为null,第二个参数lpoperation表示行为,第三个参数lpfile是程序的路径名,第四个参数lpparameters是给所打开程序的参数,可以为null,第五个参数lpdirectory可以为null,第六个参数nshowcmd跟showwindow函数的第二个参数一样,作用也一样,如果打开的程序有窗口的话,这个参数就指明了窗口如何显示.
例如打开一个记事本:
shellexecute(null,"open","notepad.exe",null,null,sw_shownormal);
而且这个函数还可以指定程序打开一个属于程序本身类型的文件,假如e盘有一个a.txt文件;我调用函数运行记事本程序并打开这个文本文件.
shellexecute(null,"open","notepad.exe","e:\\a.txt",null,sw_shownormal);
这里由于记事本程序属于系统本身自带的程序,所以没有绝对路径.
这个函数还可以打开一个网站:
shellexecute(null,"open","http://www.baidu.com",null,null,sw_shownormal);
shellexecute(null,"open","c:",null,null,sw_shownormal);
类似的函数还有winexec，只有两个参数,它的最后一个参数跟shellexecute函数的最后一个参数一样.
而第一个参数则是程序路径名.举个例子:winexce("notepad.exe",sw_shownormal);
这个函数也可以给程序传递一个文件名供要运行的程序打开,那要如何加进去呢,这里又没有第三个参数,
方法把路径名加在notpepad.exe的后面,要以空格来分开如:
winexce("notepad.exe e:\\a.txt",sw_shownormal);
第十九个playsound播放一个wav文件
函数定义：bool playsound(lpcstr pszsound, hmodule hmod,dword fdwsound);
第一个参数是wav文件的路径名，第二个参数如果不是播放mfc里以资源id命名的文件，则可以为空，第三个参数，指明了以何种方式播放文件。注意这个函数只能播放100k以下的wav文件。
假如e盘有个a.wav文件，下面这个例子播放这个文件：
#include<windows.h>
#include<mmsystem.h> //playsound函数的头文件
#pragma comment(lib, "winmm.lib") //链接库，playsound函数必须使用
int main()
{
playsound("e:\\19.wav",null,snd_sync);
return 0;
}
第二十个getmodulefilename根据模块导入表获程序的完整路径
函数定义：dword getmodulefilename( hmodule hmodule, lptstr lpfilename, dword nsize );
关于第一个参数，将在以后的动态链接库里会有介绍，这里我们只要获得程序本身的路径，那么第一个参数可以为空。
第二个参数用以存储路径，nsize指明字符数组大小。
这个举个例子，运行后，把自身程序移动到e盘下，并改名为a.exe;
#include<windows.h>
int main()
{
char szappname[128]={0};
getmodulefilename(null,szappname,128);
movefile(szappname,"e:\\a.exe");
return 0;
}
第二十一个createwindow创建一个窗口
//补习懂的人直接跳过
之前api函数的例子，都是针对dos编程的，严格来说是在windows下的仿dos（cmd)进行编程，编写控制台应用程序大家都知道，主函数是main，那针对windows编程的主函数也是main吗？不是的，windows下的主函数（入口函数）是winmain。在定义main主函数的时候，可以给它带两个参数，也可以不带。而winmain函数就不能这样了，它有固定的格式，它必须带四个参数。
现给出winmain函数的固定格式：
int winapi winmain( hinstance hinstance, hinstance hprevinstance, instance lpstr lpcmdline, int ncmdshow)
大家如果有兴趣可以通过其它渠道了解一下各参数的意思，现在我们只需要知道winmain函数就是这样定义的，不理解也没关系。
知道了这个我们就来编一个windows程序吧！
因为我们是针对windows编程，所以要建一个win32 application工程，步骤是点击文件，然后选择新建，在弹出的对话框里选择工程，再选中win32 application 接着在右边的工程名称下填工程名称，名字随便取。之后点确定。接着又弹出了一个对话框，这里为了方便，我们选择“一个简单的 win32 程序”，点完成。接着双击winmain弹出代码编辑窗口，做完这个我们就可以打代码了。
简单的例子如下：
#include "stdafx.h"
int apientry winmain(hinstance hinstance,
hinstance hprevinstance,
lpstr lpcmdline,
int ncmdshow)
{
while(1)
sleep(100);
return 0;
}
怎么样够简单吧，是不是觉得奇怪，怎么没有窗口，因为窗口要自己创建，不像控制台程序，只要一运行便会有窗口。虽然没有窗口，但你创建了一个进程，打开任务管理器，可以找到你所创建的那个进程，其实也没什么奇怪的，像windows本身的一些系统服务，也是只有进程，没有窗口的像spoolsv.exe,svchost.exe。
那要如何创建一个窗口呢？要创建一个窗口,就必须要向系统提供窗口的信息，如你要创建的窗口名字叫什么，窗口图标是什么，窗口大小，窗口背景色等，不然，系统怎么给你创建窗口呢？所以为了方便，vc就定义了一个结构，专门用存储窗口信息。
现给出这个结构的定义。
typedef struct _wndclass {
uint style; //描述类风格
wndproc lpfnwndproc; //窗口处理函数
int cbclsextra; //表示窗口类结构之后分配的额外的字节数。系统将该值初始化为0
int cbwndextra; //表示窗口实例之后分配的额外的字节数。系统将该值初始化为0
hinstance hinstance; // 应用程序实例句柄由winmain函数传进来
hicon hicon; //窗口图标句柄
hcursor hcursor; //窗口光标句柄
hbrush hbrbackground; //画刷句柄
lpctstr lpszmenuname; //窗口菜单名
lpctstr lpszclassname; //窗口类名
} wndclass, *pwndclass;
好了，如果我们已经把窗口信息填好了，那我们要怎样把这个信息告诉系统呢，也就是把要创建窗口的信息传给系统。这里我们调用registerclass函数就能实现这个功能。注册完窗口，我们就要创建窗口,用createwindow函数就能实现，不要问为什么注册窗口后直接显示不就行了，还要搞什么创建窗口。这我也不知道，反正你只要记住这格式就行了，硬式规定的，你想创建一个窗口，就必须按这些步骤来。
好了，窗口创建了，我们就要调用showwindow函数显示窗口，然后用updatewindow函数刷新一下，确保窗口能立即显示。
以下详细实现代码：
#include "stdafx.h"
#include<windows.h>
int apientry winmain(hinstance hinstance,
hinstance hprevinstance,
lpstr lpcmdline,
int ncmdshow)
{
wndclass wndcls; //定义一个存储窗口信息wndclass变量
wndcls.cbclsextra=0; //默认为0
wndcls.cbwndextra=0; //默认为0
wndcls.hbrbackground=(hbrush)getstockobject(gray_brush); //背景画刷
wndcls.hcursor=loadcursor(null,idc_cross); //十字光标
wndcls.hicon=loadicon(null,idi_error); //窗口图标
wndcls.hinstance=hinstance; //应用程序实例句柄由winmain函数传进来
wndcls.lpfnwndproc=null; //窗口消息处理函数
wndcls.lpszclassname="windowclass"; //窗口类名
wndcls.lpszmenuname=null; //窗口菜单名，没有菜单，为null
wndcls.style=cs_hredraw | cs_vredraw; //窗口类型，cs_hredraw和cs_verdraw 表明
//当窗口水平方向垂直方向的宽度变化时重绘整个窗口
registerclass(&wndcls); //把窗口信息提交给系统，注册窗口类
hwnd hwnd; //用以存储createwindow函数所创建的窗口句柄
hwnd=createwindow("windowclass","first windows",
ws_overlappedwindow,0,0,600,400,null,null,hinstance,null);//创建窗口
showwindow(hwnd,sw_shownormal); //窗口创建完了，显示它
updatewindow(hwnd); //更新窗口，让窗口毫无延迟的显示
return 0;
}
是不是出错了，内存不能读取，为什么了呢，因为你创建的窗口没有消息处理函数，windows系统当然不允许这样一个窗口存在，对按键，鼠标都没有反应，这样的窗口是没有实际意义的。 wndcls.lpfnwndproc=null; //窗口消息处理函数，就是前面这句，必须要填
窗口过程（消息）处理函数，那这个函数是怎样定义的呢，像winmain一样，它也有固定的格式。
窗口过程处理函数的格式：lresult callback winsunproc(hwnd wnd,uint umsg,wparam wparam,lparam lparam)
下面的这个是一个窗口创建的完整例子：
#include "stdafx.h"
#include<windows.h>
lresult callback winsunproc(hwnd hwnd,uint umsg,wparam wparam,lparam lparam)
{
if(umsg==wm_lbuttondown) messagebox(null,"kdjfkdf","kjdfkdfj",mb_ok); //处理鼠标按下消息，弹出消息框
return defwindowproc(hwnd,umsg,wparam,lparam); //未处理的消息通过defwindowproc函数交给系统处理
}
int apientry winmain(hinstance hinstance,
hinstance hprevinstance,
lpstr lpcmdline,
int ncmdshow)
{
wndclass wndcls; //定义一个存储窗口信息wndclass变量
wndcls.cbclsextra=0; //默认为0
wndcls.cbwndextra=0; //默认为0
wndcls.hbrbackground=(hbrush)getstockobject(gray_brush); //背景画刷
wndcls.hcursor=loadcursor(null,idc_arrow); //光标
wndcls.hicon=loadicon(null,idi_error); //窗口图标
wndcls.hinstance=hinstance; //应用程序实例句柄由winmain函数传进来
wndcls.lpfnwndproc=winsunproc; //窗口消息处理函数
wndcls.lpszclassname="windowclass"; //窗口类名
wndcls.lpszmenuname=null; //窗口菜单名，没有菜单，为null
wndcls.style=cs_hredraw | cs_vredraw; //窗口类型，cs_hredraw和cs_verdraw 表明
//当窗口水平方向垂直方向的宽度变化时重绘整个窗口
registerclass(&wndcls); //把窗口信息提交给系统，注册窗口类
hwnd hwnd; //用以存储createwindow函数所创建的窗口句柄
hwnd=createwindow("windowclass","first windows",
ws_overlappedwindow,0,0,600,400,null,null,hinstance,null); //创建窗口
showwindow(hwnd,sw_shownormal); //窗口创建完了，显示它
updatewindow(hwnd); //更新窗口，让窗口毫无延迟的显示
msg msg; //消息结构类型
while(getmessage(&msg,null,0,0)) //获取消息
{
//translatemessage(&msg); //此函数用于把键盘消息(wm_keydown,wm_keyup)转换成字符消息wm_char
dispatchmessage(&msg); //这个函数调用窗口过程处理函数，并把msg里的信息处理后传给过程函数的四个参数
}
return 0;
}
winsunproc函数的四个参数，分别对应着sendmessage函数四个参数，详情参见sendmessage函数参数解释。
msg类型解释 ：
结构定义：
typedef struct tagmsg
{
hwnd hwnd; //hwnd表示消息将要发送给的窗口句柄
uint message; //消息类型，如wm_wmclose,wm_char,wm_lbuttondown,参见消息表
wparam wparam; //消息附带信息，取值的意思具体依据消息类型而定
lparam lparam; //消息附带信息，取值的意思具体依据消息类型而定
dword time; //消息的发送时间，不常用
point pt; //消息发送时，鼠标所在的位置，不常用
}msg;
大家试着把上面的例子运行一遍，然后关掉窗口，再运行一遍，是不是出错了，因为前一个程序虽然窗口关闭了，但进程还在运行，还记得那个循环语句吗？while(getmessage(&msg,null,0,0))就是这个。只要条件成立，进程就会一直运行下去。如何让这个循环结束呢？用 postquitmessage(0); 这个语句就行了，参数0表示给自身窗口发送一个退出消息，当getmessage函数接到postquitmessage函数发出的消息后，就会返回0值。
如在窗口过程函数中处理窗口关闭wm_close消息:if(umsg==wm_close）postquitmessage(0); 这样只要一关闭窗口，它的进程也会结束。
接下来解释一下createwindow函数参数的意思,函数定义
hwnd createwindow(lpctstr lpclassname, //窗口类名，应与wndclass结构里的成员lpszclassname一致
lpctstr lpwindowname,, //窗口标题名
dword dwstyle， //窗口的风格，取值参见表style
int x,
int y, //x,y表示所创建窗口左上角位置
int nwidth,
int nheight, //nwidth,nheight表示窗口的宽高
hwnd hwndparent, //父窗口句柄，如果不是子窗口，这里取值为null
hmenu hmenu, //菜单句柄，没菜单的话，取null值
handle hlnstance, //对应着winmain函数的第一个参数
lpvoid lpparam); //null
表style：（参考：百度）
ws_border：创建一个单边框的窗口。
ws_caption：创建一个有标题框的窗口（包括ws_boder风格）。
ws_child：创建一个子窗口。这个风格不能与ws_popup风格合用。
ws_chldwindow：与ws_child相同。
ws_clipchildren:当在父窗口内绘图时，排除子窗口区域。在创建父窗口时使用这个风格。
ws_cllpblings；排除子窗口之间的相对区域，也就是，当一个特定的窗口接收到wm_paint消息时，ws_clipsiblings 风格将所有层叠窗口排除在绘图之外，只重绘指定的子窗口。如果未指定ws_clipsiblings风格，并且子窗口是层叠的，则在重绘子窗口的客户区时，就会重绘邻近的子窗口。
ws_disabled:创建一个初始状态为禁止的子窗口。一个禁止状态的窗口不能接受来自用户的输入信息.
ws_dlgframe:创建一个带对话框边框风格的窗口。这种风格的窗口不能带标题条。
ws_group:指定一组控制的第一个控制。这个控制组由第一个控制和随后定义的控制组成，自第二个控制开始每个控制，具有ws_group风格，每个组的第一个控制带有ws_tabstop风格，从而使用户可以在组间移动。用户随后可以使用光标在组内的控制间改变键盘焦点。
ws_hscroll：创建一个有水平滚动条的窗口。
ws_iconic：创建一个初始状态为最小化状态的窗口。
与ws_minimize风格相同。
ws_maximize：创建一个初始状态为最大化状态的窗口。
ws_maximizebox：创建一个具有最大化按钮的窗口。该风格不能与ws_ex_contexthelp风格同时出现，同时必须指定ws_sysmenu风格。
ws_overlapped:产生一个层叠的窗口。一个层叠的窗口有一个标题条和一个边框。与ws_tiled风格相同。 ws_overlappedwindow：创建一个具有ws_overlapped，ws_caption，ws_sysmenu ws_thickframe，ws_minimizebox，ws_maximizebox风格的层叠窗口，与ws_tiledwindow风格相同。 ws_popup；创建一个弹出式窗口。该风格不能与ws_chld风格同时使用。
ws_popuwindow：创建一个具有ws_border，ws_popup,ws_sysmenu风格的窗口，ws_caption和ws_popupwindow必须同时设定才能使窗口某单可见。
ws_sizebox：创建一个可调边框的窗口，与ws_thickframe风格相同。
ws_sysmenu：创建一个在标题条上带有窗口菜单的窗口，必须同时设定ws_caption风格。
ws_tabstop：创建一个控制，这个控制在用户按下tab键时可以获得键盘焦点。按下tab键后使键盘焦点转移到下一具有ws_tabstop风格的控制。
ws_thickframe：创建一个具有可调边框的窗口，与ws_sizebox风格相同。
ws_tiled：产生一个层叠的窗口。一个层叠的窗口有一个标题和一个边框。
与ws_overlapped风格相同。
ws_tiledwindow:创建一个具有ws_overlapped，ws_caption，ws_sysmenu， ws_thickframe，ws_minimizebox，ws_maxmizebox风格的层叠窗口。与ws_overlappedwindow风格相同。
ws_visible创建一个初始状态为可见的窗口。
ws_vscroll：创建一个有垂直滚动条的窗口。
第二十二个getmessage获取窗口消息
参照createwindow函数例子，以后的例子可能是在控制台下，也可能是win32 application，大家以后根据主函数判断该建什么工程。
第二十三个registerclass注册窗口类，参照createwindow
第二十四个updatewindow参照createwindow
第二十五个dispatchmessage参照createwindow
第二十六个loadcursorfromfile从磁盘加载一个光标文件，函数返回该光标句柄
假设e盘下有一个名为a.cur的光标文件。
hcursor cursor //定义一个光标句柄，用于存放loadcursorfromfile函数返回的光标句柄
cursor=loadcursorfromfile("e:\\a.cur");
获得了光标句柄有什么用呢？看一下窗口类wndclass里的hcursor成员，这个成员也是一个光标句柄，明白了吧！
第二十七个createsolidbrush创建一个画刷，函数返回画刷句柄
hbrush hbr=createsolidbrush(rgb(12,172,59));//三个数字分别表明rgb的颜色值，rgb根据三种颜色值返回一个colorref类型的值
第二十八个loadimage装载位图、图标、光标函数
函数定义：handle loadimage(hinstance hinst,lpctstr lpszname,uint utype,int cxdesired,int cydesired,uint fuload)
这里我们只要这个函数的几个简单功能：从磁盘加载位图，从磁盘加载图标，从磁盘加载光标。所以第一个参数hinst我们不用管它，直接填null就行，第二个参数lpszname是图片文件所在路径名，第三个参数utype指明要加载的是什么类型的图片，
是位图（填image_bitmap），还是光标（填image_cursor），还是图标（填image_icon）。第四个cxdesired和第五个参数cydesired,指定要加载的图片的宽高（可以放大光标，或者缩小），如果加载的是位图的话，则两个参数必须为0，第六个参数fuload表示以何种方式加载文件，这里我们是从磁盘加载文件，所以填lr_loadfromfile;
好了，假设e盘下有一个c.cur和i.ico文件。例子：设置窗口图标和光标，还有背景色
#include "stdafx.h" //这个头文件是编译器自动生成的，不是空工程，都会有，
//如果是直接建c++源文件，包含这个头文件，会出错
#include <windows.h>
#include <stdio.h>
lresult callback winsunproc(
hwnd hwnd, // handle to window
uint umsg, // message identifier
wparam wparam, // first message parameter
lparam lparam // second message parameter
); //窗口过程函数声明
int winapi winmain(
hinstance hinstance, // handle to current instance
hinstance hprevinstance, // handle to previous instance
lpstr lpcmdline, // command line
int ncmdshow // show state
)
{
//设计一个窗口类
wndclass wndcls;
wndcls.cbclsextra=0;
wndcls.cbwndextra=0;
wndcls.hbrbackground=createsolidbrush(rgb(12,172,59)); //画刷
wndcls.hcursor=(hcursor)loadimage(null,"e:\\c.cur",image_cursor,24,24,lr_loadfromfile); //加载光标
wndcls.hicon=(hicon)loadimage(null,"e:\\i.ico",image_icon,48,48,lr_loadfromfile); //加载图标
wndcls.hinstance=hinstance; //应用程序实例句柄由winmain函数传进来
wndcls.lpfnwndproc=winsunproc; //定义窗口处理函数
wndcls.lpszclassname="windowclass";
wndcls.lpszmenuname=null;
wndcls.style=cs_hredraw | cs_vredraw;
registerclass(&wndcls);
//创建窗口，定义一个变量用来保存成功创建窗口后返回的句柄
hwnd hwnd;
hwnd=createwindow("windowclass","first window",
ws_overlappedwindow,0,0,600,400,null,null,hinstance,null);
//显示及刷新窗口
showwindow(hwnd,sw_shownormal);
updatewindow(hwnd);
//定义消息结构体，开始消息循环
msg msg;
while(getmessage(&msg,null,0,0))
{
translatemessage(&msg);
dispatchmessage(&msg);
}
return msg.wparam;
}
//编写窗口过程函数
lresult callback winsunproc(
hwnd hwnd, // handle to window
uint umsg, // message identifier
wparam wparam, // first message parameter
lparam lparam // second message parameter
)
{
switch(umsg)
{
case wm_char: //字符消息
char szchar[20];
sprintf(szchar,"char code is %c",wparam);
messagebox(hwnd,szchar,"char",0);
break;
case wm_lbuttondown: //鼠标左键按下消息
messagebox(hwnd,"mouse clicked","message",0);
break;
case wm_close:
if(idyes==messagebox(hwnd,"是否真的结束？","message",mb_yesno))
{
destroywindow(hwnd); //销毁窗口，并发送wm_destroy消息给自身窗口
}
break;
case wm_destroy:
postquitmessage(0);
break;
default:
return defwindowproc(hwnd,umsg,wparam,lparam);
}
return 0;
}
第二十九个getdc根据窗口句柄获取设备上下文（dc）返回dc句柄
得到了一个窗口的设备上下文，就可以进行画图操作了，像画圆，画正方形，显示图片等函数都是要设备上下文(dc）句柄做参数的。
hdc dc //定义一个dc句柄
hwnd wnd=findwindow(null,"无标题.txt - 记事本"); //获取窗口句柄
dc=getdc(wnd) //获取这个窗口的设备上下文
第三十个rectnagle在窗口中画一个矩形
以"无标题.txt - 记事本"窗口为例，在这个窗口简单的画一个矩形
#include<windows.h>
void main()
{
hdc dc;
hwnd wnd=findwindow(null,"无标题.txt - 记事本");
dc=getdc(wnd); //获取窗口设备上下文（dc）
while(1) //用循环语句重复画，是为了确保不会被窗口刷新给刷掉
{
rectangle(dc,50,50,200,200); //画一个矩形
sleep(200);
}
}
第三十个createtoolhelp32snapshot给当前进程拍一个照
handle hprocesssnap=::createtoolhelp32snapshot(th32cs_snapprocess,0);
//记住这种格式就行了，返回的句柄，存储有进程信息，可以用process32firs函数找出来。
第三十一个process32first根据createtoolhelp32snapshot函数返回的句柄获取进程信息
结合process32next函数使用，有点像文件寻找函数。
看完整例子：显示系统进程名，以及进程id号
#include<windows.h>
#include<tlhelp32.h> //声明快照函数的头文件
#include<stdio.h>
int main()
{
processentry32 pe32; //进程的信息将会存储在这个结构里
//在使用这个结构之前，先设置它的大小
pe32.dwsize=sizeof(pe32);
//给系统内的所有进程拍一个快照
handle hprocesssnap=::createtoolhelp32snapshot(th32cs_snapprocess,0);
bool bmore=::process32first(hprocesssnap,&pe32); //第一次查找
while(bmore)
{
printf("进程名称:%s\n",pe32.szexefile); //szexefile是进程名
printf("进程id号:%u\n\n",pe32.th32processid); //th32processid是进程id号
bmore=::process32next(hprocesssnap,&pe32); //寻找下个进程，函数返回0，则没有进程可寻
}
return 0;
}
第三十二个openprocess根据进程id号获得进程句柄，句柄通过函数返回
函数定义：handle openprocess( dword dwdesiredaccess, bool binherithandle, dword dwprocessid);
第一个参数不要管它，填process_all_access，第二个参数也一样，填false，那最后一个参数就是进程id号。
第三十三个terminateprocess结束一个进程（需进程句柄做参数）
该函数只有两个参数，第一个是进程句柄，第二个填0就行了。
现在给个例子：假设当前有一个进程名为abc.exe的进程正在运行，编一个程序结束它。
#include<windows.h>
#include<tlhelp32.h> //声明快照函数的头文件
int main(int argc,char *argv[])
{
processentry32 pe32;
//在使用这个结构之前，先设置它的大小
pe32.dwsize=sizeof(pe32);
//给系统内的所有进程拍一个快照
handle hprocesssnap=::createtoolhelp32snapshot(th32cs_snapprocess,0);
//遍历进程快照，轮流显示每个进程的信息
bool bmore=::process32first(hprocesssnap,&pe32);
while(bmore)
{
if(strcmp("abc.exe",pe32.szexefile)==0) //如果找到进程名为abc.exe
{
handle hprocess=openprocess(process_all_access,false,pe32.th32processid); //获取句柄
::terminateprocess(hprocess,0); //结束它
}
bmore=::process32next(hprocesssnap,&pe32); //寻找下一个
}
return 0;
}
上面的这个例子，只能结束普通权限进程，如果为系统进程的话，则没有用，结束不了。在后面的提升权限函数，会有例子说明如何结束系统进程。
第三十四个createpen创建一个画笔（返回画笔句柄）
函数定义：bool createpen(int npenstyle, int nwidth, colorref crcolor);
第一个参数，表示是什么类型的线，取值有以下：
如创建一个画笔：hpen pen=createpen(ps_solid,3,rgb(255,78,99));
ps_solid 画笔画出的是实线 ps_dash 画笔画出的是虚线（nwidth必须是1） ps_dot 画笔画出的是点线（nwidth必须是1）
ps_dashdot 画笔画出的是点划线（nwidth必须是1） ps_dashdotdot 画笔画出的是点-点-划线（nwidth必须是1）
第二个参数是画笔的宽度，第三个参数是画笔的颜色，colorref类型可以rgb来获得如rgb(233,128,88);分别是红绿蓝。
第三十五个createsolidbrush创建一个画刷
只有一个colorref类型的参数
hbrush brush=createsolidbrush(rgb(22,182,111));
第三十六个selectobject把gdi对象选入相应的dc中
像画笔(句柄hpen），画刷（hbursh），位图（hbitmap）等都是gid对象。因为画图函数，如画圆，画矩形，画直线，它们所画出图形，默认属性都是不变的，如线的宽度。那么想要改变画出来时线的宽度，比如我想画出来的图形它的线条宽度为5（像素），那么就要创建一个宽度为5的画笔，然后再通过selectobject函数，给这个画笔选入，就可以了.
接下举个例子:selectobject应用
#include "stdafx.h"
#include<windows.h>
lresult callback winsunproc(hwnd hwnd,uint umsg,wparam wparam,lparam lparam)
{
static hpen pen=createpen(ps_solid,3,rgb(255,78,99)); //创建画笔
static hbrush brush=createsolidbrush(rgb(22,182,111)); //创建画刷
if(umsg==wm_paint) //窗口需要重画的时候
{
hdc hdc;
paintstruct ps;
hdc=beginpaint(hwnd,&ps); //beginpaint只能在响应wm_paint,不能用getdc获取设备上下文
selectobject(hdc,pen); //选入画笔
selectobject(hdc,brush); //选入画刷
rectangle(hdc,100,100,200,200);
endpaint(hwnd,&ps);
}
else if(umsg==wm_close) //用户关闭了窗口
destroywindow(hwnd); //销毁窗口，并发送wm_destroy消息
else if(umsg==wm_destroy) //如果窗口被销毁
postquitmessage(0); //让进程退出
return defwindowproc(hwnd,umsg,wparam,lparam); //未处理的消息通过defwindowproc函数交给系统处理
}
int apientry winmain(hinstance hinstance,
hinstance hprevinstance,
lpstr lpcmdline,
int ncmdshow)
{
wndclass wndcls; //定义一个存储窗口信息wndclass变量
wndcls.cbclsextra=0; //默认为0
wndcls.cbwndextra=0; //默认为0
wndcls.hbrbackground=(hbrush)getstockobject(gray_brush); //背景画刷
wndcls.hcursor=loadcursor(null,idc_arrow); //光标
wndcls.hicon=loadicon(null,idi_error); //窗口图标
wndcls.hinstance=hinstance; //应用程序实例句柄由winmain函数传进来
wndcls.lpfnwndproc=winsunproc; //窗口消息处理函数
wndcls.lpszclassname="windowclass"; //窗口类名
wndcls.lpszmenuname=null; //窗口菜单名，没有菜单，为null
wndcls.style=cs_hredraw | cs_vredraw; //窗口类型，cs_hredraw和cs_verdraw 表明
//当窗口水平方向垂直方向的宽度变化时重绘整个窗口
registerclass(&wndcls); //把窗口信息提交给系统，注册窗口类
hwnd hwnd; //用以存储createwindow函数所创建的窗口句柄
hwnd=createwindow("windowclass","first windows",
ws_overlappedwindow,0,0,600,400,null,null,hinstance,null); //创建窗口
showwindow(hwnd,sw_shownormal); //窗口创建完了，显示它
updatewindow(hwnd); //更新窗口，让窗口毫无延迟的显示
msg msg; //消息结构类型
while(getmessage(&msg,null,0,0)) //获取消息
{
//translatemessage(&msg); //此函数用于把键盘消息(wm_keydown,wm_keyup)转换成字符消息wm_char
dispatchmessage(&msg); //这个函数调用窗口过程处理函数，并把msg里的信息处理后传给过程函数的四个参数
}
return 0;
}
第三十七个 readprocessmemory根据进程句柄读取相应的一段内存（读其它进程里的内存）
函数定义：bool readprocessmemory(handle hprocess,pvoid pvaddressremote,pvoid pvbufferlocal,dword dwsize,
pdword pdwnumbytesread);总共四个参数
第一个参数hprocess是远程进程句柄，被读取者 。第二个pvaddressremote是远程进程中内存地址。 从具体何处读取
pvbufferlocal是本地进程中内存地址. 函数将读取的内容写入此处 ，dwsize是要读取的字节数。要读取多少
pdwnumbytesread是实际读取的内容（函数执行后，实际读了多少字节，将存储在该变量里）
远程进程的内存地址是什么意思呢，比如我现在定义一个变量a,int a;就是了，大家知道int型是占四个字节的，也就是说如果a变量所占的内存起始地址是0x1234,那么变量a就占用0x1234,0x1235,0x1236,0x1237这四个字节，这四个字节的内容决定了a变量的值。
好了知道了这个，我们就来举个例子，读取另一个进程里一个变量的值：需设计两个程序，一个用于读（read)一个用于被读(beread);
那么要如何获得另一个进程中一个变量的地址呢?这里我们用一个简单的方法，让另一个进程自己去获取，然后输出地址值。
被读的程序代码如下：假设该进程名为：beread.exe
#include<stdio.h>
int main()
{
int a=10; //要读取的变量。
printf("%x\n",&a); //输出这个变量的起始地址，假设输出为12ff7c
while(1)
{
sleep(1000);
}
return 0;
}
必须先让这个程序运行，然后根据输出的地址值，才能在下面的程序填入地址值。
读取的程序代码如下：
#include<windows.h>
#include<stdio.h>
#include<tlhelp32.h>
int main()
{
//先要获取进程句柄，如何获取，参照terminateprocess函数，结束一个进程
handle reprocess;
processentry32 pe32;
pe32.dwsize=sizeof(pe32);
handle hprocesssnap=createtoolhelp32snapshot(th32cs_snapprocess,0);
bool bmore=::process32first(hprocesssnap,&pe32);
while(bmore)
{
if(strcmp(pe32.szexefile,"beread.exe")==0) //如果是beread.exe
{
reprocess=::openprocess(process_all_access,false,pe32.th32processid); //获取该进程句柄
break;
}
bmore=process32next(hprocesssnap,&pe32);
}
int *readdress=(int *)0x12ff7c; //要读取的内存的地址值
int *p=new int;
unsigned long size;
readprocessmemory(reprocess,readdress,p,4,&size); //读取beread进程的内存
printf("%d\n",*p); //输出读取来的值
return 0;
}
第三十八个writeprocessmemory根据进程句柄写入相应的一段内存（写入其它进程里的内存）
这个函数里的参数跟readprocessmemory函数参数意思一样，只不过一个是写，一个是读。
下面直接举个例子，形式跟读内存函数的例子一样。
被写的程序代码如下：假设该进程名为：bewrite.exe
#include<stdio.h>
int main()
{
int a=10;
printf("%x\n",&a); //假设输出为12ff7c
while(1)
{
printf("%d\n",a); //每隔一秒输出，查看值有没有改变
sleep(1000);
}
return 0;
}
写入的代码如下：
#include<windows.h>
#include<stdio.h>
#include<tlhelp32.h>
int main()
{
handle reprocess;
processentry32 pe32;
pe32.dwsize=sizeof(pe32);
handle hprocesssnap=createtoolhelp32snapshot(th32cs_snapprocess,0);
bool bmore=::process32first(hprocess
相关文章:
-
-
基于Java实现的一个简单亚马逊爬虫，用于监控图书优惠的情况并及时发送邮件通知 ... [阅读全文] -
python爬虫查询车站信息 目录: 1.找到要查询的url 2.对信息进行分析 3.对信息进行处理 python爬虫查询全拼相同的车站 目录： 1... [阅读全文]
-
JVM，全称Java Virtual Machine，即Java虚拟机。以Java作为编程语言所编写的应用程序都是运行在JVM上的。JVM是一种用于... [阅读全文]
-
表单域，可以按用途分为多种不同的类型，常见的有文本框、多行文本框、密码框、隐藏域、复选框、单选框和下拉选择框等，目的是用于采集用户的输入或选择的数据... [阅读全文]
-
版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 2386932994@qq.com 举报，一经查实将立刻删除。
上一篇： 到小区门口
下一篇： 护驾！奴才们快来护驾
发表评论