PS:
预编译头的概念：

所谓的预编译头就是把一个工程中的那一部分代码,预先编译好放在一个文件里(通常是

以.pch为扩展名的)，这个文件就称为预编译头文件这些预先编译好的代码可以是任何的

C/C++代码--------甚至是inline的函数，但是必须是稳定的，在工程开发的过程中不会

被经常改变。如果这些代码被修改，则需要重新编译生成预编译头文件。注意生成预编

译头文件是很耗时间的。同时你得注意预编译头文件通常很大，通常有6-7M大。注意及

时清理那些没有用的预编译头文件。

也许你会问：现在的编译器都有Time stamp的功能，编译器在编译整个工程的时候，它

只会编译那些经过修改的文件，而不会去编译那些从上次编译过，到现在没有被修改过

的文件。那么为什么还要预编译头文件呢？答案在这里，我们知道编译器是以文件为单

位编译的，一个文件经过修改后，会重新编译整个文件，当然在这个文件里包含的所有

头文件中的东西（.eg Macro, Preprocesser ）都要重新处理一遍。VC的预编译头文件

保存的正是这部分信息。以避免每次都要重新处理这些头文件。

预编译头的作用：

根据上文介绍，预编译头文件的作用当然就是提高便宜速度了，有了它你没有必要每次

都编译那些不需要经常改变的代码。编译性能当然就提高了。

预编译头的使用：

要使用预编译头，我们必须指定一个头文件，这个头文件包含我们不会经常改变的

代码和其他的头文件，然后我们用这个头文件来生成一个预编译头文件（.pch文件）

想必大家都知道 StdAfx.h这个文件。很多人都认为这是VC提供的一个“系统级别”的

，编译器带的一个头文件。其实不是的，这个文件可以是任何名字的。我们来考察一个

典型的由AppWizard生成的MFC Dialog Based　程序的预编译头文件。（因为AppWizard

会为我们指定好如何使用预编译头文件，默认的是StdAfx.h，这是VC起的名字）。我们

会发现这个头文件里包含了以下的头文件：

#include <afxwin.h> // MFC core and standard components

#include <afxext.h> // MFC extensions

#include <afxdisp.h> // MFC Automation classes

#include <afxdtctl.h> // MFC support for Internet Explorer 4

Common Controls

#include <afxcmn.h>

这些正是使用MFC的必须包含的头文件，当然我们不太可能在我们的工程中修改这些头文

件的，所以说他们是稳定的。

那么我们如何指定它来生成预编译头文件。我们知道一个头文件是不能编译的。所以我

们还需要一个cpp文件来生成.pch 文件。这个文件默认的就是StdAfx.cpp。在这个文件

里只有一句代码就是：#include “Stdafx.h”。原因是理所当然的，我们仅仅是要它能

够编译而已?D?D?D也就是说，要的只是它的.cpp的扩展名。我们可以用/Yc编译开关来指

定StdAfx.cpp来生成一个.pch文件，通过/Fp编译开关来指定生成的pch文件的名字。打

开project ->Setting->C/C++ 对话框。把Category指向Precompiled Header。在左边的

树形视图里选择整个工程　

Project Options(右下角的那个白的地方)可以看到 /Fp “debug/PCH.pch”，这就是指

定生成的.pch文件的名字，默认的通常是　<工程名>.pch（我的示例工程名就是PCH）。

然后，在左边的树形视图里选择StdAfx.cpp.//这时只能选一个cpp文件！

这时原来的Project Option变成了 Source File Option（原来是工程，现在是一个文件

，当然变了）。在这里我们可以看到 /Yc开关，/Yc的作用就是指定这个文件来创建一个

Pch文件。/Yc后面的文件名是那个包含了稳定代码的头文件，一个工程里只能有一个文

件的可以有YC开关。VC就根据这个选项把 StdAfx.cpp编译成一个Obj文件和一个PCH文件

。

然后我们再选择一个其它的文件来看看，//其他cpp文件

在这里，Precomplier 选择了 Use ⋯⋯⋯一项，头文件是我们指定创建PCH 文件的stda

fx.h

文件。事实上，这里是使用工程里的设置，（如图1）/Yu”stdafx.h”。

这样，我们就设置好了预编译头文件。也就是说，我们可以使用预编译头功能了。以

下是注意事项：

1):如果使用了/Yu，就是说使用了预编译，我们在每个.cpp文件的最开头，我强调一遍

是最开头，包含 你指定产生pch文件的.h文件（默认是stdafx.h）不然就会有问题。如

果你没有包含这个文件，就告诉你Unexpected file end. 如果你不是在最开头包含的，

你自己试以下就知道了，绝对有很惊人的效果⋯..

fatal error C1010: unexpected end of file while looking for precompiled

header directive

Generating Code...

2）如果你把pch文件不小心丢了，编译的时候就会产生很多的不正常的行为。根据以上

的分析，你只要让编译器生成一个pch文件。也就是说把 stdafx.cpp（即指定/Yc的那个

cpp文件）从新编译一遍。当然你可以傻傻的 Rebuild All。简单一点就是选择那个cpp

文件，按一下Ctrl + F7就可以了。不然可是很浪费时间的哦。

这两天看csdn有一些关于socket粘包，socket缓冲区设置的问题，发现自己不是很清楚，所以查资料了解记录一下：

一两个简单概念长连接与短连接：
1.长连接

    Client方与Server方先建立通讯连接，连接建立后不断开， 然后再进行报文发送和接收。

2.短连接

    Client方与Server每进行一次报文收发交易时才进行通讯连接，交易完毕后立即断开连接。此种方式常用于一点对多点
通讯，比如多个Client连接一个Server.

二 什么时候需要考虑粘包问题?

1:如果利用tcp每次发送数据，就与对方建立连接，然后双方发送完一段数据后，就关闭连接，这样就不会出现粘包问题（因为只有一种包结构,类似于http协议）。关闭连接主要要双方都发送close连接（参考tcp关闭协议）。如：A需要发送一段字符串给B，那么A与B建立连接，然后发送双方都默认好的协议字符如"hello give me sth abour yourself"，然后B收到报文后，就将缓冲区数据接收,然后关闭连接，这样粘包问题不用考虑到，因为大家都知道是发送一段字符。

2：如果发送数据无结构，如文件传输，这样发送方只管发送，接收方只管接收存储就ok，也不用考虑粘包

3：如果双方建立连接，需要在连接后一段时间内发送不同结构数据，如连接后，有好几种结构：
1)"hello give me sth abour yourself"
2)"Don't give me sth abour yourself" 

 那这样的话，如果发送方连续发送这个两个包出去，接收方一次接收可能会是"hello give me sth abour yourselfDon't give me sth abour yourself" 这样接收方就傻了，到底是要干嘛？不知道，因为协议没有规定这么诡异的字符串，所以要处理把它分包，怎么分也需要双方组织一个比较好的包结构，所以一般可能会在头加一个数据长度之类的包，以确保接收。

三 粘包出现原因：在流传输中出现，UDP不会出现粘包，因为它有消息边界(参考Windows 网络编程)
1 发送端需要等缓冲区满才发送出去，造成粘包
2 接收方不及时接收缓冲区的包，造成多个包接收

