精华内容
下载资源
问答
  • Windows程序运行机制

    千次阅读 2014-07-20 17:23:22
    Windows程序内部运行机制 一、API与SDK Windows操作系统提供了各种各样的函数,以方便我们开发Windows应用程序,这些函数是Windows操作系统提供给应用程序编程的接口(Application Programming Interface),...
         在此声明,以下程序转载自原文地址,在此表示感谢!其中,我也加入了一些自己的理解,希望对大家的学习起到帮助作用。
    一、API与SDK
         Windows操作系统提供了各种各样的函数,以方便我们开发Windows应用程序,这些函数是Windows操作系统提供给应用程序编程的接口(Application Programming Interface),简称为API函数。我们在编写Windows程序时所说的API函数,就是指系统提供的函数,所有主要的Windows函数都在Window.h头文件中进行了说明微软提供的API函数大多是有意义的单词组合,每个单词的首字母大写。MSDN是微软为开发人员提供的一套帮助系统,其中包含大量的开发文档、技术文章和示例代码。SDK的全称是Software Development Kit,中文译为软件开发包。SDK实际上就是开发所需资源的一个集合,包括API函数库、帮助文档、使用手册、辅助工具等资源

    二、窗口与句柄
         窗口是Windows应用程序中一个非常重要的元素,一个Windows应用程序至少要有一个窗口,称为主窗口。窗口是屏幕上的一块矩形区域,是Windows应用程序与用户进行交互的接口。利用窗口,可以接受用户的输入,以及显示输出一个应用程序窗口通常包括标题栏、菜单栏、系统菜单、最小化框、最大化框、可调边框,有的还有滚动条。窗口可以分为客户区和非客户区。客户区是窗口的一部分,应用程序通常在客户区中显示文字或者绘制图形。标题栏、菜单栏、系统菜单、最小化框、最大化框、可调边框统称为窗口的非客户区,它们由Windows系统来管理,而应用程序则主要管理客户区的外观及操作。在Windows应用程序中,窗口是通过窗口句柄(HWND)来标识的。我们要对某个窗口进行操作,首先就要得到这个窗口的句柄。在Windows程序中,有各种各样的资源(窗口,图标、光标等),系统在创建这些资源时会为它们分配内存,并返回标识这些资源的标识号,即句柄。

    三、消息与消息队列
         在Windows中,不仅用户程序可以调用系统的API函数,系统也会调用用户自定义程序模块,这个调用是通过消息队列来进行的,从而完成用户自定义功能。Windows程序设计是一种基于事件驱动方式的程序设计模式,主要是基于消息响应的。用户与应用程序交互时,操作系统感知事件,将事件包装成一个消息,投递到应用程序的消息队列中,然后应用程序从消息队列中取出消息并进行响应。在这个处理过程中,操作系统也会给应用程序“发送消息”。所谓“发送消息”,实际上是操作系统调用程序中一个专门负责处理消息的函数,这个函数称为窗口过程。

    1)、消息
         在Windows程序中,消息是由MSG结构体定义的。MSG结构体的定义如下:
    typedef struct tagMSG {
        HWND   hwnd;     
        UINT   message;
        WPARAM wParam;
        LPARAM lParam;
        DWORD  time;
        POINT  pt;
    } MSG;
    第一个成员变量hwnd表示消息所属的窗口。我们通常开发的程序都是窗口应用程序,一个消息一般都是与某个窗口相关联的。例如,在某个活动窗口中按下鼠标左键,产生的按键消息就是发给该窗口的。在Windows程序中,用HWND类型的变量来标识窗口。
    第二个成员变量message指定了消息的标识符。在Windows中,消息是由一个数值来表示的,不同的消息对应不同的数值。但是由于数值不便于记忆,所以Windows将消息对应的数值定义为WM_XXX宏的形式,WM是Windows Message的缩写,XXX对应某种消息的英文拼写的大写形式。在程序中,我们通常都是以WM_XXX宏的形式来使用消息的。
    第三、第四个成员变量wParam和lParam,用于指定消息的附加信息。wParam、lParam表示的信息随消息的不同而不同,如果想知道这两个成员变量具体表示的信息,可以在MSDN中关于某个具体消息的说明文档查看到。在VC++开发环境下通过goto definition查看WPARAM和LPARAM这两种类型的定义,可以发现这两种类型实际上就是unsigned int和long。
    最后两个变量分别表示消息投递到消息队列中的时间和鼠标的当前位置。


    2)、消息队列
    每一个Windows应用程序开始执行后,系统都会为该程序创建一个消息队列,这个消息队列用来存放该程序创建的窗口的消息。Windows将产生的消息依次放到消息队列中,而应用程序则通过一个消息循环不断地从消息队列中取出消息,并进行响应。这种消息机制,就是Windows程序运行的机制。

    3)、进队消息和不进队消息
         Windows程序中的消息可以分为“进队消息”和“不进队消息”。进队的消息将由系统放入到应用程序的消息队列中,然后由应用程序取出并发送。不进队的消息在系统调用窗口过程时,直接发送给窗口。不管是进队消息还是不进队消息,最终都由系统调用窗口过程函数对消息进行处理。
     
    4)、WinMain函数
          当Windows操作系统启动一个程序时,调用该程序的WinMain函数(实际是由插入到可执行文件中的启动代码调用的)。WinMain是Windows程序的入口点函数,与DOC程序的入口点函数main的作用相同,当WinMain函数结束或返回时,Windows应用程序结束编写一个完整的Win32程序,该程序实现的功能是创建一个窗口,并在窗口中响应键盘及鼠标消息,程序实现的步骤为:
    A、WinMain函数的定义
    B、创建一个窗口
    C、进行消息循环
    D、编写窗口过程函数

    四、WinMain函数的定义
    WinMain函数的原形声明如下:
    int WINAPI WinMain(
      HINSTANCE hInstance,  // handle to current instance
      HINSTANCE hPrevInstance,  // handle to previous instance
      LPSTR lpCmdLine,      // pointer to command line
      int nCmdShow          // show state of window
    );
    WinMain函数接收4个参数,这些参数都是在系统调用WinMain函数时,传递给应用程序的。
    第一个参数hInstance表示该程序当前运行的实例的句柄,这是一个数值。当程序在Windows下运行时,它唯一标识运行中的实例注意,只有运行中的程序实例,才有实例句柄。一个应用程序可以运行多个实例,每运行一个实例,系统都会给该实例分配一个句柄值,并通过hInstance参数传递给WinMain函数;
    第二个参数hPrevInstance表示当前实例的前一个实例的句柄,在Win32环境下,这个参数总是NULL,即在Win32环境下,这个参数不再起作用;
    第三个参数lpCmdLine是一个以空终止的字符串,指定传递给应用程序的命令行参数。要在VC++开发环境中向应用程序传递参数,可以单击菜单Project-Setting,选择“Debug”选项卡,在“Program arguments”编辑框中输入你想传递给应用程序的参数;
    第四个参数nCmdShow指定程序的窗口应该如何显示,例如最大化、隐藏等。这个参数的值由该程序的调用者所指定,应用程序通常不需要去理会这个参数的值。
    关于WinMain函数前的修饰符WINAPI,其实就是_stdcall。

    五、窗口的创建
    A、创建一个完整的窗口,需要经过下面几个操作步骤:
    B、设计一个窗口类
    C、注册窗口类
    D、创建窗口
    E、显示及更新窗口
    1、设计一个窗口类
         一个完整的窗口具有许多特征,包括光标、图标、背景色等。在创建一个窗口前,必须对该类型的窗口进行设计,指定窗口的特征。Windows提供了WNDCLASS结构体来定义窗口特征,该结构体定义好一个窗口所具有的基本属性。WNDCLASS结构体的定义如下:
    typedef struct _WNDCLASS {
        UINT    style;
        WNDPROC lpfnWndProc;
        int     cbClsExtra;
        int     cbWndExtra;
        HANDLE  hInstance;
        HICON   hIcon;
        HCURSOR hCursor;
        HBRUSH  hbrBackground;
        LPCTSTR lpszMenuName;
        LPCTSTR lpszClassName;
    } WNDCLASS;
    第一个成员变量style指定了这一类型窗口的样式,常用的样式:
    CS_HREDRAW:当窗口水平方向上的宽度发生变化时,将重新绘制整个窗口。当窗口发生重绘时,窗口中的文字和图形将被擦除。如果没有指定这一样式,那么在水平方向上调整窗口的宽度时,将不会重绘窗口。
    CS_VREDRAW:当窗口垂直方向上的宽度发生变化时,将重新绘制整个窗口。如果没有指定这一样式,那么在垂直方向上调整窗口的宽度时,将不会重绘窗口。
    知识点:在Windows.h中,以CS_开头的类样式(Class Style)标识符被定义为16位的类常量,这些常量都只有某一位为1。用这种方式定义的标识符称为“位标志”,我们可以使用位运算操作符来组合使用这些样式。

    第二个成员变量lpfnWndProc是一个函数指针,指向窗口过程函数,窗口过程函数是一个回调函数,回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时由另外一方调用的,用于对该事件或条件进行响应。回调函数的实现机制是:
    1)、定义一个回调函数;
    2)、提供函数实现的一方在初始化的时候,将回调函数的函数指针注册给调用者;
    3)、当特定的事件或条件发生的时候,调用者使用函数指针调用回调函数对事件进行处理;
    针对Windows的消息处理机制,窗口过程函数被调用的过程如下:
    1)、在设计窗口类的时候,将窗口过程函数的地址付给lpfnWndProc成员变量;
    2)、调用RegisterClass(&wndclass)注册窗口类,那么系统就有了我们所编写的窗口过程函数的地址;
    3)、当应用程序接收到某一窗口的消息时,调用DispatchMessage(&msg)将消息回传给系统,系统则利用先前注册窗口类时得到的函数指针,调用窗口过程函数对消息进行处理。

         一个Windows程序可以包含多个窗口过程函数,一个窗口过程总是与某一特定的窗口类相关联,基于该窗口类创建的窗口使用同一个窗口过程。
    lpfnWndProc成员变量的类型是WNDPROC,在VC++开发环境中使用goto definition功能,可以看到WNDPROC的定义:
    typedef LRESULT (CALLBACK * WNDPROC)(HWND,UINT,WPARAM,LPARAM);
    LRESULT和CALLBACK实际上是long和_stdcall.从WNDPROC的定义可以知道,WNDPROC实际上是函数指针类型。注意:WNDPROC被定义为指向窗口过程函数的指针类型,窗口过程函数的格式必须与WNDPROC相同。
    知识点:在函数调用过程中,会使用栈。_stdcall与_cdecl是两种不同的函数调用约定,定义了函数参数入栈的顺序,由调用函数还是被调用函数将参数弹出栈,以及产生函数修饰名的方法。

    第三个成员变量cbClsExtra:Windows为系统中的每一窗口类管理一个WNDCLASS结构。在应用程序注册一个窗口类时,它可以让Windows系统为WNDCLASS结构分配和追加一定字节数的附加内存空间,这部分内存空间称为类附加内存,由属于这种窗口类的所有窗口所共享,类附加内存空间用于存储类的附加信息。Windows系统把这部分内存初始化为0。一般我们将这个参数设置为0;


    第四个成员变量cbWndExtra:Windows系统为每一个窗口管理一个内部数据结构,在注册一个窗口类时,应用程序能够指定一定字节数的附加内存空间,称为窗口附加内存。在创建这类窗口时,Windows系统就为窗口的结构分配和追加指定数目的附加内存空间,应用程序可用这部分内存存储窗口特有的数据。Windows系统把这部分内存初始化为0。一般我们将这个参数设置为0;

    第五个成员变量hInstance指定包含窗口过程的程序的实例句柄;

    第六个成员变量hIcon指定窗口类的图标句柄,这个成员变量必须是一个图标资源的句柄,如果这个成员为NULL,那么系统将提供一个默认的图标。在为hIcon变量赋值时,可以调用LoadIcon函数加载一个图标资源,返回系统分配给该图标的句柄。
    HICON LoadIcon(
      HINSTANCE hInstance, // handle to application instance
      LPCTSTR lpIconName   // icon-name string or icon resource
    );
    LoadIcon的第二个参数是LPCTSTR类型,实际被定义为CONST CHAR *,即指向字符常量的指针,而图标的ID是一个整数。对于这种情况,我们需要MAKEINTERSOURCE宏把资源ID标识符转换为需要的LPCTSTR类型。
    知识点:在VC++中,对于自定义的菜单、图标、光标、对话框等资源,都保存在资源脚本(通常扩展名为.rc)文件中。在VC++开发环境中,要访问资源文件,可以单击左边项目视图窗口底部的ResourceView选项卡,你将看到以树状列表形式显示的资源项目。在任何一种资源上双击鼠标左键,将打开资源编辑器。在资源编辑器中,以“所见即所得”的方式对资源进行编辑。资源文件本身是文本文件格式,如果了解资源文件的编写格式,也可以直接使用文本编辑器对资源进行编辑。
    在VC++中,资源是通过标识符(ID)来标识的,同一个ID可以标识多个不同的资源。资源的ID实质上是一个整数,在“resource.h”中定义为一个宏。我们在为资源指定ID的时候,应该养成一个良好的习惯,即在“ID”后附加特定资源英文名称的首字母,例如,菜单资源为IDM_XXX,图标资源为:IDI_XXX。采用这种方式时,我们在程序中使用资源ID时,可以一目了然

    第七个成员变量hCursor指定窗口类的光标句柄,这个成员变量必须是一个光标资源的句柄。

    第八个成员变量hbrBackground指定窗口类的背景画刷句柄。当窗口发生重绘时,系统使用这里指定的画刷来擦除窗口的背景。我们可以调用GetStockObject函数来得到系统的标准画刷,GetStockObject函数不仅可以用于获取画刷句柄,还可以用于获取画笔、字体和调色板的句柄。

    第九个成员变量lpszMenuName是一个以空终止的字符串,制定菜单资源的名字。如果使用菜单资源的ID号,那么需要用MAKEINTERSOURCE宏来进行转换。要注意,菜单并不是一个窗口。

    第十个成员变量lpszClassName是一个以空终止的字符串,指定窗口类的名字。

    六、消息循环
         在创建窗口、显示窗口、更新窗口后,需要编写一个消息循环,不断地从消息队列中取出消息,并进行响应。要从消息队列中取出消息,需要调用GetMessage()函数,该函数的原型声明如下:
    BOOL GetMessage(
      LPMSG lpMsg,         // address of structure with message
      HWND hWnd,           // handle of window
      UINT wMsgFilterMin,  // first message
      UINT wMsgFilterMax   // last message
    );
    参数lpMsg指向一个消息结构体,GetMessage从线程的消息队列中取出的消息信息将保存在该结构体对象中;
    参数hWnd指定接收属于哪一个窗口的消息。通常将其设置为NULL,用于接收属于调用线程的所有窗口的窗口消息;
    参数wMsgFilterMin指定要获取的消息的最小值,通常设置为0;
    参数wMsgFilterMax指定要获取的消息的最大值。如果wMsgFilterMin和wMsgFilterMax都设置为0,则接受所有消息。

          GetMessage函数接收到除了WM_QIUT外的消息均返回非零值。对于WM_QIUT消息,该函数返回零。如果出现了错误,该函数返回-1。编写的消息循环代码如下:
    MSG msg;
    while(GetMessage(&msg,NULL,0,0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
        GetMessage函数只有在接收到WM_QIUT消息时,才返回0。此时,while语句判断的条件为假,循环退出,程序才有可能结束运行。在没有接收到WM_QIUT消息时,Windows应用程序就通过这个while循环来保证程序始终处于运行状态;
    TranslateMessage函数用于将虚拟键消息转换为字符消息。字符消息被投递到调用线程的消息队列中,当下一次调用GetMessage函数时被取出。当我们敲击键盘上的某个字符键时,系统将产生WM_KEYDOWN和WM_KEYUP消息。这两个消息的附加参数包含的是虚拟键代码和扫描码等信息,而我们在程序中需要得到某个字符的ACSII码,TranslateMessage 函数就可以将WM_KEYDOWN和WM_KEYUP消息的组合转换为一条WM_CHAR消息(该消息的wParam附加参数包含了字符的ASCII码),并将转换后的新消息投递到线程的消息队列中。注意,TranslateMessage函数并不会修改原有的消息,它只是产生新的消息并投递到消息队列中;
    DispatchMessage函数分派一个消息到窗口过程,由窗口过程对消息进行处理。DispatchMessage实际上是将消息回传给操作系统,由操作系统调用窗口过程对消息进行处理。

    Windows应用程序的消息处理机制:
    1、操作系统接收到应用程序的窗口消息,将消息投递到该应用程序的消息队列中;
    2、应用程序在消息循环中调用GetMessage函数从消息队列中取出一条一条的消息。取出消息后,应用程序可以对消息进行一些预处理;
    3、应用程序调用DispatchMessage,将消息回传给操作系统。消息由MSG结构体对象来表示,其中包含了接收消息的窗口的句柄。因此,DispatchMessage函数总能进行正确的传递;
    4、系统利用WNDCLASS结构体的lpfnWndProc成员保存的窗口过程函数的指针调用窗口过程,对消息进行处理(即“系统给应用程序发送了消息”)。
    提示:从消息队列中获取消息还可以调用PeekMessage函数;发送消息可以使用SendMessage和PostMessage函数。SendMessage函数将消息直接发送给窗口,并调用该窗口的窗口过程进行处理。在窗口过程对消息处理完毕后,该函数才返回。PostMessage函数将消息放入到与创建窗口的线程相关的消息队列后立即返回。

    七、编写窗口过程函数
          一个Windows应用程序的主要代码部分就集中在窗口过程函数中,该函数的声明形式如下:
    LRESULT CALLBACK WindowProc(
      HWND hwnd,      // handle to window
      UINT uMsg,      // message identifier
      WPARAM wParam,  // first message parameter
      LPARAM lParam   // second message parameter
    );
         窗口过程函数的名字可以任意取,但函数定义的形式必须和上述声明的形式一致。WindowProc函数的4个参数分别对应消息的窗口句柄、消息代码、消息代码的两个附加参数。一个程序可以有多个窗口,窗口过程函数的第1个参数hwnd就标识了接收消息的特定窗口。在窗口过程函数内部使用switch/case语句来确定窗口过程接收的是什么消息,以及如何对这个消息进行处理。

    八、 小结
         创建一个Win32应用程序的步骤:编写WinMain函数,可以在MSDN上查找并复制,设计窗口类,注册窗口类,显示并更新窗口,编写消息循环,编写窗口过程函数。
    展开全文
  • windows程序运行机制

    千次阅读 2014-08-14 22:03:05
    三.windows内部程序内部运行机制  一般windows程序要经过以下流程,注册窗口、创建窗口、显示和更新窗口、进入消息循环、消息处理! 1.注册窗口类 WNDCLASSEX结构体: typedef struct _WNDCLASSEX { ...

    一.字符集的编码

    对字符集的编码可以使用8位和16位进行编码,ASCII编码使用了一个字节进行编码,Unicode用两个字节进行编码,最多可以表示65536个字符;ASCII码当初的设计只是针对美国英语设计的。对于其他国家而言,一个字节最多只能够256个字符,对于汉字,最常用的汉字就多大6000多个。显然用一个字节并不能够完全表示所有的汉字;因此,16位编码可以表示多国言语,对于国际语言的转换变得方便。

    宽字符集:使用两个字节对字符进行编码,计算机判断宽字符集的字符串是否结束,通过连续两个‘\0’进行识别,即当出现两个连续的字符'\0'时就认为此字符串结束;unicode属于宽字符集。

    多字节字符集:一个字节或者两个字节,当遇到‘\0’就判定是字符串结尾。

        因此,使用前必须确定使用的字符集,不然会带来一些不必要的麻烦;windows程序是如何兼容两种字符集的,在tchar.h头文件中有如下的宏定义

     

    #ifdef  _UNICODE
    
      #define _tcslen    wcslen
      #deine  TCHAR  wchar_t
      #define LPTSTR wchar_t *
      #define _T(x)   L##x
    #else
      #define _tcslen    strlen
      #deine  TCHAR  char
      #define LPTSTR char *
      #define _T(x)   x
    #endif
    这里只列出部分宏定义,因此我们可以通过宏定义实现两种编码的兼容;幸运地是,这些微软已经帮我们做好了,我们只要会用就行了。


    二.预备知识

    (1)句柄(HANDLE):句柄是windows中一个必要重要的概念,是windows程序中的一种资源标识符,通过句柄可以区分不同的资源,从而可以方便我们管理资源。windows中有很多资源,包括窗口(HWND)、光标(HCURSOR)、图标(HICON)、画刷(HBRUSH)等。

    (2)窗口(window):窗口分为客户区和非客户区;非客户无包括标题栏、菜单栏、工具栏和窗口边框,客户区是用来与客户打交道的区域

    (3)消息:windows程序设计是一种事件驱动的方式,基于消息的;操作系统感知特定窗口的事件,并把它打包成消息,放到应用程序的消息队列中,然后应用程序从消息队列中取出消息并对此进行响应。当应用程序需要响应某一个消息时,从消息队列中取出消息,并把此消息分发给操作系统,由操作系统完成对应用程序的消息处理函数的调用。

    进队消息:进入消息队列。

    不进队消息:系统调用窗口过程时直接发送给窗口。

    (4)winmain():winmain函数是windows程序的入口点函数,声明形式如下:

    int WINAPI WinMain(  HINSTANCE hInstance,      // handle to current instance
      HINSTANCE hPrevInstance,  // handle to previous instance
      LPSTR lpCmdLine,          // command line
      int nCmdShow              // show state);

    第一个参数:应用程序的实例句柄,用于标识不同的应用程序

    第二个参数:当前实例的前一个实例的句柄

    第三个参数:命令行参数;如一个文本应用程序,当文本应用程序打开一个文本文档时,需要把文本文档的路径传给文本应用程序

    第四个参数:指定程序的窗口应该如何显示,最大化、最小化、隐藏等。


    三.windows内部程序内部运行机制

        一般windows程序要经过以下流程,注册窗口、创建窗口、显示和更新窗口、进入消息循环、消息处理!

    1.注册窗口类

    WNDCLASSEX结构体:

    typedef struct _WNDCLASSEX { 
        UINT       cbSize; 
        UINT       style; 
        WNDPROC    lpfnWndProc; 
        int        cbClsExtra; 
        int        cbWndExtra; 
        HINSTANCE  hInstance; 
        HICON      hIcon; 
        HCURSOR    hCursor; 
        HBRUSH     hbrBackground; 
        LPCTSTR    lpszMenuName; 
        LPCTSTR    lpszClassName; 
        HICON      hIconSm; 
    } WNDCLASSEX, *PWNDCLASSEX; 

    总共有12个属性:以EX为后缀的函数,代表是原先函数的扩展版本

    cbSize:WNDCALSSEX结构体类型的大小  sizeof(WNDCLASSEX)

    style:窗口的样式 ;一般有CS_VERDRAW,CS_HREDRAW,

    cbWndEXtra: 指定窗口附加内存,一般为0

    cbClsEXtra:指定窗口类型额外的内存,一般为0

    lpfnWndProc:窗口回调函数

    hInstance:窗口实例句柄

    hIcon:窗口类的图标句柄 LoadIcon();函数装载

    hCursor:窗口类光标句柄LoadCursor()函数装载

    hbrBackground:背景颜色,一般用HGDIOBJ GetStockObject(int);获取标准画刷;

    lpzsMenuName:菜单资源的名字,菜单资源的ID号,一般需要用MAKEINTERSOURCE宏进行类型转换;

    lpszClassName:窗口类的名字

    hIconSm:

     然后调用ATOM RegisterClassEx( CONST WNDCLASSEX *)对窗口进行注册;

    const TCHAR * lpszClassName= _T("MyWinows");
    	WNDCLASSEX wndcls;
    	wndcls.cbClsExtra=0;
    	wndcls.cbWndExtra=0;
    	wndcls.cbSize=sizeof(WNDCLASSEX);
    	wndcls.hbrBackground=(HBRUSH)COLOR_GRAYTEXT;
    	wndcls.hCursor=LoadCursor(NULL,IDC_CROSS);
    	wndcls.hIcon=LoadIcon(NULL,IDI_QUESTION);
    	wndcls.hIconSm=NULL;
    	wndcls.hInstance=hInstance;
    	wndcls.lpfnWndProc=WindowProc;
    	wndcls.lpszClassName = lpszClassName;
    	wndcls.lpszMenuName=NULL;
    	wndcls.style=CS_VREDRAW | CS_HREDRAW;
    	//12条属性
    	bool nRet=::RegisterClassEx(&wndcls);
    		if (!nRet)
    		{
    			::MessageBox(NULL,_T("注册窗口类失败"),_T("注册窗口"),MB_OK);
    			return FALSE;
    		}


    2.创建窗口

    HWND CreateWindowEx(  DWORD dwExStyle,      // extended window style
      LPCTSTR lpClassName,  // registered class name
      LPCTSTR lpWindowName, // window name  
      DWORD dwStyle,        // window style
      int x,                // horizontal position of window
      int y,                // vertical position of window
      int nWidth,           // window width  
      int nHeight,          // window height
      HWND hWndParent,      // handle to parent or owner window
      HMENU hMenu,          // menu handle or child identifier
      HINSTANCE hInstance,  // handle to application instance
      LPVOID lpParam        // window-creation data);

     窗口风格dwStyle是以WS_开始的宏,在window.h文件中;(x,y)窗口左上角的坐标,nWidth,nHeight分别是窗口的宽度和高度;

    lpParam:作为WM_CREATE消息的附加参数lpParam传入的数据指针;

    	HWND hWnd=::CreateWindowEx(0,lpszClassName,_T("时间的流逝"),
    		WS_OVERLAPPEDWINDOW | WS_VISIBLE,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,
    		NULL,NULL,hInstance,NULL);
    	if (NULL==hWnd)
    	{
    		::MessageBox(NULL,_T("创建窗口失败"),_T("创建窗口"),MB_OK);
    		return FALSE;
    	}


    3.显示和更新窗口

    ::ShowWindow(hWnd,SW_SHOW);
    ::UpdateWindow(hWnd);
    窗口的显示状态:SW_开头的宏;

    4.消息循环

    	MSG msg;
    	while (::GetMessage(&msg,NULL,NULL,NULL))
    	{
    		::TranslateMessage(&msg);
    		::DispatchMessage(&msg);
    	}

    当GetMessage接收到除WM_QUIT消息之外都返回非零值,即一直在消息循环;

    TranslateMessage();用于虚拟键转换成字符消息,比如可以把WM_KEYDOWN和WM_KEYUP转换成WM_CHAR消息,然后投递到消息队列中。

    DispatchMessage()把消息分发给窗口过程,由窗口过程函数对消息进行处理,实际上把消息回传给操作系统;

    windows消息处理机制:

    (1)操作系统接收到应用程序的窗口消息,将消息投递到该应用程序的消息队列中。
    2)应用程序在消息循环中调用GetMessage函数从消息队列中取出一条条的消息。取出后,以对消息进行一些预处理,如放弃对某些消息的响应,或者调用TranslateMessage产生新的消息
    3)应用程序调用DispatchMessage,将消息回传给操作系统。消息是由MSG结构体对象来表示的,其中就包含了接收消息的窗口的句柄。因此,DispatchMessage函数总能进行正确的传递。

    4)系统利用WNDCLASS结构体的lpfnWndProc成员保存的窗口过程函数的指针调用窗口过程,对消息进行处理(即“系统给应用程序发送了消息”)。

    5.消息处理

    LRESULT CALLBACK WindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, 
    	LPARAM lParam )
    {
    	switch (uMsg)
    	{
    	case WM_CLOSE:
    		::DestroyWindow(hWnd);
    		break;
    	case WM_DESTROY:
    		::PostQuitMessage(0);
    		break;
    	case WM_PAINT:
    		HDC hdc;
    		RECT clientRect;
    		GetClientRect(hWnd,&clientRect);
    		PAINTSTRUCT ps;
    		 hdc=BeginPaint(hWnd,&ps);  //获取设备描述表
    		//DrawText(hdc,_T("www.lppmww.com"),_tcslen(_T("www.lppmww.com")),&clientRect,DT_SINGLELINE|DT_BOTTOM);
    		 TextOut(hdc,100,0,_T("www.lppmww.com"),_tcslen(_T("www.lppmww.com")));
    		EndPaint(hWnd,&ps);
    		break;
    	default:
    		break;
    	}
    
    	return ::DefWindowProc(hWnd,uMsg,wParam,lParam);  //默认的窗口过程
    }

    系统是通过窗口过程函数的地址来调用窗口过程函数的;beginPaint和endPaint只能在WM_PAINT消息的响应函数中;

    windows绘图:

    一般我们生活中要完成绘图过程,需要以下几个元素:画家、画图工具、画图技巧;windows程序与之相对应的是

    画家:设备描述表

    画图工具:画笔、画刷、位图等

    画图技巧:windows提供的API函数,画点、划线函数;

    在windows中,我们要想绘图,

    首先应该获取设备描述表,把绘图工具选入设备描述表,然后调用windows提供的API函数;

    获取设备描述表的方法:

    (1)beginPaint()和EndPaint(),在WM_PAINT消息响应函数里面用

    (2)GetDC()和ReleaseDC(),在客户区绘图

    (3)GetWindowDC()和ReleaseDC()  在非客户区绘图


    代码:

    #include <tchar.h>
    #include <Windows.h>
    //编写兼容两种字符的winMain
    LRESULT CALLBACK WindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, 
    	LPARAM lParam ); 
    //编写兼容两种字符的winMain
    int WINAPI _tWinMain(  HINSTANCE hInstance,      // handle to current instance
    	HINSTANCE hPrevInstance,  // handle to previous instance
    	LPTSTR lpCmdLine,          // command line
    	int nCmdShow              // show state
    	)
    {  
    	const TCHAR * lpszClassName= _T("MyWinows");
    	WNDCLASSEX wndcls;
    	wndcls.cbClsExtra=0;
    	wndcls.cbWndExtra=0;
    	wndcls.cbSize=sizeof(WNDCLASSEX);
    	wndcls.hbrBackground=(HBRUSH)COLOR_GRAYTEXT;
    	wndcls.hCursor=LoadCursor(NULL,IDC_CROSS);
    	wndcls.hIcon=LoadIcon(NULL,IDI_QUESTION);
    	wndcls.hIconSm=NULL;
    	wndcls.hInstance=hInstance;
    	wndcls.lpfnWndProc=WindowProc;
    	wndcls.lpszClassName = lpszClassName;
    	wndcls.lpszMenuName=NULL;
    	wndcls.style=CS_VREDRAW | CS_HREDRAW;
    	//12条属性
    	bool nRet=::RegisterClassEx(&wndcls);
    		if (!nRet)
    		{
    			::MessageBox(NULL,_T("注册窗口类失败"),_T("注册窗口"),MB_OK);
    			return FALSE;
    		}
    	HWND hWnd=::CreateWindowEx(0,lpszClassName,_T("时间的流逝"),
    		WS_OVERLAPPEDWINDOW | WS_VISIBLE,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,
    		NULL,NULL,hInstance,NULL);
    	if (NULL==hWnd)
    	{
    		::MessageBox(NULL,_T("创建窗口失败"),_T("创建窗口"),MB_OK);
    		return FALSE;
    	}
    	::ShowWindow(hWnd,SW_SHOW);
    	::UpdateWindow(hWnd);
    
    	MSG msg;
    	while (::GetMessage(&msg,NULL,NULL,NULL))
    	{
    		::TranslateMessage(&msg);
    		::DispatchMessage(&msg);
    	}
    }
    LRESULT CALLBACK WindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, 
    	LPARAM lParam )
    {
    	switch (uMsg)
    	{
    	case WM_CLOSE:
    		::DestroyWindow(hWnd);
    		break;
    	case WM_DESTROY:
    		::PostQuitMessage(0);
    		break;
    	case WM_PAINT:
    		HDC hdc;
    		RECT clientRect;
    		GetClientRect(hWnd,&clientRect);
    		PAINTSTRUCT ps;
    		 hdc=BeginPaint(hWnd,&ps);  //获取设备描述表
    		//DrawText(hdc,_T("www.lppmww.com"),_tcslen(_T("www.lppmww.com")),&clientRect,DT_SINGLELINE|DT_BOTTOM);
    		 TextOut(hdc,100,0,_T("www.lppmww.com"),_tcslen(_T("www.lppmww.com")));
    		EndPaint(hWnd,&ps);
    		break;
    	default:
    		break;
    	}
    
    	return ::DefWindowProc(hWnd,uMsg,wParam,lParam);  //默认的窗口过程
    }


    展开全文
  • 通过编写一个简单的win32对话框程序,回顾了一下windows程序运行机制。   #include &lt;Windows.h&gt; #include &lt;stdio.h&gt; //操作系统将每个事件包装成消息放入消息队列中,应用程序从...

    通过编写一个简单的win32对话框程序,回顾了一下windows程序的运行机制。

     

    #include <Windows.h>
    #include <stdio.h>
    
    //操作系统将每个事件包装成消息放入消息队列中,应用程序从消息队列中获取消息并做相应处理
    
    //消息回调函数声明
    LRESULT CALLBACK Winmypro(          
    						  HWND hwnd,
    						  UINT uMsg,
    						  WPARAM wParam,
    						  LPARAM lParam
    						  );
    
    //入口函数
    int WINAPI WinMain(          
    				   HINSTANCE hInstance,
    				   HINSTANCE hPrevInstance,
    				   LPSTR lpCmdLine,
    				   int nCmdShow
    				   )
    {
    	//设计窗口类
    	WNDCLASS wnd;
    	wnd.cbClsExtra = 0;
    	wnd.cbWndExtra = 0;
    	wnd.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    	wnd.hCursor = LoadCursor(NULL,IDC_CROSS);
    	wnd.hIcon = LoadIcon(NULL,IDI_ERROR);
    	wnd.hInstance = hInstance;
    	wnd.lpfnWndProc = Winmypro;
    	wnd.lpszClassName = "zhang";
    	wnd.lpszMenuName = NULL;
    	wnd.style = CS_HREDRAW | CS_VREDRAW;
    
    	//注册窗口类
    	RegisterClass(&wnd);
    
    	//创建窗口
    	HWND hWnd;
    	hWnd = CreateWindow("zhang","Windows程序运行机制",WS_OVERLAPPEDWINDOW,0,0,600,400,NULL,NULL,hInstance,NULL);
    
    	//显示窗口
    	ShowWindow(hWnd,SW_NORMAL);
    
    	//更新窗口
    	UpdateWindow(hWnd);
    
    	//从消息队列获取消息
    	MSG msg;
    	while(GetMessage(&msg,NULL,0,0))
    	{
    		TranslateMessage(&msg);
    		DispatchMessage(&msg);
    	}
    
    	return 0;
    }
    
    //回调函数实现
    LRESULT CALLBACK Winmypro(          
    						  HWND hwnd,
    						  UINT uMsg,
    						  WPARAM wParam,
    						  LPARAM lParam
    						  )
    {
    	switch(uMsg)
    	{
    	case WM_CHAR:
    		char szchar[20];
    		sprintf(szchar,"char is %d",wParam);
    		MessageBox(hwnd,szchar,"注意",MB_OK);
    		break;
    	case WM_LBUTTONDOWN:
    		MessageBox(hwnd,"mouse click","文字",MB_OK);
    		HDC hDC;
    		hDC = GetDC(hwnd);
    		TextOut(hDC,0,50,"Windows运行机制",strlen("Windows运行机制"));
    		ReleaseDC(hwnd,hDC);
    		break;
    	case WM_PAINT://每当窗口发生重绘
    		HDC hDC1;
    		PAINTSTRUCT ps;
    		hDC1 = BeginPaint(hwnd,&ps);
    		TextOut(hDC1,0,0,"Windows运行机制_重绘了",strlen("Windows运行机制_重绘了"));
    		EndPaint(hwnd,&ps);
    		break;
    	case WM_CLOSE://窗口关闭时
    		if(IDYES == MessageBox(hwnd,"确认结束?","提示",MB_YESNO))
    		{
    			DestroyWindow(hwnd);//销毁窗口,并产生WM_DESTROY消息
    		}
    		break;
    	case WM_DESTROY:
    		PostQuitMessage(0);//向系统发送关闭程序消息
    		break;
    	default:
    		return DefWindowProc(hwnd,uMsg,wParam,lParam);
    	}
    	return 0;
    }
    
    //相关函数:
    //消息结构体
    typedef struct tagMSG { 
    HWND hwnd; 	   //Handle to the window whose window procedure receives the message. 资源的标识
    UINT message;  //Unsigned int,Specifies the message identifier.消息的标识,消息用宏表示
    WPARAM wParam; //Specifies additional information about the message.附加消息
    LPARAM lParam; //Specifies additional information about the message.
    DWORD time;    //Double WORD,32-bit unsigned int.Specifies the time at which the message was posted. 
    POINT pt;      //The POINT structure defines the x- and y- coordinates of a point. 
    }MSG;
    
    //其中
    typedef struct tagPOINT { 
      LONG x; 
      LONG y; 
    } POINT, *PPOINT;
    
    HICON LoadIcon(
      HINSTANCE hInstance, // handle to application instance
      LPCTSTR lpIconName   // name string or resource identifier
    );
    
    //注册:
    ATOM RegisterClass(
      CONST WNDCLASS *lpWndClass  // class data
    );
    
    //创建:
    HWND CreateWindow(
      LPCTSTR lpClassName,  // registered class name.注册的窗口类名
      LPCTSTR lpWindowName, // window name.窗口名字
      DWORD dwStyle,        // window style.窗口类型
      int x,                // horizontal position of window窗口水平坐标(窗口左上角)
      int y,                // vertical position of window窗口垂直坐标
      int nWidth,           // window width
      int nHeight,          // window height
      HWND hWndParent,      // handle to parent or owner window.父窗口
      HMENU hMenu,          // menu handle or child identifier.菜单句柄
      HINSTANCE hInstance,  // handle to application instance
      LPVOID lpParam        // window-creation data.  WM_CREATE的附加参数
    );
    
    //显示并更新:
    BOOL ShowWindow(
      HWND hWnd,     // handle to window
      int nCmdShow   // show state
    );
    
    BOOL UpdateWindow(
      HWND hWnd   // handle to window
    );
    
    BOOL GetMessage(//从消息消息队列中取消息并返回,收到WM_QUIT返回0
      LPMSG lpMsg,         // message information
      HWND hWnd,           // handle to window
      UINT wMsgFilterMin,  // first message.设定消息最小值
      UINT wMsgFilterMax   // last message.设定消息最大值
    }
    
    BOOL TranslateMessage(  CONST MSG *lpMsg   // message information);
    //翻译消息。
    
    LRESULT DispatchMessage(
      CONST MSG *lpmsg   // message information
    );
    
    //回调函数
    LRESULT CALLBACK WindowProc(
      HWND hwnd,      // handle to window
      UINT uMsg,      // message identifier
      WPARAM wParam,  // first message parameter
      LPARAM lParam   // second message parameter
    );
    
    int MessageBox(
      HWND hWnd,          // handle to owner window
      LPCTSTR lpText,     // text in message box
      LPCTSTR lpCaption,  // message box title
      UINT uType          // message box style
    );
    
    //DC设备上下文
    HDC GetDC(
      HWND hWnd   // handle to window
    );
    
    //calls the default window procedure to provide default processing for any windo
    //w messages that an application does not process. This function ensures that 
    //every message is processed. DefWindowProc is called with the same parameters 
    //received by the window procedure. 
    //默认处理
    LRESULT DefWindowProc(
      HWND hWnd,      // handle to window
      UINT Msg,       // message identifier
      WPARAM wParam,  // first message parameter
      LPARAM lParam   // second message parameter
    );
    
    BOOL TextOut(
      HDC hdc,           // handle to DC
      int nXStart,       // x-coordinate of starting position
      int nYStart,       // y-coordinate of starting position
      LPCTSTR lpString,  // character string
      int cbString       // number of characters
    );
    
    WM_PAINT//重绘消息
    
    HDC BeginPaint(//只能在WM_PAINT下使用
      HWND hwnd,            // handle to window
      LPPAINTSTRUCT lpPaint // paint information
    );
    
    //销毁窗口
    BOOL DestroyWindow(
      HWND hWnd   // handle to window to destroy
    );
    
    //indicates to the system that a thread has made a request to terminate (quit). 
    //发送WM_QUIT到消息队列
    VOID PostQuitMessage(
      int nExitCode   // exit code
    );

     

     

     

     

     

    展开全文
  • Windows程序运行机制 1. Windows应用程序,OS,计算机硬件相互关系 2. 消息类型数据结构 typedef struct tagMSG { HWND hwnd; UINT message; WPARAM wParam; LPARAM lParam; DWORD time; Point pt; }MSG; ...

    Windows程序运行机制

    1. Windows应用程序,OS,计算机硬件相互关系



    2. 消息类型数据结构

    typedef struct tagMSG
    {
        HWND hwnd;
        UINT message;
        WPARAM wParam;
        LPARAM lParam;
        DWORD time;
        Point pt;
    }MSG;

    hwnd : 将要接受这个消息的窗口的句柄,实际上是窗口的WinProc函数接受这个消息。

    message : 消息的类型,如WM_KEYDOWN , WM_CHAR , WM_LBUTTONDOWN 等。

    wParam , lParam : 消息的附加参数,如WM_CHAR表键盘一字符按下,但具体哪个字符按下,则需附加信息才能确定。

    time : 表示消息发生的时间。

    pt : 表信息发生时,鼠标的位置。

    3. Windows程序入口函数WinMain

    int WINAPI WinMain(
        HINSTANCE hInstance,
        HINSTANCE hPrevInstance,
        LPSTR lpCmdLine,
        int nCmdShow);

    hInstance : 当前窗口实例的句柄。如同一个程序,运行两次,产生两个窗口,则系统将为每个窗口生成不同的实例号。
    hPrevInstance : 前一窗口实例的句柄,如同一MFC程序,运行一次产生窗口A1,再运行产生窗口A2,则A2的hPrevInstance将存放A1的hInstance。
    lpCmdLine : 向程序传递命令行参数,类似于Win32 Console Application中Main函数中的int argc , char ** argv 。 。。。下面补充VS2008具体设置方法。。。。VC6中是,工程、设置、Debug、。。。
    nCmdShow : 表示窗口初始显示时的状态,如最大化,最小化等。
    4. 窗口的创建过程
    1) 设计一个窗口类 WNDCLASS
    typedef struct _WNDCLASS
    {
        UINT stype;
        WNDPROC lpfnWndProc;
        int cbClsExtra;
        int cbWndExtra;
        HINSTANCE hInstance;
        HICON hIcon;
        HCURSOR hCursor;
        HBRUSH hbrBackground;
        LPCTSTR lpszMenuName;
        LPCTSTR lpszClassName;
    } WNDCLASS , * PWNDCLASS;
    
    
    style : 所设计窗口的类型 , 如 CS_HREDRAW | CS_VREDRAW 。
    lpfnWndProc : 回调函数名 ,在应用程序接受消息时,将自动调用回调函数进行处理,这个调用回调函数的过程由OS进行处理,但用户需要自己在回调函数中确定如何处理消息。
    cbClsExtra/cbWndExtra : 分别表示由用户给窗口类、窗口划定额外内存大小。一般可以设置为0,0并非表示不划定大小,而是表示默认大小。
    hInstance : 表示该窗口属于哪个应用程序,其中这个实例号表征对应的应用程序。(有待改进)。
    hIcon/hCursor : 表示窗口的左上角图标的类型 和 窗口内部鼠标的显示形式。
    hbrBackground : 表窗口的背景画刷颜色 。 可以直接赋值,也可以通过GetStockObject()函数获取,注意,此时需要强制类型转换。
    lpszMenuName : 当窗口中有菜单项时,用此参数指向菜单。无菜单时,设为NULL。
    lpszClassName : 通过以上设置,一个个性化的窗口类便设计完成,此时,需要为这个个性化的窗口类命名,以便在后面程序中为此个性化窗口类实例化。
    
    
    2) 注册窗口类 RegisterClass
    3)创建窗口 CreateWindow
    4) 显示、更新窗口 ShowWindow 、UpdateWindow
    其中UpdateWindow()可有可无,具体原因,有待补充。

    5. 消息循环 MSG

    MSG msg;
    while( GetMessage(&msg , NULL , 0 , 0) )
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    OS将为每个应用程序创建一个消息队列。

    GetMessage() : 从消息队列中取一条消息。函数返回类型BOOL,当返回TRUE时,将一直进行消息循环,直至返回FALSE。

    TranslateMessage() : 转换消息。如当用户按下键盘按键时,将产生WM_KEYDOWN和WM_KEYUP消息,但对于用户来说,需要知道具体按下哪一个键。此时,TranslateMessage()函数将结合消息的wParam和lParam参数,对消息进行转换,转换成WM_CHAR消息。TranslateMessage()函数是从消息队列中取出一条消息,对其转换之后,重新放置回消息队列。

    DispatchMessage() : 分派消息。可以理解为,该函数将消息队列所取出并转换了的消息路由给OS,然后OS将调用该窗口实例的消息处理回调函数,从而响应消息。

    6. 消息回调函数 WindowProc

    在消息回调函数中,我们对感兴趣的消息进行处理。

    switch(uMsg)
    {
        case WM_PAINT: ...
        case WM_LBUTTONDOWN: ...
        case WM_CLOSE: ...
        case WM_DESTROY: ...
        default:
            return DefaultWindowProc(...);
    }

    常用消息:

    WM_PAINT : 在窗口重绘时,产生此消息。如窗口水平重画、垂直重画、窗口初始显示时等。

    WM_CLOSE : 在关闭窗口时,产生此消息。我们可以在回调函数此消息下,进行对话框MessageBox判定,判定是否确定要关闭窗口。如果是,则调用DestroyWindow()函数进行窗口销毁。其中DestroyWindow()函数将发送一个WM_DESTROY消息到消息队列中去。在WM_DESTROY消息个性化中,写上PostQuitMessage()函数,该函数控制程序是否退出。其将投递WM_QUIT消息到消息队列总,当消息队列中GetMessage()函数收到WM_QUIT消息,将终止消息循环,从而结束程序。

    从以上过程我们可以看出,如果我们在WM_CLOSE消息下,填入DestroyWindow()函数,而在WM_DESTROY消息下,并不填入PostQuitMessage()函数的话,只是窗口被关闭,程序并未退出,而在后台运行。除非有特殊的目的,一般我们不这样去做。

    7. 常用方法及数据结构说明

    HDC : 设备上下文句柄。譬如我们需要在程序窗口画一个图形,这必然需要我们与显示设备的驱动程序打交道,而DC可以通过操作系统帮助我们做到这一点。

    如在WM_PAINT消息中,如果需要在窗口一直显示些什么东西,就需要获取窗口的HDC,然后通过相关函数,以HDC作为参数,从而进行绘图。

    HDC hdc = BeginPaint(...);
    ...
    EndPaint(...);

    其中BeginPaint()、EndPaint()要成对出现,并且这两个对HDC进行操作的函数只能用于WM_PAINT消息中,不能用于其他地方获取HDC。

    而在其他地方,我们需要使用以下形式进行HDC的获取:

    HDC hDC = GetDC(...);
    ...
    ReleaseDC(...);

    同样,GetDC()、ReleaseDC()也需要成对出现,并且这两个函数不能用于WM_PAINT消息中获取HDC。

    展开全文
  • 消息队列:每当一个Windows应用程序创建后,系统都会为该程序创建一个消息队列,这个消息队列用来存放该程序的窗口的消息, 消息产生后被投递到消息队列中,应用程序通过一个消息循环不断的消息队列中取出消息进行...
  • Windows程序内部运行机制Windows程序内部运行机制Windows程序内部运行机制
  • 主要介绍了Windows程序内部运行机制实例详解,对于学习Windows程序设计来说是非常重要的一课,需要的朋友可以参考下
  • Windows程序运行机制

    2011-01-04 18:52:41
    Windows程序运行机制.pdf 学习windows编程的好书!
  • windows程序运行机制

    2008-10-20 13:24:16
    windows程序运行机制,对运行机制有大概的理解。
  • Windows程序内部运行机制 2007-10-21 19:521010人阅读评论(0)收藏举报 windowsvc++applicationcallbackwinapistructure Windows程序内部运行机制 先加个链接在这里:...
  • Windows程序运行机制.pdfWindows程序的运行机制.pdf
  • Windows程序运行机制

    2013-07-01 00:04:23
    Windows“进队消息”和“不进队消息” Windows程序中的消息可以分为“进队消息”和“不进队消息”。进队的消息将由系统放入到应用程序的消息队列中...Windows程序运行机制 每一个Windows应用程序开始执行后,系统都
  • Windows程序内部运行机制详细说明Windows窗口编程过程窗口的产生,以及各种句柄与窗口的对应关系
  • 再理解Windows程序内部运行机制
  • Windows程序内部运行机制1.Windows程序设计是一种完全不同于传统的的DOS方式的程序设计方法。它是一种事件驱动的方式的程序设计模式,主要是基于消息的。 eg.当用户在窗口中画图时的时候,按下鼠标左键,此时,操作...
  • API函数是指Windows提供给应用程序编程的接口。  SDK(软件开发包):包括了API函数,帮助文档,辅助开发工具。  在Windows应用程序中,窗口是通过窗口句柄(HWND)来标识的。... Windows程序设计是一种基于事件
  • 对于WINDOWS程序的内部运行机制,主要学习知识点如下。 1.MSDN 的全称是 Microsoft Developer Network。这是微软公司面向软件开发者的一种信息服务。MSDN 实际上是一个以 Visual Studio 和 Windows 平台为...
  • 要想熟练掌握 Windows 应用程序的开发,首先需要理解Windows 平台下程序运行的 内部机制。市面上很多介绍Visual C++开发的书籍,一上来就讲解MFC,并且只讲操作不 讲原理,结果使得很多初学者看完书后感觉云山雾绕。...
  • Windows程序内部运行机制

    千次阅读 2007-10-21 19:52:00
    Windows程序内部运行机制 先加个链接在这里:http://www.cwws.com.cn/dev/C__Builder/list_54_1.html中国站长上的关于vc mfc的一些不错的资料 1、API与SDKWindows操作系统提供了各种各样的函数,以方便我们开发...
  • 一. Windows程序内部运行机制--Windows编程课程学习笔记

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,115
精华内容 1,246
关键字:

windows程序运行机制