我用UltraEdit打开生成的xml文件，UltraEdit把它识别为ASCII格式的文本文件，而通过二进制查看，也确实如此，我看了下帮助文档，也没具体提及到这个问题。但后来我仔细整理了一下思路后，发觉这个其实不算什么问题，分析如下。

文档上就说明了，TinyXML是完全支持UTF-8的，可以尝试load一个UTF-8格式的xml文件，完全没有问题，那现在问题是load了一个UTF-8文件后，文件中的字符串，在TiXmlDocument对象中，到底是什么格式？TinyXML在load它之后会不会直接把UTF-8格式转为Unicode格式？——不会，为什么？因为TinyXML在编写的时候是把自己定位为一个比较单纯的C++ Lib，它没有使用任何Windows相关的API，包括很重要的两个编码转换函数WideCharToMultiByte和MultiByteToWideChar，它都没用，对不同平台，编码转换函数可能是不同的，因此TinyXML不会画蛇添足地提供这个转换，也就是说，如果你的xml文件（UTF-8格式）中如果有中文的话，用TinyXML加载进来之后，依旧是UTF-8的，不经过转换直接print出来的话，就是乱码了，所以要经过一个UTF-8到Unicode的转换，转换代码我这里就不写了。再说一下，TinyXML声称对UTF-8的支持表示它认识UTF-8的xml文件，但并不表示它自动对UTF-8的文本进行转换。

好，再回到保存的问题上，其实你差不多想到了，应该怎么做，因为整个TinyXML其实并不计较内存中的文本究竟是什么内容，它都可以把文本当做是UTF-8（当然了，实际上把文本转为UTF-8然后交给TinyXML的工作是我们的程序去完成），那我们可不可以说保存的xml文件其实就已经是UTF-8格式的？——答案是肯定的。而UTF-8的格式标志其实就是文件头的三个字节：0xEF，0xBB，0xBF。有了这个头，用UltraEdit打开这个xml，UltraEdit就把它认为是一个UTF-8的文本文件了。

这个改动非常简单，稍微浏览下TinyXML的代码就知道怎么改了，我下载的TinyXML是2.6.1版本的（我没记错的话），在tinyxml.cpp文件中搜索“useMicrosoftBOM”，把“useMicrosoftBOM = false;”这个语句改为“useMicrosoftBOM = true;”就可以了，好像一共才三处地方，十分简单，代码一看就懂，不多说了。

写这个程序的时候其实我是想要这么一种加密方法：假如明文只有一个字节，那加密出来的密文应该也只有一个字节。而实际上别人实现好的AES算法加密出来的密文通常都要带上一串随机数，不太符合我的要求。

没有什么include，没有什么LIB，更没有什么DLL，代码再简单不过，但我保证它很有效，OK，不多说了，看代码：

写完了，运行结果是如下：

241 206 235 249 4 160 190 73 253 196
160 238 105 243 18 190 10 97 26 66
182 218 99 73 40 204 208 123 196 46
76 208 117 159 38 66 234 117 142 52
66 63 135 193 60 49 228 15 12 58
131 252 1 171 96 72 254 198 171 201
110 242 27 189 199 108 136 12 177 215
88 66 156 183 221 142 27 45 61 221
122 158 39 174 123 112 156 241 77 227
112 148 57 67 225 30 47 49 83 94

48 49 50 51 52 53 54 55 56 57
48 49 50 51 52 53 54 55 56 57
48 49 50 51 52 53 54 55 56 57
48 49 50 51 52 53 54 55 56 57
48 49 50 51 52 53 54 55 56 57
48 49 50 51 52 53 54 55 56 57
48 49 50 51 52 53 54 55 56 57
48 49 50 51 52 53 54 55 56 57
48 49 50 51 52 53 54 55 56 57
48 49 50 51 52 53 54 55 56 57 Press any key to continue

上面这段是密文，看起来是不是完全没有原文的样子了？你试试看把TEST_LEN改为1，只加密一个字节看，这也是允许的，代码纯C，移植性很好，拿去别处用也方便。但对安全性要求高的应用可能不能使用这种方法了，至于怎么样才算安全，我也不知道，密码学方面的东西我最害怕了。

在TCP/IP网络中两个进程间的相互作用的主机模式是客户机/服务器模式(Client/Server model)。该模式的建立基于以下两点：
1、非对等作用；
2、通信完全是异步的。
客户机/服务器模式在操作过程中采取的是主动请示方式。

服务器方要先启动，并根据请示提供相应服务，过程如下：
1、打开一通信通道并告知本地主机，它愿意在某一个公认地址上接收客户请求。
2、等待客户请求到达该端口。
3、接收到重复服务请求，处理该请求并发送应答信号。
4、返回第二步，等待另一客户请求
5、关闭服务器。

然后死客户方：
1、打开一通信通道，并连接到服务器所在主机的特定端口。
2、向服务器发送服务请求报文，等待并接收应答；继续提出请求……
3、请求结束后关闭通信通道并终止。

二、基本套接字

为了更好说明套接字编程原理，给出几个基本的套接字，在以后的篇幅中会给出更详细的使用说明。