解决办法：
为了避免粘包现象，可采取以下几种措施。一是对于发送方引起的粘包现象，用户可通过编程设置来避免，TCP提供了强制数据立即传送的操作指令push，TCP软件收到该操作指令后，就立即将本段数据发送出去，而不必等待发送缓冲区满；二是对于接收方引起的粘包，则可通过优化程序设计、精简接收进程工作量、提高接收进程优先级等措施，使其及时接收数据，从而尽量避免出现粘包现象；三是由接收方控制，将一包数据按结构字段，人为控制分多次接收，然后合并，通过这种手段来避免粘包。

以上提到的三种措施，都有其不足之处。第一种编程设置方法虽然可以避免发送方引起的粘包，但它关闭了优化算法，降低了网络发送效率，影响应用程序的性能，一般不建议使用。第二种方法只能减少出现粘包的可能性，但并不能完全避免粘包，当发送频率较高时，或由于网络突发可能使某个时间段数据包到达接收方较快，接收方还是有可能来不及接收，从而导致粘包。第三种方法虽然避免了粘包，但应用程序的效率较低，对实时应用的场合不适合。

在Win7旗舰版下使用VS2008编译程序时出现LINK : fatal error LNK1000: Internal error during IncrBuildImage错有如下两种解决方法：

方法一：打补丁

    到微软网站下载343461_ENU_i386_zip补丁包，然后打补丁既可。

方法二：修改项目设置

    项目->属性->链接器->常规 下面的“启用增量链接”，将“是(/INCREMENTAL)”改为“否(/INCREMENTAL:NO)”既可。

ps：找不到补丁包，就按第二种方法。

 DWORD dwSize;
 CHAR   szHead[] = "Accept: */*\r\n\r\n";
 VOID* szTemp[16384];
 HINTERNET  hConnect;
 CFile file;

 if ( !(hConnect = InternetOpenUrlA ( hOpen, szUrl, szHead,
   lstrlenA (szHead), INTERNET_FLAG_DONT_CACHE | INTERNET_FLAG_PRAGMA_NOCACHE | INTERNET_FLAG_RELOAD, 0)))
 {
    AfxMessageBox("不能打开该URL!");
    return -1;
 }

 if  (file.Open(szFileName,CFile::modeWrite|CFile::modeCreate)==FALSE )
 {
    AfxMessageBox("不能打开本地的文件!");
   return -1;
 }

 DWORD dwByteToRead = 0;
 DWORD dwSizeOfRq = 4;
 DWORD dwBytes = 0;

    if (!HttpQueryInfo(hConnect, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,
                  (LPVOID)&dwByteToRead, &dwSizeOfRq, NULL))
 {
  dwByteToRead = 0;
 }

 DWORD start;
 DWORD end;
 DWORD time;
 CString tempstring;
 time = 10;
 start = timeGetTime();
 do
 {
  if (!InternetReadFile (hConnect, szTemp, 16384,  &dwSize))
  {
   AfxMessageBox("读文件出错!");
   file.Close();
   return -1;
  }
  if (dwSize==0)
   break;
  else
   file.Write(szTemp,dwSize);
  dwBytes+=dwSize;
  if(dwByteToRead)
  {
   tempstring.Format("%d%%",(dwBytes*100)/dwByteToRead);
   SetDlgItemText(IDC_PERCENT_TEXT,tempstring);
  }
  FLOAT fSpeed = 0;
  fSpeed = (float)dwBytes;
  fSpeed /= ((float)time)/1000.0f;
  fSpeed /= 1024.0f;
  tempstring.Format("%dKB/s",fSpeed);
  SetDlgItemText(IDC_SPEED_TEXT,tempstring);
  end = timeGetTime();
  time = end - start;
  if(time == 0)
   time = 10;
 }while (TRUE);

 file.Close();
 InternetCloseHandle(hOpen);

一 WinINet是微软开发的一个库，可以完成http ftp客户端的工作。让程序员从复杂的协议中节省大量体力。

二 我会用了http, ftp类似。用WinINet完成一个http下载需要以下步骤 。 下面这个是同步操作（也就是一步步操作，每个函数执行完才会返回一个结果的意思）

     1   InternetOpen      Initializes an application's use of the WinINet functions.
                   需要的话 InternetSetOption 设置代理服务器地址以及端口。
                   http：    ip:port 或者 http=http://ip:port
                   socks：SOCKS=ip:port
     2   InternetConnect    关联目标地址或者域名以及服务ip

     3   HttpOpenRequest   关联要下载的内容名字
                   InternetSetOption 设置用户名密码

     4   HttpSendRequest     这步就是用HttpOpenRequest 的返回值（已经关联了上面的所有信息）发送出去，第一次用了网络。向目标服务器或者代理服务器。

     5   HttpQueryInfo
            该函数查询返回值，不参与网络操作。可以查询服务器的返回信息，比如目标文件的大小，该文件是否存在，代理服务返回了要求用户名，密码等等（这几个最常用），还有很多信息。

     6   InternetReadFile
            很普通的读函数，就是下载文件。不知道是否和底层网络同步，底层会不会提前下载呢？

     7   InternetCloseHandle 释放资源

三    异步操作，比较复杂的。   为什么需要异步操作呢？ 因为涉及到网络操作，某些函数在操作中可能需要时间，如果一直不返回（比如1秒）时，这时主线程要结束程序，岂不就出现意想不到的结果了，但是如果每个函数都能够瞬间返回，然后通过WaitForMultipleObjects或者WaitForSingleObject等待结果的出现（此时就不会操作那个消耗1秒的函数了，而这个1秒函数正是要用到系统资源HINTERNET的）。

       异步操作的目的上如，原理呢？ 其实原理就是注册一个函数，在这里叫InternetStatusCallback，因为微软写得底层代码要用到，所以必须格式统一。一旦有结果来了就通过事件通知我们，WaitForSingleObject函数就可以走了。比如等到了HINTERNET创建或者命令发送成功等结果。然后我们就可以第一时间安全的使用了。
      API 函数如果名字最后可以带EX，那么带ex的就是异步操作的。

四 一定要注意，凡是有unicode和mutilbyte函数的一定要统一，最好都用mutilbyte的。

五： 代码如下：
// crt_assert.c
// compile with: /c
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

#include <iostream>

#include "winsock2.h"
#include <string>
#include <Wininet.h>
#include <windows.h>
#include <fstream>　//要使用文件输入输出流必须的头文件
using namespace std;
#define __HTTP_VERB_GET    "GET"
#define __HTTP_VERB_POST "POST"
#define __HTTP_ACCEPT_TYPE "*/*"
#define __HTTP_ACCEPT "Accept: */*\r\n"
#define __SIZE_HTTP_BUFFER    100000
#define __SIZE_HTTP_RESPONSE_BUFFER    100000
#define __SIZE_HTTP_HEAD_LINE    2048