1、创建套接字——socket()
功能：使用前创建一个新的套接字
格式：SOCKET PASCAL FAR socket(int af,int type,int procotol);
af: 通信发生的区域
type: 要建立的套接字类型
procotol: 使用的特定协议

2、指定本地地址——bind()
功能：将套接字地址与所创建的套接字号联系起来。
格式：int PASCAL FAR bind(SOCKET s,const struct sockaddr FAR * name,int namelen);
s: 是由socket()调用返回的并且未作连接的套接字描述符（套接字号）。
其它：没有错误，bind()返回0，否则SOCKET_ERROR

地址结构说明：

3、建立套接字连接——connect()和accept()
功能：共同完成连接工作
格式：int PASCAL FAR connect(SOCKET s,const struct sockaddr FAR * name,int namelen);
格式：SOCKET PASCAL FAR accept(SOCKET s,struct sockaddr FAR * name,int FAR * addrlen);
(参数同上)

4、监听连接——listen()
功能：用于面向连接服务器，表明它愿意接收连接。
格式：int PASCAL FAR listen(SOCKET s, int backlog);

5、数据传输——send()与recv()
功能：数据的发送与接收
格式：int PASCAL FAR send(SOCKET s,const char FAR * buf,int len,int flags);
格式：int PASCAL FAR recv(SOCKET s,const char FAR * buf,int len,int flags);
buf:指向存有传输数据的缓冲区的指针。

6、多路复用——select()
功能：用来检测一个或多个套接字状态。
格式：int PASCAL FAR select(int nfds,fd_set FAR * readfds,fd_set FAR * writefds,
 fd_set FAR * exceptfds,const struct timeval FAR * timeout);
readfds:指向要做读检测的指针
writefds:指向要做写检测的指针
exceptfds:指向要检测是否出错的指针
timeout:最大等待时间

7、关闭套接字——closesocket()
功能：关闭套接字s
格式：BOOL PASCAL FAR closesocket(SOCKET s);

三、典型过程图

2.1 面向连接的套接字的系统调用时序图

2.2 无连接协议的套接字调用时序图

2.3 面向连接的应用程序流程图

四、WinSock简介

Windows Sockets 是从 Berkeley Sockets 扩展而来的，其在继承 Berkeley Sockets 的基础上，又进行了新的扩充。这些扩充主要是提供了一些异步函数，并增加了符合WINDOWS消息驱动特性的网络事件异步选择机制。

Windows Sockets由两部分组成：开发组件和运行组件。
开发组件：Windows Sockets 实现文档、应用程序接口(API)引入库和一些头文件。
运行组件：Windows Sockets 应用程序接口的动态链接库(WINSOCK.DLL)。

五、WinSock主要扩充说明

1、异步选择机制
Windows Sockets 的异步选择函数提供了消息机制的网络事件选择，当使用它登记网络事件发生时，应用程序相应窗口函数将收到一个消息，消息中指示了发生的网络事件，以及与事件相关的一些信息。Windows Sockets 提供了一个异步选择函数 WSAAsyncSelect()，用它来注册应用程序感兴趣的网络事件，当这些事件发生时，应用程序相应的窗口函数将收到一个消息。

函数结构如下：
int PASCAL FAR WSAAsyncSelect(SOCKET s,HWND hWnd,unsigned int wMsg,long lEvent);
hWnd：窗口句柄
wMsg：需要发送的消息
lEvent：事件（以下为事件的内容）

事件值含义：
FD_READ 期望在套接字上收到数据（即读准备好）时接到通知
FD_WRITE 期望在套接字上可发送数据（即写准备好）时接到通知
FD_OOB 期望在套接字上有带外数据到达时接到通知
FD_ACCEPT 期望在套接字上有外来连接时接到通知
FD_CONNECT 期望在套接字连接建立完成时接到通知
FD_CLOSE 期望在套接字关闭时接到通知

例如：我们要在套接字读准备好或写准备好时接到通知，语句如下：
rc=WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE);
如果我们需要注销对套接字网络事件的消息发送，只要将 lEvent 设置为0

2、异步请求函数
在 Berkeley Sockets 中请求服务是阻塞的，WINDOWS SICKETS 除了支持这一类函数外，还增加了相应的异步请求函数——WSAAsyncGetXByY。

3、阻塞处理方法
Windows Sockets 为了实现当一个应用程序的套接字调用处于阻塞时，能够放弃CPU让其它应用程序运行，它在调用处于阻塞时便进入一个叫“HOOK”的例程，此例程负责接收和分配WINDOWS消息，使得其它应用程序仍然能够接收到自己的消息并取得控制权。

WINDOWS 是非抢先的多任务环境，即若一个程序不主动放弃其控制权，别的程序就不能执行。因此在设计Windows Sockets 程序时，尽管系统支持阻塞操作，但还是反对程序员使用该操作。但由于 SUN 公司下的 Berkeley Sockets 的套接字默认操作是阻塞的，WINDOWS 作为移植的 SOCKETS 也不可避免对这个操作支持。