void CALLBACK InternetStatusCallback(

                                    HINTERNET hInternet,
                                    DWORD dwContext,
                                    DWORD dwInternetStatus,
                                    LPVOID lpvStatusInformation,
                                    DWORD dwStatusInformationLength);
HANDLE hEvent[3];

HINTERNET hFile;
HINTERNET hNet;
HINTERNET hSession,hConnect,hRequest;
int WaitExitEvent()
{
    //return 1;
    DWORD dwRet = ::WaitForMultipleObjects(3, hEvent, FALSE, 30000);//INFINITE);
    int x=-1;
    switch (dwRet)
    {
        //句柄被创建事件或者读数据请求成功完成事件
    case WAIT_OBJECT_0:
        x=0;
        cout<<"WAIT_OBJECT_0"<<endl;
        //句柄被关闭事件
        break;
    case WAIT_OBJECT_0+1:
        x=1;
        cout<<"WAIT_OBJECT_1"<<endl;
        //用户要求终止子线程事件或者发生错误事件
        break;
    case WAIT_OBJECT_0+2:
        x=2;
        cout<<"WAIT_OBJECT_2"<<endl;
       
        break;
    default:
        cout<<"WaitForMultipleObjects time out"<<endl;
        return -1;

    }
    return x;
}

// 支持代理设置， 是否异步设置； 采用事件驱动
void WinINet3(bool setProxy, bool ASYNC)
{
    hSession=NULL;
    hConnect=NULL;
    hRequest=NULL;
    for (int i = 0; i < 3; i++)
    {
        hEvent[i] = CreateEvent(
            NULL,   // default security attributes
            FALSE, // auto-reset event object
            FALSE, // initial state is nonsignaled
            NULL); // unnamed object

        if (hEvent[i] == NULL)
        {
            printf("CreateEvent error: %d\n", GetLastError() );
            ExitProcess(0);
        }
    }
    char *url = "http://down.360safe.com/setup.exe";
    char *pip = "down.360safe.com";
    char *paim = "/setup.exe";

    //   step 1
    if(ASYNC)    cout<<"异步模式"<<endl;
   // setProxy =false;
    if(setProxy)
    {
        cout<<"代理模式"<<endl;
        if(ASYNC)
          hSession = InternetOpen("name",
        INTERNET_OPEN_TYPE_DIRECT,//|INTERNET_OPEN_TYPE_PROXY,// INTERNET_OPEN_TYPE_PROXY,
        NULL,NULL,INTERNET_FLAG_ASYNC); // 异步
        else
          hSession = InternetOpen("name",INTERNET_OPEN_TYPE_PROXY,NULL,NULL,0); // 同步
    }
    else
    {
        if(ASYNC)
            hSession = InternetOpen("name",INTERNET_OPEN_TYPE_PRECONFIG,NULL,NULL,INTERNET_FLAG_ASYNC); // 异步
        else
            hSession = InternetOpen("name",INTERNET_OPEN_TYPE_PRECONFIG,NULL,NULL,0); // 同步
    }
    if(!hSession){
        DWORD er = ::GetLastError();
        cout<<"InternetOpen error"<<endl;//, "Err", MB_OK);
        return;
    }
    if(ASYNC)
    {
        //Sleep(500);
        INTERNET_STATUS_CALLBACK res = ::InternetSetStatusCallback(hSession,InternetStatusCallback);
        if(res == INTERNET_INVALID_STATUS_CALLBACK)
        {
            cout<<"InternetSetStatusCallback failed, so return "<<endl;
            return ;   
        }
        else
        {
            cout<<"InternetSetStatusCallback succeed, so go on "<<endl;

        }
        //Sleep(500);
    }
   
    char   strProxyList[MAX_PATH],   strUsername[64],   strPassword[64];
    strcpy(strProxyList,   "SOCKS=58.56.87.2:1080"); //   写上socks怎么就无效了呢？？？SOCKS5=172.18.132.27:1080
    strcpy(strUsername,   "user01");
    strcpy(strPassword,   "baidu");
    INTERNET_PROXY_INFO proxy;
    proxy.dwAccessType = INTERNET_OPEN_TYPE_PROXY;
    proxy.lpszProxy    = strProxyList;
    proxy.lpszProxyBypass = NULL;
    if( setProxy &&!InternetSetOption(hSession,INTERNET_OPTION_PROXY ,&proxy,sizeof(INTERNET_PROXY_INFO)))
    {
        cout<<"InternetSetOption failed"<<endl;
        return ;
    }
   
    // step 2
    //如果明确知道需要认证，第4，5个参数可以输入用户名，密码"administrator","password"
    //第2，3个参数为目标主机IP、端口号(不是代理服务器的参数)
    hConnect = InternetConnect(hSession,pip,INTERNET_DEFAULT_HTTP_PORT,NULL,NULL,INTERNET_SERVICE_HTTP,INTERNET_FLAG_RELOAD,0);
    if(!ASYNC &&!hConnect){
        cout<<"同步，InternetConnect error"<<endl;//, "Err", MB_OK);
        return;
    }
    if( ASYNC&& hConnect== NULL)// 异步 需要等待   竟然直接创建好了
    {
        int er = GetLastError();
        DWORD dwError = ::GetLastError();
        if (dwError != ERROR_IO_PENDING)
        {
            cout<<"CHttpDownload::OpenInternetConnection| 连接失败" <<endl;
            return ;
        }
        else //
        {
            cout<<"hConnect == NULL, so run WaitExitEvent"<<endl;
            WaitExitEvent(); // 等待成功创建 // 这里应该等待   这里应该显示一次呀
            ::ResetEvent(hEvent[0]);
            ::ResetEvent(hEvent[1]);
            ::ResetEvent(hEvent[2]);
        }
    }
    cout<<"step 2 :InternetConnect secced"<<endl;

    // ::InternetSetStatusCallback(hConnect,InternetStatusCallback);
   
    // step 3!!!
    char   szHead[] = "Accept: */*\r\n\r\n";
    char **p = new char*[2];*p = szHead;*(p+1) = NULL;

    //hRequest = HttpOpenRequest(hConnect,"GET","download/BaiduHi_1.0_Beta2.exe",NULL,NULL,/*(const char **)p*/NULL,0/*INTERNET_FLAG_NO_COOKIES|INTERNET_FLAG_RELOAD*/,0); // no request;
    CONST TCHAR *szAcceptType=__HTTP_ACCEPT_TYPE;
    hRequest = ::HttpOpenRequest(hConnect,
        "GET",
        paim,
        HTTP_VERSION,
        "",
        &szAcceptType,
        INTERNET_FLAG_RELOAD|INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_NO_CACHE_WRITE,
        0);
   
    //::HttpAddRequestHeaders( hRequest, __HTTP_ACCEPT, strlen(__HTTP_ACCEPT), HTTP_ADDREQ_FLAG_REPLACE);
    /*_hHTTPRequest=::HttpOpenRequest(    _hHTTPConnection,
        __HTTP_VERB_GET, // HTTP Verb
        szURI, // Object Name
        HTTP_VERSION, // Version
        "", // Reference
        &szAcceptType, // Accept Type
        INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_NO_CACHE_WRITE,
        0); // context call-back point
    */
    if (!ASYNC&& !hRequest){
        cout<<"同步，HttpOpenRequest error"<<endl;//, "Err", MB_OK);
        return;
    }
    if( ASYNC&& hRequest== NULL)// 异步 需要等待
    {
        int er = GetLastError();
        DWORD dwError = ::GetLastError();
        if (dwError != ERROR_IO_PENDING)
        {
            cout<<"CHttpDownload::OpenInternetConnection| 连接失败" <<endl;
            return ;
        }
        else //
        {
            cout<<"hRequest == NULL, so run WaitExitEvent"<<endl;
            WaitExitEvent(); // 等待成功创建
            ::ResetEvent(hEvent[0]);
            ::ResetEvent(hEvent[1]);
            ::ResetEvent(hEvent[2]);
        }
    }
    //Sleep(10000);
    cout << "step 3 : HttpOpenRequest success"<<endl;
    //::InternetSetStatusCallback(hRequest,InternetStatusCallback);
    //////////////////////////////////////////////
    if (setProxy )
    {
        // InternetSetOption 不要异步等待
        if( !InternetSetOption(hRequest,INTERNET_OPTION_PROXY_USERNAME ,strUsername,strlen(strUsername)+1))
        {
            cout<<"InternetSetOption Username failed"<<endl;
            return ;
        }
        if( !InternetSetOption(hRequest,INTERNET_OPTION_PROXY_PASSWORD ,strPassword,strlen(strPassword)+1))
        {
            cout<<"InternetSetOption Password failed"<<endl;
            return ;
        }
    }
    // step 4
    //HttpSendRequest(hRequest,NULL,0,NULL,0);
    //Sleep(3000);
    ::ResetEvent(hEvent[0]);
    ::ResetEvent(hEvent[1]);
    ::ResetEvent(hEvent[2]);
    if(!::HttpSendRequest(hRequest,NULL,0,NULL,0)) // 为什么失败？？？
    {
        //Sleep(3000);
        if(!ASYNC)// 同步
        {
            DWORD dwError = ::GetLastError();
              cout<<"同步，HttpSendRequest failed, GetLastError=="<<dwError<<endl;
            return ;
       
        }
        else
        {
            Sleep(3000);
            DWORD dwError = ::GetLastError();
            cout<<"dwError =="<<dwError<<endl;
            if (dwError != ERROR_IO_PENDING)
            {
                cout<<"dwError != ERROR_IO_PENDING, so quit,dwError =="<<dwError<<endl;
                return ;
            }
            else //
            {
                cout<<"HttpSendRequest, so run WaitExitEvent"<<endl;
                Sleep(3000);
                //if(WaitExitEvent()!=2)//; // 等待成功创建 等待是否不对？？？
                {
                       cout<<"had not recv complete event, so quit"<<endl;
                    // return ;
                }
            }
        }
       
    }
    Sleep(3000);
    cout << "step 4: HttpSendRequest success!"<<endl;

    int bufh[1000];
    DWORD dwLen,dwIndex;
    /*if(!::HttpQueryInfo(hRequest, HTTP_QUERY_RAW_HEADERS_CRLF, bufh, &dwLen, &dwIndex))// 这句话？？？
    {
        //return E_FAIL;
        return;
    }
*/
    // 判断状态码；
    char m_dwStatusCode[90];
    DWORD dwStatusSize = sizeof(m_dwStatusCode);
    /*if (FALSE == ::HttpQueryInfo(hRequest,   // 查询失效？？
        HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,
        &m_dwStatusCode,
        &dwStatusSize,
        NULL))   //获取返回状态码
    {
        return ;
    }
    //判断状态码是不是 200
    //if (HTTP_STATUS_OK != m_dwStatusCode)
    {
        //return ;
    }
*/

    DWORD dwByteToRead = 0;
    DWORD dwSizeOfRq = 4;
    DWORD dwBytes = 0;
    //这三个值分别存储文件的大小，HttpQueryInfo内容的大小和总共读取的字节数。
    //HttpQueryInfo(hRequest, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, (LPVOID)&dwByteToRead, &dwSizeOfRq, NULL);
    //需要说明的是 HttpQueryInfo 并不进行网络操作，因此它不需要进行异步操作的处理。
    if (!HttpQueryInfo(hRequest, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, (LPVOID)&dwByteToRead, &dwSizeOfRq, NULL))
    { // 这里失败了？？？
       
        DWORD dwError = ::GetLastError();
        cout<<"HttpQueryInfo failed, so return， GetLastError() =="<<dwError<<endl;
        return ;
    }
    FILE * pFile = fopen("e://baidu01.exe", "wb" );
    //ofstream mfile("out.txt");//定义文件输出流ouf，并关联到out.txt
    int i=0;
    DWORD leftB = dwByteToRead;
    cout<<"开始下载"<<endl;
    if( !ASYNC) // 同步下载
    {
        while(true)
        {
            const int MAX_BUFFER_SIZE = 65536;
            unsigned long nSize = 0;
            char szBuffer[MAX_BUFFER_SIZE+2];
            int num = MAX_BUFFER_SIZE;
            if( leftB < num);
            num = leftB;
            BOOL bRet = ::InternetReadFile(hRequest, szBuffer, num, &nSize); // 异步 需要等待

            leftB -= nSize;
            cout<<i++<<" size: "<<nSize<<endl;
            if(!bRet || nSize <= 0)
                break;
            fwrite(szBuffer, sizeof(char), nSize, pFile);
        }
    }
    else // 异步下载
    {
        INTERNET_BUFFERS i_buf = {0};
        i_buf.dwStructSize = sizeof(INTERNET_BUFFERS);
        i_buf.lpvBuffer = new TCHAR[10242];
        i_buf.dwBufferLength = 10240;
         for( DWORD i=0;i<dwByteToRead;)
        {
            //重置读数据事件
            ::ResetEvent( hEvent[0]);
            int num = 10240;
            if(dwByteToRead-i<10240)
            {
                num = dwByteToRead-i;
                   i_buf.dwBufferLength = dwByteToRead-i;
            }
            if (FALSE == ::InternetReadFileEx(hRequest,
                &i_buf,
                IRF_ASYNC,
                NULL))
            {
                if (ERROR_IO_PENDING == ::GetLastError())
                {
                    if ( NULL)//WaitExitEvent()!=2)
                    {
                        delete[] i_buf.lpvBuffer;
                        return ;
                    }
                }
                else
                {
                    cout<<"down failed,so return"<<endl;
                    delete[] i_buf.lpvBuffer;
                    return ;
                }
            }
            else
            {
                //在网络传输速度快，步长较小的情况下，
                //InternetReadFileEx 经常会直接返回成功，
                //因此要判断是否发生了用户要求终止子线程事件。
                cout<<"网络很好，InternetReadFileEx返回true"<<endl;

                // 暂不考虑用户退出
            }
            i += i_buf.dwBufferLength; // 最后一次写多了！！！
            fwrite(i_buf.lpvBuffer, sizeof(char), i_buf.dwBufferLength, pFile);
            cout<<"i== "<<i<<endl;
            //保存数据
             //通知主线程下载进度
                   
        }
    }
    InternetCloseHandle(hRequest);
    InternetCloseHandle(hConnect);
    InternetCloseHandle(hSession);
    cout<<"success download file"<<endl;
   
    return;
}

int main( void )
{
   
    WinINet3(true,true);
    return 1;
}

void OnInternetHandleCreated(HINTERNET hInternet, LPINTERNET_ASYNC_RESULT lpInetStatusResult)
{
    if(NULL == lpInetStatusResult)
    {
        //ATLASSERT( 0 );
        return;
    }
    hFile = HINTERNET(lpInetStatusResult->dwResult);
    HINTERNET    hInet = HINTERNET(lpInetStatusResult->dwResult);
    DWORD        dwInetHandleType;
    DWORD        dwTypeLen = sizeof(dwInetHandleType);

    InternetQueryOption( hInet, INTERNET_OPTION_HANDLE_TYPE, &dwInetHandleType, &dwTypeLen);
    switch(dwInetHandleType)
    {
    case INTERNET_HANDLE_TYPE_CONNECT_HTTP:
        //CloseInternetConnection(); //   这里是何意？？？？ 通过回调 设置httpConnect
        hConnect = hInet;     //
        break;
    case INTERNET_HANDLE_TYPE_HTTP_REQUEST:
        //CloseInternetFile();    //    这里是何意？？    通过回调 设置httpFile
        hRequest = hInet;    //
        break;
    default:
        break;
    }
    cout<<"OnInternetHandleCreated, so ::SetEvent(hEvent[0])"<<endl;
    // HANDLE已创建事件（异步控制）
    ::SetEvent(hEvent[0]);
}
void OnInternetRequestComplete(HINTERNET hInternet, LPINTERNET_ASYNC_RESULT lpInetStatusResult)
{

    if( lpInetStatusResult == NULL )
    {
        //ATLASSERT( 0 );
        return;
    }
    cout<<"OnInternetRequestComplete, so ::SetEvent(hEvent[2])"<<endl;
    // 激发请求完成事件（异步控制）
    ::SetEvent(hEvent[0]);
}