在Windows Sockets 实现中，对于不能立即完成的阻塞操作做如下处理：DLL初始化→循环操作。在循环中，它发送任何 WINDOWS 消息，并检查这个 Windows Sockets 调用是否完成，在必要时，它可以放弃CPU让其它应用程序执行（当然使用超线程的CPU就不会有这个麻烦了^_^）。我们可以调用 WSACancelBlockingCall() 函数取消此阻塞操作。

在 Windows Sockets 中，有一个默认的阻塞处理例程 BlockingHook() 简单地获取并发送 WINDOWS 消息。如果要对复杂程序进行处理，Windows Sockets 中还有 WSASetBlockingHook() 提供用户安装自己的阻塞处理例程能力；与该函数相对应的则是 WSAUnhookBlockingHook()，它用于删除先前安装的任何阻塞处理例程，并重新安装默认的处理例程。请注意，设计自己的阻塞处理例程时，除了函数 WSACancelBlockingHook() 之外，它不能使用其它的 Windows Sockets API 函数。在处理例程中调用 WSACancelBlockingHook()函数将取消处于阻塞的操作，它将结束阻塞循环。

4、出错处理

Windows Sockets 为了和以后多线程环境（WINDOWS/UNIX）兼容，它提供了两个出错处理函数来获取和设置当前线程的最近错误号。（WSAGetLastEror()和WSASetLastError()）

5、启动与终止

使用函数 WSAStartup() 和 WSACleanup() 启动和终止套接字。

六、Windows Sockets网络程序设计核心

我们终于可以开始真正的 Windows Sockets 网络程序设计了。不过我们还是先看一看每个 Windows Sockets 网络程序都要涉及的内容。让我们一步步慢慢走。

1、启动与终止

在所有Windows Sockets函数中，只有启动函数WSAStartup()和终止函数WSACleanup()是必须使用的。启动函数必须是第一个使用的函数，而且它允许指定 Windows Sockets API 的版本，并获得 SOCKETS的特定的一些技术细节。本结构如下：

int PASCAL FAR WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);

其中 wVersionRequested 保证 SOCKETS 可正常运行的 DLL 版本，如果不支持，则返回错误信息。我们看一下下面这段代码，看一下如何进行 WSAStartup() 的调用：

关闭函数使用时，任何打开并已连接的 SOCK_STREAM 套接字被复位，但那些已由 closesocket() 函数关闭的但仍有未发送数据的套接字不受影响，未发送的数据仍将被发送。程序运行时可能会多次调用 WSAStartuo() 函数，但必须保证每次调用时的 wVersionRequested 的值是相同的。

2、异步请求服务

Windows Sockets 除支持 Berkeley Sockets 中同步请求，还增加了了一类异步请求服务函数 WSAAsyncGerXByY()。该函数是阻塞请求函数的异步版本。应用程序调用它时，由 Windows Sockets DLL 初始化这一操作并返回调用者，此函数返回一个异步句柄，用来标识这个操作。当结果存储在调用者提供的缓冲区，并且发送一个消息到应用程序相应窗口。常用结构如下：

需要注意的是，由于 Windows 的内存对像可以设置为可移动和可丢弃，因此在操作内存对象是，必须保证 WIindows Sockets DLL 对象是可用的。

3、异步数据传输

使用 send() 或 sendto() 函数来发送数据，使用 recv() 或recvfrom() 来接收数据。Windows Sockets 不鼓励用户使用阻塞方式传输数据，因为那样可能会阻塞整个 Windows 环境。下面我们看一个异步数据传输实例。

假设套接字 s 在连接建立后，已经使用了函数 WSAAsyncSelect() 在其上注册了网络事件 FD_READ 和 FD_WRITE，并且 wMsg 值为 UM_SOCK，那么我们可以在 Windows 消息循环中增加如下的分支语句：

4、出错处理

Windows 提供了一个函数来获取最近的错误码 WSAGetLastError()，推荐的编写方式如下：

len = send (s,lpBuffer,len,0);
if((len==SOCKET_ERROR)&&(WSAGetLastError()==WSAWOULDBLOCK)){}

一，快速生成一个DLL

哦，对了，讲解还是用VC++ 6.0（简称VC6）来讲解。在VC6下new一个“Win32 Dynamic-Link Library”的Project，就叫“dllTest”吧，注意不要选择“MFC AppWizard(dll)”，因为……这不属于本文的内容，其实最重要的是：我不太懂（^_^），然后呢，选择“An empty DLL project”即可。

接下来就是创建以这两个文件，并添加到Project中去：

lib.h

lib.cpp

Build！（这么简单的程序不会通不过吧？）你就能看到你的生成目录下有个文件，叫“dllTest.dll”，这就是我们第一个dll，没几行代码，简单吧，但麻雀虽小五脏俱全，我们使用Visual Studio提供的工具“Depends”打开这个文件看看，如图所示，你能看到我们导出的这个函数，add。

这个超微型的dll和普通程序的不同在于add函数的声明，多了一个__declspec(dllexport)，这个是关键，这个修饰符告诉VC6，这个函数需要导出，而前面的extern "C"的意思是这个函数是以C语言的标准来调用的，如果不加extern "C"的话，会怎么样呢？自己试试看吧，Build后再用Depends看看生成的dll。

二、使用这个DLL

用VC6的向导创建一个“Win32 Console Application”的Project，叫“CallDllTest”，然后选择“"A Hello, Word!"Application”，为什么用Console？简单呗。

把CallDllTest.cpp的内容换成以下：
CallDllTest.cpp

Build，然后<Ctrl>+<F5>运行，就能看到结果了，打印了一个“5”出来，说明正常了，有点需要说明的是你得把前面生产的那个DLL和这次生成的EXE放在同一目录下方可。代码很简单，思路就是定义函数指针类型，加载DLL，获取要调用的函数的指针，然后调用，这么一个过程。

三、静态链接

刚才使用LoadLibrary这个API加载DLL的方式叫动态链接，现在来介绍静态链接，其实静态链接用得还更多，只不过你不一定注意到而已，不信的话现在查看一下你刚创建的CallDllTest这个Project的Project Settings，如图：

注意我画红线的这个地方，Kernel32.lib，user32.lib和gdi32.lib等，这些lib叫做“导入库”，并不包含真正有效的代码，真正有效的代码是存放在DLL中的，刚才我们所使用的LoadLibrary这个API，其实就是通过Kernel32.lib链接到Kernel32.dll中去的，也就是说LoadLibrary的实现存在于Kernel32.dll中，而我们是通过Kernel32.lib来找到它的，如果还有兴趣的话，可以用Depends看看Kernel32.dll，看看里面是否有LoadLibrary，里面函数很多，别看花眼了哦，这可是Windows的核心库之一，但可能你并没有找到LoadLibrary，而是找到了，LoadLibraryA和LoadLibraryW，这很正常，因为很多需要使用到字符串的API，都有两个版本，一个是窄字符版，一个是宽字符版，在程序编译链接的时候，编译器会根据你的选项来跟你选择其中一个，这里暂时不展开了。

那如何静态使用前面生成的那个dllTest.dll呢？回到刚才dllTest.dll的那个生成目录，你会发现一个叫dllTest.lib的文件，这就是我前面提到“导入库”，现在改一下CallDllTest.cpp。
CallDllTest.cpp

dllTest.lib这个文件得复制到CallDllTest这个Project的目录下，否则会报找不到文件，执行结果如何？跟刚才是一样的，这种方式就叫静态链接，区别是什么？不需要在运行时调用LoadLibrary了，我个人觉得静态链接用得更多一些。

注意看代码：

这句话很关键，__declspec(dllimport)对应了DllTest中的__declspec(dllexport)，表示该函数将从dll中导入，那你也许要问了：“我怎么知道这个dll中有这个函数？并且还知道这个函数的参数类型和返回值类型？该不会也是用Depends去看吧？”呃……这怎么说呢？如果这个dll是你写的，你当然知道啦，但如果这个Dll不是你写的话，它的作者往往会提供一个头文件，就好像你要使用LoadLibrary，你得包含“windows.h”这个头文件一样，否则就出现符号未定义的编译错误，那么我们改一下lib.h这个头文件。

lib.h

在DllTest这个Project中，DLLTEST_EXPORTS是被定义了的，如图：

所以使用dllexport，而在别的Project中，则使用dllimport。在CallDllTest中include这个lib.h，就可以了，当然你也可以写得更好，我这里仅仅是demo。

四、DLL中的main函数

大家都知道C语言的程序是从main开始的，到了Windows环境下，则换成了WinMain，但也差不多，那DLL有没有类似的入口呢？答案是肯定的，我们来改一下DllTest的lib.cpp。

lib.cpp

你能看到一个叫“DllMain”的函数，它就是dll的入口，oh，当然了，我这篇文章所讲的都是针对Windows操作系统的，Linux的可不一样哦，甚至一般来说，Linux的DLL都不叫“DLL”。

好了，你再按照前面的方法去调用下这个DLL，（记得拷贝这个dll到相应目录去）这时候你就能看到执行结果中多了“process attach of DLL”和“process detach of DLL”，这是很显而易见的，一个进程连接和断开连接到这个dll的时候，DllMain就会被调用，且传递的ul_reason_for_call参数分别是DLL_PROCESS_ATTACH和DLL_PROCESS_DETACH，那什么时候会有“DLL_THREAD_ATTACH”和“DLL_THREAD_DETACH”？当库已经加载，创建新的线程和销毁线程的时候，会分别使用THREAD_ATTACH和THREAD_DETACH参数来调DllMain。

五、调用方式

前面我们导入，导出函数的时候都加了一个“extern "C"”，那不加会怎么样呢？如果再涉及到这几个修饰符：__stdcall，__cdecl和__fastcall，那又会怎样呢？我画了两个表，大家可以比较下，体会下。

这是三种不同调用方式的比较：

这是命名修饰在不同方式下的比较：

如果dll和exe的命名理解不一致，就有可能出错。通常来说，我是习惯于用“extern "C"”和“__cdecl”的组合。