void CALLBACK InternetStatusCallback(
                                    HINTERNET hInternet,
                                    DWORD_PTR dwContext,
                                    DWORD dwInternetStatus,
                                    LPVOID lpvStatusInformation,
                                    DWORD dwStatusInformationLength
                                    )
{
    cout<<"进入回调"<<endl;
    switch (dwInternetStatus)
    {
    case INTERNET_STATUS_RESOLVING_NAME:
        break;
    case INTERNET_STATUS_NAME_RESOLVED:
        break;
    case INTERNET_STATUS_CONNECTING_TO_SERVER:
        break;
    case INTERNET_STATUS_CONNECTED_TO_SERVER:
        break;
    case INTERNET_STATUS_SENDING_REQUEST:
        break;
    case INTERNET_STATUS_REQUEST_SENT:
        break;
    case INTERNET_STATUS_RECEIVING_RESPONSE:
        break;
    case INTERNET_STATUS_RESPONSE_RECEIVED:
        break;
    case INTERNET_STATUS_CLOSING_CONNECTION:
        break;
    case INTERNET_STATUS_CONNECTION_CLOSED:
        break;
    case INTERNET_STATUS_HANDLE_CREATED:
        cout<<"回调是INTERNET_STATUS_HANDLE_CREATED"<<endl;
        OnInternetHandleCreated(hInternet, LPINTERNET_ASYNC_RESULT(lpvStatusInformation)); // 传递了HINTERNET 这是精髓呀
        break;
    case INTERNET_STATUS_HANDLE_CLOSING:
        break;
    case INTERNET_STATUS_REQUEST_COMPLETE:
        cout<<"回调是INTERNET_STATUS_REQUEST_COMPLETE"<<endl;
        OnInternetRequestComplete(hInternet, LPINTERNET_ASYNC_RESULT(lpvStatusInformation));
        break;
    case INTERNET_STATUS_REDIRECT:
    case INTERNET_STATUS_INTERMEDIATE_RESPONSE:
    case INTERNET_STATUS_STATE_CHANGE:
    default:
        break;
    }
}

 CRect BoxRect;
 BoxRect=rect;
 BoxRect.right =BoxRect.left +15;
 dc.DrawFrameControl(BoxRect,DFC_BUTTON,DFCS_BUTTONCHECK|GetCheck()?DFCS_CHECKED :0);

 CFont   myFont; 
 myFont.CreatePointFont (100,_T("宋体"));
 CFont   *pOldFont=(CFont   *)dc.SelectObject(&myFont);
 dc.SetBkMode(TRANSPARENT);  

 CString StrWndText;
 GetWindowText(StrWndText);

 rect.OffsetRect (20,0);
 dc.SetTextColor(RGB(0,0,0));
 dc.DrawText(StrWndText,   rect,   DT_LEFT|DT_VCENTER|DT_SINGLELINE);
 dc.SelectObject   (pOldFont); 
 myFont.DeleteObject   (); 
}

　　正规软件经常用到临时文件，你经常可以会看到C:\Windows\Temp目录下有大量的扩展名为tmp的文件，这些就是程序运行是建立的临时文件。临时文件的使用方法基本与常规文件一样，只是文件名应该调用函数GetTempFileName()获得。它的第一个参数是建立此临时文件的路径，第二个参数是建立临时文件名的前缀，第四个参数用于得到建立的临时文件名。得到此临时文件名以后，你就可以用它来建立并操作文件了，如：
　　char szTempPath[_MAX_PATH],szTempfile[_MAX_PATH];
　　GetTempPath(_MAX_PATH, szTempPath);
　　GetTempFileName(szTempPath,_T ("my_"),0,szTempfile);
　　CFile m_tempFile(szTempfile,CFile:: modeCreate|CFile:: modeWrite);
　　char m_char='a';
　　m_tempFile.Write(&m_char,2);
　　m_tempFile.Close();
　　5．文件的复制、删除等
　　MFC中没有提供直接进行这些操作的功能，因而要使用SDK。SDK中的文件相关函数常用的有CopyFile()、CreateDirectory()、DeleteFile()、MoveFile()。它们的用法很简单，可参考MSDN。

1,判断文件是否存在
    access(filename,mode);
2,对于不同用途又不同的文件操作,其中API函数CreateFile()也是比较有用处理方式,对于巨型文件很合适的其他的楼上的大都说了,不重复了.

[1]显示对话框，取得文件名

CString FilePathName;
CFileDialog dlg(TRUE);///TRUE为OPEN对话框，FALSE为S***E AS对话框
if (dlg.DoModal() == IDOK)
    FilePathName=dlg.GetPathName();

相关信息：CFileDialog 用于取文件名的几个成员函数：
假如选择的文件是C:\WINDOWS\TEST.EXE
则(1)GetPathName();取文件名全称，包括完整路径。取回C:\WINDOWS\TEST.EXE
(2)GetFileTitle();取文件全名：TEST.EXE
(3)GetFileName();取回TEST
(4)GetFileExt();取扩展名EXE