六、导出变量

前面只说了如何导出函数，那如何导出一个变量呢？方法类似，甚至可以说几乎一样，看代码：

lib.cpp

lib.h

这样，就可以了，和导出函数是没什么差别吧？同样，你也可以用Depends观察生成的DLL，你会发现iExportInt这个导出符号，也就是我们导出的这个变量了。现在看CallDllTest的代码：

CallDllTest.cpp

输出是什么？112和113，说明成功了。不知道你这个时候有没有想到一个问题，那就是如果两个进程同时调用dllTest.dll，而且同时修改和读取iExportInt，那会不会乱掉呢？要不要做一个互斥锁呢？答案是：不会，不需要。这得益于Windows内存管理的一个底层实现技术，叫Copy-on-write，在调用执行“iExportInt++”的时候，其实并非真正修改了DLL中的值，而是做了一份拷贝，通过内存映射机制，使得程序访问的那个“iExportInt”其实是那份拷贝，而另一进程使用的也是自己的拷贝，互不干涉。

七、共享内存

紧接着前面这个问题，那如果我企图通过DLL来让不同进程共享一段内存，而不是让系统执行默认的Copy-on-write操作，那怎么办呢？有办法！这是Microsoft提供的一个方法，个人觉得是个不错的进程间通信的方法，比如两个进程需要交换一大块数据，而且这一大块数据变化比较频繁，通过数据库啊，文件啊，就显得有点慢，如果通过socket啊，管道啊，就显得有些不直接，还是直接使用共享内存来得直接，但很多人并不知道这个功能，我这里跟大家分享下。

lib.h

lib.cpp

Build一下，然后用Depends看看输出情况。现在来改CallDllText.cpp。这里有非常要注意的两个地方，一是“={0}”这个初始化，这是必须的，否则共享将不起作用，Microsoft规定了共享段一定需要先初始化，哪怕只是给第一个元素赋个随便什么值都好，如这个例子，我只是给第一个元素赋值了个0；另一处要注意的是“/SECTION:shared,RWS"这个字符串，中间可别要有空格，否则你同样会发现共享不起作用，我当时调试就很郁闷，因为我习惯在英文逗号后加个空格。

CallDllText.cpp

Sleep(10000)会让程序堵塞10秒钟，这样就可以运行多个程序的副本，来观察共享的效果。

八、结束

DLL涵盖的知识面相当广，本文只是篇入门级的文章，介绍了一些比较实用的内容而已，如果要进一步学习，需要看看《Windows核心编程》这种经典著作，关于DLL的很多内容我都没有提及到，比如DLL的导出方法其实有好几种，我介绍的只是其中一种，但我认为我介绍的方法是最好用而且是最简单的。我们写程序，是为了实现某些应用，而不是为了炫耀某些技术，所以我是偏向于使用成熟，可靠和易行的方法。

#include <math.h>

void RegulateAll(double dMin, double dMax, int iMaxAxisNum);

int main(int argc, char* argv[])
{
     RegulateAll(2, 45, 7);
       RegulateAll(0.12, 0.43, 5);
       RegulateAll(10001, 10002, 5);
       RegulateAll(-12.65, 56.3, 6);
       RegulateAll(5243217834.12, 5378234435.12, 5);
      RegulateAll(-0.043, 0.099, 8);
     RegulateAll(-123431, -67325, 10);
     RegulateAll(0.0, 0.0, 5);
    return 0;
}

void RegulateAll(double dMin, double dMax, int iMaxAxisNum)
{
    if(iMaxAxisNum<1 || dMax<dMin)
        return;

    double dDelta = dMax - dMin;
    if(dDelta<1.0) //Modify this by your requirement.
    {
        dMax+=(1.0-dDelta)/2.0;
        dMin-=(1.0-dDelta)/2.0;
    }
    dDelta = dMax - dMin;

    int iExp = (int)(log(dDelta)/log(10.0))-2;
    double dMultiplier = pow(10, iExp);
    const double dSolutions[] = {1, 2, 2.5, 5, 10, 20, 25, 50, 100, 200, 250, 500};
    int i;
    for(i=0; i<sizeof(dSolutions)/sizeof(double); i++)
    {
        double dMultiCal = dMultiplier * dSolutions[i];
        if(((int)(dDelta/dMultiCal) + 1)<=iMaxAxisNum)
        {
            break;
        }
    }

    double dInterval = dMultiplier * dSolutions[i];

    double dStartPoint = ((int)ceil(dMin/dInterval) - 1) * dInterval;
    int iAxisIndex;
    for(iAxisIndex=0; 1; iAxisIndex++)
    {
        printf("%f", dStartPoint+dInterval*iAxisIndex);
        if(dStartPoint+dInterval*iAxisIndex>dMax)
            break;
        printf(" | ");
    }

    printf("\n");
}

除开打印和前面的条件判断外，真的没几行，而且只用了一个非常有限的迭代，效率自然是很高的。

这是表示，如果生成调试版本，要指示当前文件的名称。__FILE__是一个宏，在编译器编译过程中给它赋值为当前正在编译的文件名称。

vc.net默认情况下使用预编译头(/Yu)，不明白的在加入新.h文件后编译时总出现fatal error C1010: 在查找预编译头指令时遇到意外的文件结尾的错误。解决方法是在在include头文件的地方加上#include "stdafx.h",或者打项目属性，找到“C/C++”文件夹，单击“预编译头”属性页。修改“创建/使用预编译头”属性为“不使用预编译头”。

二、C/C++头文件一览

C、传统 C++
#include <assert.h>　　　　//设定插入点
#include <ctype.h>　　　　 //字符处理
#include <errno.h>　　　　 //定义错误码
#include <float.h>　　　　 //浮点数处理
#include <fstream.h>　　　 //文件输入／输出
#include <iomanip.h>　　　 //参数化输入／输出
#include <iostream.h>　　　//数据流输入／输出
#include <limits.h>　　　　//定义各种数据类型最值常量
#include <locale.h>　　　　//定义本地化函数
#include <math.h>　　　　　//定义数学函数
#include <stdio.h>　　　　 //定义输入／输出函数
#include <stdlib.h>　　　　//定义杂项函数及内存分配函数
#include <string.h>　　　　//字符串处理
#include <strstrea.h>　　　//基于数组的输入／输出
#include <time.h>　　　　　//定义关于时间的函数
#include <wchar.h>　　　　 //宽字符处理及输入／输出
#include <wctype.h>　　　　//宽字符分类

标准 C++　（同上的不再注释）
#include <algorithm>　　　 //STL 通用算法
#include <bitset>　　　　　//STL 位集容器
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex>　　　　 //复数类
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>　　　　　 //STL 双端队列容器
#include <exception>　　　 //异常处理类
#include <fstream>
#include <functional>　　　//STL 定义运算函数（代替运算符）
#include <limits>
#include <list>　　　　　　//STL 线性列表容器
#include <map>　　　　　　 //STL 映射容器
#include <iomanip>
#include <ios>　　　　　　 //基本输入／输出支持
#include <iosfwd>　　　　　//输入／输出系统使用的前置声明
#include <iostream>
#include <istream>　　　　 //基本输入流
#include <ostream>　　　　 //基本输出流
#include <queue>　　　　　 //STL 队列容器
#include <set>　　　　　　 //STL 集合容器
#include <sstream>　　　　 //基于字符串的流
#include <stack>　　　　　 //STL 堆栈容器　　　　
#include <stdexcept>　　　 //标准异常类
#include <streambuf>　　　 //底层输入／输出支持
#include <string>　　　　　//字符串类
#include <utility>　　　　 //STL 通用模板类
#include <vector>　　　　　//STL 动态数组容器
#include <cwchar>
#include <cwctype>

using namespace std;

C99 增加
#include <complex.h>　　 //复数处理
#include <fenv.h>　　　　//浮点环境
#include <inttypes.h>　　//整数格式转换
#include <stdbool.h>　　 //布尔环境
#include <stdint.h>　　　//整型环境
#include <tgmath.h>　　　//通用类型数学宏

三、预处理的由来

在C++的历史发展中，有很多的语言特征（特别是语言的晦涩之处）来自于C语言，预处理就是其中的一个。C++从C语言那里把C语言预处理器继承过来，C语言预处理器，被Bjarne博士(C++之父)简称为Cpp，不知道是不是C Program Preprocessor的简称。

四、常见的预处理功能

预处理器的主要作用就是把通过预处理的内建功能对一个资源进行等价替换，最常见的预处理有：文件包含，条件编译、布局控制和宏替换4种。

1，文件包含：#include 是一种最为常见的预处理，主要是做为文件的引用组合源程序正文。
2，条件编译：#if,#ifndef,#ifdef,#endif,#undef等也是比较常见的预处理，主要是进行编译时进行有选择的挑选，注释掉一些指定的代码，以达到版本控制、防止对文件重复包含的功能。
3，布局控制：#pragma，这也是我们应用预处理的一个重要方面，主要功能是为编译程序提供非常规的控制流信息。
4，宏替换：#define，这是最常见的用法，它可以定义符号常量、函数功能、重新命名、字符串的拼接等各种功能。

五、预处理指令

预处理指令的格式如下：

#directive tokens

#符号应该是这一行的第一个非空字符，一般我们把它放在起始位置。如果指令一行放不下，可以通过“\”进行控制，例如：

#define Error if(error) exit(1)

等价于

#define Error \
if(error) exit(1)

下面我们看一下常见的预处理指令：
#define 宏定义
#undef 未定义宏
#include 文本包含
#ifdef 如果宏被定义就进行编译
#ifndef 如果宏未被定义就进行编译
#endif 结束编译块的控制
#if 表达式非零就对代码进行编译
#else 作为其他预处理的剩余选项进行编译
#elif 这是一种#else和#if的组合选项
#line 改变当前的行数和文件名称
#error 输出一个错误信息
#pragma 为编译程序提供非常规的控制流信息

下面我们对这些预处理进行一一的说明，考虑到宏的重要性和繁琐性，我们把它放到最后讲。