[2]打开文件
CFile file("C:\HELLO.TXT",CFile::modeRead);//只读方式打开
//CFile::modeRead可改为 CFile::modeWrite(只写),
//CFile::modeReadWrite(读写),CFile::modeCreate(新建)
例子：
{
CFile file;
file.Open("C:\HELLO.TXT",CFile::modeCreate|Cfile::modeWrite);
.
.
.
}

[3]移动文件指针
file.Seek(100,CFile::begin);///从文件头开始往下移动100字节
file.Seek(-50,CFile::end);///从文件末尾往上移动50字节
file.Seek(-30,CFile::current);///从当前位置往上移动30字节
file.SeekToBegin();///移到文件头
file.SeekToEnd();///移到文件尾

[4]读写文件
读文件：
char buffer[1000];
file.Read(buffer,1000);
写文件：
CString string("自强不息");
file.Write(string,8);

[5]关闭文件
file.Close();

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zhuang_rui/archive/2007/09/28/1804875.aspx

在MFC类库提供了CWnd::OnCtlColor函数,在工作框架的子窗口被重画时将调用该成员函数.因此可以重载WM_CTLCOLOR消息的响应函数.此函数的原型:
  afx_msg HBRUSH OnCtlColor(CDC *pDC,CWnd *pWnd,UINT nCtlColor);
           参数nCtlColor用于指定控件的类型,可以是:
           .CTLCOLOR_BTN                按钮控件
           .CTLCOLOR_DLG                对话框
           .CTLCOLOR_EDIT               编辑框
           .CTLCOLOR_LISTBOX            列表控件
           .CTLCOLOR_MSGBOX             消息控件
           .CTLCOLOR_SCROLLBAR 滚动条控件
           .CTLCOLOR_STATIC             静态控件
[程序实现]
           假设你已有了名为My的对话框工程.你有了一个STATIC的控件，ID为IDC_STATIC1.
  HBRUSH CMyDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
           {
        HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
  
        // TODO: Change any attributes of the DC here
           if (nCtlColor==CTLCOLOR_STATIC)

              {
                    pDC->SetTextColor(RGB(255,0,0));  //字体颜色
                    pDC->SetBkColor(RGB(0, 0, 255));   //字体背景色  

                }
        // TODO: Return a different brush if the default is not desired
        return hbr;
           }

如果要指定某个特定控件可以这样写：ID为IDC_STATIC1

if (pWnd->GetDlgCtrlID()==IDC_STATIC1)
{
       pDC->SetTextColor(RGB(255,0,0));  //设置字体颜色
       pDC->SetBkMode(TRANSPARENT); //设置字体背景为透明
// TODO: Return a different brush if the default is not desired
  return (HBRUSH)::GetStockObject(BLACK_BRUSH);  // 设置背景色
}
else
return hbr;

【注】

BLACK_BRUSH:黑色

WHITE_BRUSH:白色

GRAY_BRUSH:灰色

NULL_BRUSH:透明

HOLLOW_BRUSH ：透明

注：如果在窗体中使用这种方法，会引起代码的臃肿，建议自定义自己的类。

Windows Template Library - WTL的安装指南满地都是，而且源程序也附带了安装说明，似乎没有必要再多写一个。但是，事情并没有想象的那么简单，本人有过将近4年的C++开发经验，在两年前刚转入C#，有很长时间没碰C++了（最后使用的工具是VC++6.0）。今天突发兴趣，想要玩玩VC++ 2005和WTL，谁知，以我这种经验，折腾这看是简单的玩意，也花了大半天的时间方才搞出第一个WTL的Hello World，个中曲折，说来实在惭愧，只好把正确的安装过程写一下，如果能给别人一点提示，那是最好的了。至少，可以做个笔记，两三年以后如果又忘了，还可以回来翻翻。

1、从http://sourceforge.net/projects/wtl下载最新版本的WTL，当时是8.0
2、下载得到的是一个自解压文件，可以解压到任意目录。比如d:\wtl80，下面有几个子目录samples, include, AppWizMobile, AppWizCE, AppWiz，还有一个txt文件和htm文件。其中include是头文件，samples是几个示例，AppWiz*是各种向导文件。
3、在命令行里执行：wscript.exe "D:\WTL80\AppWiz\setup80.js"，如果是vs2005 express、vs2003等，分别执行setup80x.js, setup70.js,可以看看里面的文档说明。
   注：这是一个很容易让人困惑的地方，网上的文档全都说解压后执行setup80.js文件，但都没说如何执行。后来在代码里看到有WScript，才想到用WSCript.exe来执行。

4、打开VS2005, 选择VC++项目，就可以看到WTL项目的向导了。

5、在VS2005里，打开菜单“工具”——选项——项目和解决方案——VC++目录，在“显示以下内容的目录”下拉框中，选择“包含文件”，加入刚才解压的wtl下的include，本例中是"d:\wtl80\include"。

6、按照向导创建一个程序，编译，执行，OK。

用向导建立一个Win32程序“hello, world!”，然后用下面的内容替换整个CPP文件内容就可以了

#include "stdafx.h"
#include "resource.h"

#include "ShellApi.h"

HINSTANCE hInst = NULL;

HDESK hDesktopCurrent;
HDESK hDesktopLlx;

LONG APIENTRY WndProc(
    HWND hWnd,
    UINT message,      // type of message
    WPARAM wParam,     // additional information
    LPARAM lParam)     // additional information
{
 int wmId, wmEvent;
 PAINTSTRUCT ps;
 HDC hdc;

 switch (message)
 {
  case WM_COMMAND:
   wmId    = LOWORD(wParam);
   wmEvent = HIWORD(wParam);
   // Parse the menu selections:
   switch (wmId)
   {
    case IDM_ABOUT:
       //DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
       break;
    case IDM_EXIT:
       DestroyWindow(hWnd);
       break;
    default:
       return DefWindowProc(hWnd, message, wParam, lParam);
   }
   break;
  case WM_PAINT:
   hdc = BeginPaint(hWnd, &ps);
   // TODO: Add any drawing code here...
   RECT rt;
   GetClientRect(hWnd, &rt);
   //DrawText(hdc, szHello, strlen(szHello), &rt, DT_CENTER);
   EndPaint(hWnd, &ps);
   break;
  /*
  case WM_DESTROY:
   PostQuitMessage(0);
   break;
  //*/
  case WM_LBUTTONDOWN:
   break;
  case WM_HOTKEY:
   if(7777 == wParam)
   {
    PostQuitMessage(0);
   }
   else if(7778 == wParam)
   {
    SwitchDesktop(hDesktopCurrent);
   }
   else if(7779 == wParam)
   {
    SwitchDesktop(hDesktopLlx);
   }
   break;
  case WM_QUIT:
  case WM_DESTROY:
   SwitchDesktop(hDesktopCurrent);
   return DefWindowProc(hWnd, message, wParam, lParam);
  default:
   return DefWindowProc(hWnd, message, wParam, lParam);
   }
   return 0;
}