六、文件包含指令

这种预处理使用方式是最为常见的，平时我们编写程序都会用到，最常见的用法是：
#include <iostream> //标准库头文件
#include <iostream.h> //旧式的标准库头文件
#include "IO.h" //用户自定义的头文件
#include "../file.h" //UNIX下的父目录下的头文件
#include "/usr/local/file.h" //UNIX下的完整路径
#include "..\file.h" //Dos下的父目录下的头文件
#include "\usr\local\file.h" //Dos下的完整路径

（其实DOS/Windows的目录分隔也可以用斜杠，为了和Unix兼容，就统一用斜杠吧）

这里面有2个地方要注意：

1、我们用<iostream>还是<iostream.h>?

我们主张使用<iostream>，而不是<iostream.h>,为什么呢？我想你可能还记得我曾经给出过几点理由，这里我大致的说一下：

首先，h格式的头文件早在98年9月份就被标准委员会抛弃了，我们应该紧跟标准，以适合时代的发展。其次，iostream.h只支持窄字符集，iostream则支持窄/宽字符集。还有，标准对iostream作了很多的改动，接口和实现都有了变化。最后，iostream组件全部放入namespace std中，防止了名字污染。

2、<io.h>和"io.h"的区别？

其实他们唯一的区别就是搜索路径不同：对于#include <io.h> ，编译器从标准库路径开始搜索对于#include "io.h" ，编译器从用户的工作路径开始搜索。

七、编译控制指令

这些指令的主要目的是进行编译时进行有选择的挑选，注释掉一些指定的代码，以达到版本控制、防止对文件重复包含的功能。使用格式，如下：

1、#ifdef identifier

如果identifier为一个定义了的符号，your code就会被编译，否则剔除。
#ifdef identifier
your code
#endif

2、#ifndef identifier

如果identifier为一个未定义的符号，your code就会被编译，否则剔除。
#ifndef identifier
your code
#endif

3、#if expression

如果expression非零，your code就会被编译，否则剔除。
#if expression
your code
#endif

4、#ifdef identifier

如果identifier为一个定义了的符号，your code1就会被编译，否则your code2就会被编译。
#ifdef identifier
your code1
#else
your code2
#endif

5、#else与#elif

如果epression1非零，就编译your code1，否则，如果expression2非零，就编译your code2，否则，就编译your code3。
#if expressin1
your code1
#elif expression2 //呵呵，elif
your code2
#else
your code3
#enif

其他预编译指令除了上面我们说的集中常用的编译指令，还有3种不太常见的编译指令：#line、#error、#pragma，我们接下来就简单的谈一下。

6，#line

语法如下：

#line number filename

例如：

#line 30 a.h

其中，文件名a.h可以省略不写。这条指令可以改变当前的行号和文件名，例如上面的这条预处理指令就可以改变当前的行号为30，文件名是a.h。初看起来似乎没有什么用，不过，他还是有点用的，那就是用在编译器的编写中，我们知道编译器对C++源码编译过程中会产生一些中间文件，通过这条指令，可以保证文件名是固定的，不会被这些中间文件代替，有利于进行分析。

7，#error

语法如下：

#error info

例如：

#ifndef UNIX
#error This software requires the UNIX OS.
#endif

这条指令主要是给出错误信息，上面的这个例子就是，如果没有在UNIX环境下，就会输出This software requires the UNIX OS.然后诱发编译器终止。所以总的来说，这条指令的目的就是在出现其它编译错误之前能够给出一定的信息。

8，#pragma

它是非统一的，他要依靠各个编译器生产者。例如VC++中：

#pragma comment(lib,"dllTest.lib")

导入库dllTest.lib。

八、预定义标识符

为了处理一些有用的信息，预处理定义了一些预处理标识符，虽然各种编译器的预处理标识符不尽相同，但是他们都会处理下面的4种：

__FILE__ 正在编译的文件的名字
__LINE__ 正在编译的文件的行号
__DATE__ 编译时刻的日期字符串，例如： "25 Dec 2000"
__TIME__ 编译时刻的时间字符串，例如： "12:30:55"

例如：cout<<"The file is :"<<__FILE__"<<"! The lines is:"<<__LINE__<<endl;

九、预处理何去何从

如何取代#include预处理指令，我们在这里就不再一一讨论了。C++并没有为#include提供替代形式，但是namespace提供了一种作用域机制，它能以某种方式支持组合，利用它可以改善#include的行为方式，但是我们还是无法取代#include。

#pragma应该算是一个可有可无的预处理指令，按照Bjarne的话说，就是：“#pragma被过分的经常的用于将语言语义的变形隐藏到编译系统里，或者被用于提供带有特殊语义和笨拙语法的语言扩充。”

对于#ifdef，我们仍然束手无策，就算是我们利用if语句和常量表达式，仍然不足以替代它，因为一个if语句的正文必须在语法上正确，满足类检查，即使他处在一个绝不会被执行的分支里面。

十、预编译头文件的补充说明