void StartMyExplore(void)
{
 STARTUPINFO sui;         // Process startup info
 PROCESS_INFORMATION pi;  // info returned from CreateProcess
 //
 // Most sui members will be 0
 //
 ZeroMemory ((PVOID)&sui, sizeof(sui));

 sui.cb = sizeof (sui);
 //
 // Need the lpDesktop member so the new process runs on this desktop
 // The lpDesktop member was reserved in previous versions of NT
 //
 sui.lpDesktop = _T("llx");
 CreateProcess (NULL,   // image name
      "explorer", // command line
      NULL,   // process security attributes
      NULL,   // thread security attributes
      TRUE,   // inherit handles
      CREATE_DEFAULT_ERROR_MODE|CREATE_SEPARATE_WOW_VDM,
      NULL,   // environment block
      NULL,   // current directory
      &sui,   // STARTUPINFO
      &pi);   // PROCESS_INFORMATION
}

int CALLBACK WinMain( HINSTANCE hInstance,
      HINSTANCE hPrevInstance,
      LPSTR lpCmdLine,
      int nCmdShow)
{
 WNDCLASS wc;
 wc.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
 wc.lpfnWndProc = WndProc;
 wc.cbClsExtra = 0;
 wc.cbWndExtra = 0;
 wc.hInstance = hInstance;
 wc.hIcon = LoadIcon (NULL, "IDI_SETTHREADDESKTOP");
 wc.hCursor = LoadCursor (NULL, IDC_ARROW);
 wc.hbrBackground = (HBRUSH)GetStockObject (WHITE_BRUSH);
 wc.lpszMenuName = NULL;
 wc.lpszClassName = "lilinxiang";
 if(!RegisterClass(&wc))
 {
  return TRUE;
 }

 hDesktopCurrent = NULL;
 hDesktopCurrent = GetThreadDesktop(GetCurrentThreadId());

 hDesktopLlx = NULL;
 hDesktopLlx = OpenDesktop("llx", 0, FALSE, NULL);
    if (hDesktopLlx != NULL)
 {
  CloseDesktop(hDesktopLlx);
 }

 SECURITY_ATTRIBUTES sa;
 sa.bInheritHandle = TRUE;
 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
 sa.lpSecurityDescriptor = NULL;

 hDesktopLlx = CreateDesktop("llx", NULL,
                                    NULL,0,MAXIMUM_ALLOWED,
                                    NULL);
 if(hDesktopLlx == NULL)
 {
  return 0;
 }

 if(!SetThreadDesktop(hDesktopLlx))
 {
  char szError[256] = {0};
  ltoa( (long)(GetLastError()) , szError, 10);
 }
 SwitchDesktop(hDesktopLlx);

 HWND hWnd = NULL;
 hWnd = CreateWindow ("lilinxiang",
        "hello, world!",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT,
        0,
        CW_USEDEFAULT,
        0,
        NULL,
        NULL,
        hInstance,
        NULL
        );
 if(NULL == hWnd)
 {
  return TRUE;
 }

 //register hotkey for exit this desktop or switch to another desktop
 //ShowWindow(hWnd, SW_SHOW);
 //UpdateWindow(hWnd);
 if(!RegisterHotKey(hWnd, 7777, MOD_CONTROL, 'Q'))
 {//exit process
  return TRUE;
 }
 if(!RegisterHotKey(hWnd, 7778, MOD_CONTROL | MOD_SHIFT, 'Q'))
 {//switch to new desktop
  return TRUE;
 }
 if(!RegisterHotKey(hWnd, 7779, MOD_CONTROL | MOD_SHIFT, 'W'))
 {//switch to original desktop
  return TRUE;
 }
 
 StartMyExplore();

 MSG msg;
 while (GetMessage(&msg, NULL,  0, 0))
    {
                 TranslateMessage(&msg);// Translates virtual key codes
                 DispatchMessage(&msg); // Dispatches message to window
    }

 SwitchDesktop(hDesktopCurrent);
 return TRUE;
}

//   : )  好东西噢

用CreateDesktop新建一个桌面，什么都没有的桌面，然后在新桌面环境中运行了explorer所以就有了和windows一样功能的桌面，这个时候你就有了两个桌面了，下面要做的就是用SwitchDesktop切换不同的桌面了

在不同桌面中打开的程序在其他桌面的任务栏包括系统托盘上不可见，不过任务管理器中还是可见的这样你就非常方便的做很多事了，很多...  而且还可以非常快的转到正常状态上可以让会责骂你的人比如老板什么的无话可说，因为他们什么也看不到  : )

或者你也可以给你用户定制一个个性化的桌面。改改上面的代码可以得到你要的效果的。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/goingup/archive/2006/03/07/618323.aspx用向导建立一个Win32程序“hello, world!”，然后用下面的内容替换整个CPP文件内容就可以了

或者你也可以给你用户定制一个个性化的桌面。改改上面的代码可以得到你要的效果的。

The WM_NCLBUTTONDOWN message is posted when the user presses the left mouse button while the cursor is within the nonclient area of a window. This message is posted to the window that contains the cursor. If a window has captured the mouse, this message is not posted.

class A
{
public:
 virtual void FA() = 0;
};
class B
{
public:
 virtual void FB() = 0;
};
class C : public A , public B
{
public:
 void FA(){cout<<"FA"<<endl;}
 void FB(){cout<<"FB"<<endl;}
};
int main()
{
 C* mc = new C();
 B* mb = static_cast<B*>(mc);
 ((A*)mb)->FA();
 return 0;
}

输出的是FB, com中利用这机制实现了聚合。

         按OK后，如果马上编译的话会出现如下错误：
LIBCMTD.lib(crt0.obj) : error LNK2001: unresolved external symbol _main
Debug/Dll.dll : fatal error LNK1120: 1 unresolved externals
打开VC++菜单Project\Settings\C/C++选项卡，如下图，在Project Options：末尾的地方添加”/D”（图中蓝色高亮的地方），要注意位置，我试了，要把/D放到/GZ后面也会链接错误，我也不懂为什么，^_^。按OK，再次编译，成功。大家可以自己测试下到底有没有更改成功，什么，如果测试？打出调式信息啊。

1.4 DisableThreadLibraryCalls
看帮助就知道它是干么用的：
The DisableThreadLibraryCalls function disables the DLL_THREAD_ATTACH and DLL_THREAD_DETACH notifications for the dynamic-link library (DLL) specified by hLibModule. This can reduce the size of the working code set for some applications.

原文地址：http://www.blogjava.net/Yipak/articles/182025.html

int __stdcall Sub(int numa, int numb)
{
        return (numa - numb);
}

然后创建一个.def的文件，在里面加上

;DllTestDef.lib : 导出DLL函数
;作者：----
LIBRARY defDll.dll
EXPORTS
Add @ 1
Sub @ 2

           最后创建一个测试程序：.cpp文件如下：
#include <iostream>
#include <windows.h>
using namespace std;

typedef int (__stdcall *Fun)(int , int);
HINSTANCE hInstance;
Fun fun;