这里介绍VC6的预编译功能的使用，由于预编译详细使用比较的复杂，这里只介绍几个最重要的预编译指令: /Yu, /Yc,/Yx,/Fp。其它的详细资料可以参考:

MSDN -> Visual Studio 6.0 Document -> Visual C++ 6.0 Document -> VC++ Programmer Guider -> Compiler and Linker -> Details -> Creating Precompiled Header files

预编译头的概念：

所谓的预编译头就是把一个工程中的那一部分代码，预先编译好放在一个文件里（通常是以.pch为扩展名的），这个文件就称为预编译头文件这些预先编译好的代码可以是任何的C/C++代码，甚至是inline的函数，但是必须是稳定的，在工程开发的过程中不会被经常改变。如果这些代码被修改，则需要重新编译生成预编译头文件。注意生成预编译头文件是很耗时间的。同时你得注意预编译头文件通常很大，通常有6-7M大。注意及时清理那些没有用的预编译头文件。

也许你会问：现在的编译器都有Time stamp的功能，编译器在编译整个工程的时候，它只会编译那些经过修改的文件，而不会去编译那些从上次编译过，到现在没有被修改过的文件。那么为什么还要预编译头文件呢？答案在这里，我们知道编译器是以文件为单位编译的，一个文件经过修改后，会重新编译整个文件，当然在这个文件里包含的所有头文件中的东西（.eg Macro, Preprocessor ）都要重新处理一遍。VC的预编译头文件保存的正是这部分信息。以避免每次都要重新处理这些头文件。

根据上文介绍，预编译头文件的作用当然就是提高便宜速度了，有了它你没有必要每次都编译那些不需要经常改变的代码。编译性能当然就提高了。但根据我的实践经验，使用VC6编译器，在编译一个小程序的时候，用不用预编译头文件，基本看不出编译速度的差距，可能对于一个大型程序来说，这种编译速度差才能体现出来。

要使用预编译头，我们必须指定一个头文件，这个头文件包含我们不会经常改变的代码和其他的头文件，然后我们用这个头文件来生成一个预编译头文件（.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”。原因是理所当然的，我们仅仅是要它能够编译而已―――也就是说，要的只是它的.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.如图：


（图２）

这时原来的Project Option变成了 Source File Option（原来是工程，现在是一个文件，当然变了）。在这里我们可以看到 /Yc开关，/Yc的作用就是指定这个文件来创建一个Pch文件。/Yc后面的文件名是那个包含了稳定代码的头文件，一个工程里只能有一个文件的可以有YC开关。VC就根据这个选项把 StdAfx.cpp编译成一个Obj文件和一个PCH文件。

然后我们再选择一个其它的文件来看看，如图：

（图3）

在这里，Precomplier 选择了 Use ………一项，头文件是我们指定创建PCH 文件的stdafx.h文件。事实上，这里是使用工程里的设置，（如图1）/Yu "stdafx.h"。

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

1，如果使用了/Yu，就是说使用了预编译，我们在每个.cpp文件的最开头，我强调一遍是最开头，包含你指定产生pch文件的.h文件（默认是stdafx.h）不然就会有问题。如果你没有包含这个文件，就告诉你Unexpected file end. 如果你不是在最开头包含的，你自己试以下就知道了，绝对有很惊人的效果。

2，如果你把pch文件不小心丢了，根据以上的分析，你只要让编译器生成一个pch文件就可以了。也就是说把 stdafx.cpp（即指定/Yc的那个cpp文件）重新编译一遍就可以了。当然你可以傻傻的 Rebuild all。简单一点就是选择那个cpp文件，按一下Ctrl + F7就可以了。

结束后ps区域自动变有效。还有：

这一对需要调用ValidateRect()函数来使得区域有效。

还有别的办法，但不常用，这里略过。不过有一个还是值得一说，那就是取得Window HDC的办法，用它可以在Windows非客户区画图：

4、获取HDC信息
GetDeviceCaps()
其中比较重要的指标是：
HORZRES - horizontal resolution
VERTRES - vertical resolution
BITSPIXEL - 色深

5、保存HDC与还原HDC

6、画图画图！

7、画笔HPEN（改变线条）
方法1：
HPEN hPen = GetStockObject(ARGUMENTS);
ARGUMENTS为：BLACK_PEN 黑笔WHITE_PEN 白笔

方法2：
HPEN hPen = CreatePen(iPenStyle, iWidth, crColor);
iPenStyle为：PS_SOLID实线PS_DASH虚线PS_DOT点线PS_DASHDOT虚点线PS_DASHDOTDOT虚双点线PS_NULL空线PS_INSIDEFRAME？？

获取画笔信息：

选出HDC中的画笔：

8、背景模式
改变背景模式，也就是制定虚线间间隙的填充问题了：

有Set嘛，相应地有Get了，这里略过。

9、叠加模式

10、画刷HBRUSH（改变填充）
画刷能指明区域填充模式。
方法1：

方法2：

11、多边形填充模式及画多边形

12、区域HRGN（绘画范围）

区域合并

注意：hDestRgn, hSrcRgn1, hSrcRgn2都必须有效。

使区域无效/有效：