int main()
{
 hInstance = LoadLibrary("defDll.dll");

 if (!hInstance)
  cout<<"Not Find this Dll"<<endl;
 fun = (Fun)GetProcAddress(hInstance, MAKEINTRESOURCE(1));
 cout<<fun(12,3)<<endl;;
 fun = (Fun)GetProcAddress(hInstance, "Sub");
 cout<<fun(7, 3)<<endl;
 FreeLibrary(hInstance);
}

msdn中：

Handle to a bitmap.typedef HANDLE HBITMAP;

cbitmap是mfc中封装bitmap的类；

msdn中：

Encapsulates（囊括） a Windows graphics device interface (GDI) bitmap and provides member functions to manipulate（操作） the bitmap.

 
class CBitmap : public CGdiObject转化方法两种，
Attach和FromHandle：
CBitmap bmp;
bmp.LoadBitmap(IDB_BITMAP1);
HBITMAP hbm = (HBITMAP)bmp;
CBitmap bmp1;
bmp1.Attach(hbm);
HBITMAP = CBitmap.m_hObject;
CBitmap* = CBitmap.FromHandle(HBITMAP)//已知
HBITMAP hbit;
CBitmap cb;
cb.FromHandle(hbit);//已知
CBitmap cb;
HBITMAP hbit=(HBITMAP)cb;
CBitmap bmp;HBITMAP hBmp;
相互转换：hBmp=(HBITMAP)bmp.GetSafeHandle();bmp.Attach(hBmp);
注意点：Attach和FromHandle的区别FromHandle得到的指针是临时变量，,通过Attach连接的句柄可以长久保留,但通过FromHandle得到的只是暂时的,大概只在一个消息区间内有效,很快便会被删除,所以基本上不能用。我用了FromHandle然后一直出错！！！

CBitmap 无法从文件中加载位图，可以用下面的方法解决。

       MFC 消息控制流最具特色的地方是CWnd类的虚拟函数PreTranslateMessage()，通过重载这个函数，可以改变MFC的消息控制流程，甚至可以作一个全新的控制流出来。只有穿过消息队列的消息才受PreTranslateMessage()影响，采用SendMessage()或其他类似的方式向窗口直接发送的而不经过消息队列的消息根本不会理睬PreTranslateMessage()的存在。 

       是否调用TranslateMessage()和DispatchMessage()是由一个名称为PreTranslateMessage()函数的返回值决定的，如果该函数返回TRUE，则不会把该消息分发给窗口函数处理。

传给PreTranslateMessage()的消息是未经翻译过的消息，它没有经过TranslateMessage()处理。可以在该函数中使用(pMsg->wParam==VK_RETURN)来拦截回车键。wParam中存放的是键盘上字符的虚拟码。

PeekMessage和GetMessage的区别：

GetMessage在没有消息的时候等待消息，cpu当然低

PeekMessage没有消息的时候立刻返回，所以cpu占用率高。

因为游戏不能靠windows消息驱动，所以要用PeekMessage();

     PretranslateMessage 的实现，不得不谈到MFC消息循环的实现。MFC通过CWinApp类中的Pumpmessage函数实现消息循环，但是实际的消息循环代码位于 CWinThread中，CWinApp只是从CWinThread继承过来。其简化后的代码大概如下：
　　BOOL CWinThread::PumpMessage()
　　{
　　_AFX_THREAD_STATE *pState = AfxGetThreadState();
　　
　　::GetMessage(&(pState->m_msgCur), NULL, NULL, NULL))
　　
　　if (!AfxPreTranslateMessage(&(pState->m_msgCur)))
　　{
　　::TranslateMessage(&(pState->m_msgCur));
　　::DispatchMessage(&(pState->m_msgCur));
　　}
　　return TRUE;
　　}
　　可以看到，PumpMessage在实际的TranslateMessage和DispatchMessage发生之前会调用 AfxPreTranslateMessage，AfxPreTranslateMessage又会调用 CWnd::WalkPreTranslateTree(虽然也会调用其他函数，但是这个最为关键），其代码如下：
　　BOOL PASCAL CWnd::WalkPreTranslateTree(HWND hWndStop, MSG* pMsg)
　　{
　　ASSERT(hWndStop == NULL || ::IsWindow(hWndStop));
　　ASSERT(pMsg != NULL);
　　
　　// walk from the target window up to the hWndStop window checking
　　// if any window wants to translate this message
　　
　　for (HWND hWnd = pMsg->hwnd; hWnd != NULL; hWnd = ::GetParent(hWnd))
　　{
　　CWnd* pWnd = CWnd::FromHandlePermanent(hWnd);
　　if (pWnd != NULL)
　　{
　　// target window is a C window
　　if (pWnd->PreTranslateMessage(pMsg))
　　return TRUE; // trapped by target window (eg: accelerators)
　　}
　　
　　// got to hWndStop window without interest
　　if (hWnd == hWndStop)
　　break;
　　}
　　return FALSE; // no special processing
　　}
　　
　　可以看到，代码还是很直接的。从接受到消息的窗口层层往上遍历，并调用PretranslateMessage看是否返回TRUE，是则结束，否则继续。
　　这里有一个地方非常关键：CWnd *pWnd = CWnd::FromHandlePermanent(hWnd) 这一句代码从当前AfxModuleThreadState拿到Permanent句柄表，从而找到hWnd对应的CWnd

MFC 中PreTranslateMessage是GetMessage(...)函数的下一级操作，即GetMessage(...)从消息队列中获取消息后，交由PreTranslateMessage（）处理，若其返回FALSE则再交给TranslateMessage和 DispatchMessage处理（进入WindowProc）；  
如果用SendMessage,   则消息直接交到WindowProc处理，所以GetMessage不会取得SendMessage的消息，当然PreTranslateMessage也就不会被调用。   [Page]
如果用PostMessage,则消息进入消息队列，由GetMessage取得，PreTranslateMessage就有机会进行处理。

例子：
按Enter,ESC按是不会退出了

BOOL CComboBoxExDlg::PreTranslateMessage(MSG* pMsg)
{
if(WM_KEYDOWN == pMsg->message )
{
UINT nKey = (int) pMsg->wParam; 
if( VK_RETURN == nKey || VK_ESCAPE == nKey )
return TRUE ;
}

return CDialog::PreTranslateMessage(pMsg);
}

编辑框，如何响应的这个回车的信息
如果你的编辑框定义如下  
  CEdidt   m_cName;       //ID号为IDC_E_NAME  
   
  BOOL   CSecondDlg::PreTranslateMessage(MSG*   pMsg)    
  {  
  //   TODO:   Add   your   specialized   code   here   and/or   call   class  
   
                if   (pMsg->message==WM_KEYDOWN)  
  {  
          //CWnd   *p=GetDlgItem(IDC_E_NAME);  
  CWnd   *   hWnd=GetFocus();  
  //if(pMsg->wParam==13   &&   pMsg->hwnd==m_cName)  
  if(pMsg->wParam==13   &&   hWnd==&m_cName)  
  {  
  处理函数  
  return   TRUE;  
  }  
  else  
  {  
                                                          处理函数  
  }  
  }  
  return   CDialog::PreTranslateMessage(pMsg);  
  }