我们学校的计算机学院从去年起开始组织学生参加世界上最具权威性的大学生程序设计竞赛——ACM/ICPC。从这学期开始，学院计划有组织地进行训练和讲座，以帮助大家在有限的时间内尽可能多地提高自己的能力，这对有兴趣投入数据结构与算法研究的同学来说无疑是一件好事。但是，刚刚接触信息学领域的同学往往存在很多困惑，不知道从何入手学习，在这篇文章里，我希望能将自己不多的经验与大家分享，希望对各位有所帮助。

一、语言是最重要的基本功

    无论侧重于什么方面，只要是通过计算机程序去最终实现的竞赛，语言都是大家要过的第一道关。亚洲赛区的比赛支持的语言包括C/C++与JAVA。笔者首先说说JAVA，众所周知，作为面向对象的王牌语言，JAVA在大型工程的组织与安全性方面有着自己独特的优势，但是对于信息学比赛的具体场合，JAVA则显得不那么合适，它对于输入输出流的操作相比于C++要繁杂很多，更为重要的是JAVA程序的运行速度要比C++慢10倍以上，而竞赛中对于JAVA程序的运行时限却往往得不到同等比例的放宽，这无疑对算法设计提出了更高的要求，是相当不利的。其实，笔者并不主张大家在这种场合过多地运用面向对象的程序设计思维，因为对于小程序来说这不旦需要花费更多的时间去编写代码，也会降低程序的执行效率。

    接着说C和C++。许多现在参加讲座的同学还在上大一，C的基础知识刚刚学完，还没有接触过C++，其实在赛场上使用纯C的选手还是大有人在的，它们主要是看重了纯C在效率上的优势，所以这部分同学如果时间有限，并不需要急着去学习新的语言，只要提高了自己在算法设计上的造诣，纯C一样能发挥巨大的威力。

    而C++相对于C，在输入输出流上的封装大大方便了我们的操作，同时降低了出错的可能性，并且能够很好地实现标准流与文件流的切换，方便了调试的工作。如果有些同学比较在意这点，可以尝试C和C++的混编，毕竟仅仅学习C++的流操作还是不花什么时间的。

    C++的另一个支持来源于标准模版库（STL），库中提供的对于基本数据结构的统一接口操作和基本算法的实现可以缩减我们编写代码的长度，这可以节省一些时间。但是，与此相对的，使用STL要在效率上做出一些牺牲，对于输入规模很大的题目，有时候必须放弃STL，这意味着我们不能存在“有了STL就可以不去管基本算法的实现”的想法；另外，熟练和恰当地使用STL必须经过一定时间的积累，准确地了解各种操作的时间复杂度，切忌对STL中不熟悉的部分滥用，因为这其中蕴涵着许多初学者不易发现的陷阱。

    通过以上的分析，我们可以看出仅就信息学竞赛而言，对语言的掌握并不要求十分全面，但是对于经常用到的部分，必须十分熟练，不允许有半点不清楚的地方，下面我举个真实的例子来说明这个道理——即使是一点很细微的语言障碍，都有可能酿成错误：

    在去年清华的赛区上，有一个队在做F题的时候使用了cout和printf的混合输出，由于一个带缓冲一个不带，所以输出一长就混乱了。只是因为当时judge team中负责F题的人眼睛尖，看出答案没错只是顺序不对（答案有一页多，是所有题目中最长的一个输出），又看了看程序发现只是输出问题就给了个Presentation error（格式错）。如果审题的人不是这样而是直接给一个 Wrong Answer，相信这个队是很难查到自己错在什么地方的。

    现在我们转入第二个方面的讨论，基础学科知识的积累。

二、以数学为主的基础知识十分重要

    虽然被定性为程序设计竞赛，但是参赛选手所遇到的问题更多的是没有解决问题的思路，而不是有了思路却死活不能实现，这就是平时积累的基础知识不够。今年World Final的总冠军是波兰华沙大学，其成员出自于数学系而非计算机系，这就是一个鲜活的例子。竞赛中对于基础学科的涉及主要集中于数学，此外对于物理、电路等等也可能有一定应用，但是不多。因此，大一的同学也不必为自己还没学数据结构而感到不知从何入手提高，把数学捡起来吧！下面我来谈谈在竞赛中应用的数学的主要分支。

    1、离散数学——作为计算机学科的基础，离散数学是竞赛中涉及最多的数学分支，其重中之重又在于图论和组合数学，尤其是图论。

    图论之所以运用最多是因为它的变化最多，而且可以轻易地结合基本数据结构和许多算法的基本思想，较多用到的知识包括连通性判断、DFS和BFS，关节点和关键路径、欧拉回路、最小生成树、最短路径、二部图匹配和网络流等等。虽然这部分的比重很大，但是往往也是竞赛中的难题所在，如果有初学者对于这部分的某些具体内容暂时感到力不从心，也不必着急，可以慢慢积累。

    竞赛中设计的组合计数问题大都需要用组合数学来解决，组合数学中的知识相比于图论要简单一些，很多知识对于小学上过奥校的同学来说已经十分熟悉，但是也有一些部分需要先对代数结构中的群论有初步了解才能进行学习。组合数学在竞赛中很少以难题的形式出现，但是如果积累不够，任何一道这方面的题目却都有可能成为难题。

    2、数论——以素数判断和同余为模型构造出来的题目往往需要较多的数论知识来解决，这部分在竞赛中的比重并不大，但只要来上一道，也足以使知识不足的人冥思苦想上一阵时间。素数判断和同余最常见的是在以密码学为背景的题目中出现，在运用密码学常识确定大概的过程之后，核心算法往往要涉及数论的内容。

    3、计算几何——计算几何相比于其它部分来说是比较独立的，就是说它和其它的知识点很少有过多的结合，较常用到的部分包括——线段相交的判断、多边形面积的计算、内点外点的判断、凸包等等。计算几何的题目难度不会很大，但也永远不会成为最弱的题。

    4、线性代数——对线性代数的应用都是围绕矩阵展开的，一些表面上是模拟的题目往往可以借助于矩阵来找到更好的算法。

    5、概率论——竞赛是以黑箱来判卷的，这就是说你几乎不能动使用概率算法的念头，但这也并不是说概率就没有用。关于这一点，只有通过一定的练习才能体会。

    6、初等数学与解析几何——这主要就是中学的知识了，用的不多，但是至少比高等数学多，我觉得熟悉一下数学手册上的相关内容，至少要知道在哪儿能查到，还是必要的。

    7、高等数学——纯粹运用高等数学来解决的题目我接触的只有一道，但是一些题目的叙述背景往往需要和这部分有一定联系，掌握得牢固一些总归没有坏处。

    以上就是竞赛所涉及的数学领域，可以说范围是相当广的。我认识的许多人去搞信息学的竞赛就是为了逼着自己多学一点数学，因为数学是一切一切的基础。

三、数据结构与算法是真正的核心

    虽然数学十分十分重要，但是如果让三个只会数学的人参加比赛，我相信多数情况下会比三个只会数据结构与算法的人得到更为悲惨的结局。

    先说说数据结构。掌握队列、堆栈和图的基本表达与操作是必需的，至于树，我个人觉得需要建树的问题有但是并不多。（但是树往往是很重要的分析工具）除此之外，排序和查找并不需要对所有方式都能很熟练的掌握，但你必须保证自己对于各种情况都有一个在时间复杂度上满足最低要求的解决方案。说到时间复杂度，就又该说说哈希表了，竞赛时对时间的限制远远多于对空间的限制，这要求大家尽快掌握“以空间换时间”的原则策略，能用哈希表来存储的数据一定不要到时候再去查找，如果实在不能建哈希表，再看看能否建二叉查找树等等——这都是争取时间的策略，掌握这些技巧需要大家对数据结构尤其是算法复杂度有比较全面的理性和感性认识。

    接着说说算法。算法中最基本和常用的是搜索，主要是回溯和分支限界法的使用。这里要说的是，有些初学者在学习这些搜索基本算法是不太注意剪枝，这是十分不可取的，因为所有搜索的题目给你的测试用例都不会有很大的规模，你往往察觉不出程序运行的时间问题，但是真正的测试数据一定能过滤出那些没有剪枝的算法。实际上参赛选手基本上都会使用常用的搜索算法，题目的区分度往往就是建立在诸如剪枝之类的优化上了。

    常用算法中的另一类是以“相似或相同子问题”为核心的，包括递推、递归、贪心法和动态规划。这其中比较难于掌握的就是动态规划，如何抽象出重复的子问题是很多题目的难点所在，笔者建议初学者仔细理解图论中一些以动态规划为基本思想所建立起来的基本算法（比如Floyd-Warshall算法），并且多阅读一些定理的证明，这虽然不能有什么直接的帮助，但是长期坚持就会对思维很有帮助。

四、团队配合

    通过以上的介绍大家也可以看出，信息学竞赛对于知识面覆盖的非常广，想凭一己之力全部消化这些东西实在是相当困难的，这就要求我们尽可能地发挥团队协作的精神。同组成员之间的熟练配合和默契的形成需要时间，具体的情况因成员的组成不同而不同，这里我就不再多说了。

五、练习、练习、再练习

    知识的积累固然重要，但是信息学终究不是看出来的，而是练出来的，这是多少前人最深的一点体会，只有通过具体题目的分析和实践，才能真正掌握数学的使用和算法的应用，并在不断的练习中增加编程经验和技巧，提高对时间复杂度的感性认识，优化时间的分配，加强团队的配合。总之，在这里光有纸上谈兵是绝对不行的，必须要通过实战来锻炼自己。

    大家一定要问，我们去哪里找题做，又如何检验程序是否正确呢？这大可不必担心，现在已经有了很多网上做题的站点，这些站点提供了大量的题库并支持在线判卷，你只需要把程序源码提交上去，马上就可以知道自己的程序是否正确，运行所使用的时间以及消耗的内存等等状况。下面我给大家推荐几个站点，笔者不建议大家在所有这些站点上做题，选择一个就可以了，因为每个站点的题都有一定的难易比例，系统地做一套题库可以使你对各种难度、各种类型的题都有所认识。

    1、Ural：

    Ural是中国学生对俄罗斯的Ural州立大学的简称 ，那里设立了一个Ural Online Problem Set，并且支持Online Judge。Ural的不少题目算法性和趣闻性都很强，得到了国内广大学生的厚爱。根据“信息学初学者之家”网站的统计，Ural的题目类型大概呈如下的分布：

    这和实际比赛中的题型分布也是大体相当的。有兴趣的朋友可以去看看。

    2、UVA：

    UVA代表西班牙Valladolid大学(University de Valladolid)。该大学有一个那里设立了一个PROBLEM SET ARCHIVE with ONLINE JUDGE ，并且支持ONLINE JUDGE，形式和Ural大学的题库类似。不过和Ural不同的是，UVA题目多的多，而且比较杂，而且有些题目的测试数据比较刁钻。这使得刚到那里做题的朋友往往感觉到无所适从，要么难以找到合适的题目，要么Wrong Answer了很多次以后仍然不知道错在那里。 如果说做Ural题目主要是为了训练算法，那么UVA题目可以训练全方位的基本功和一些必要的编程素质。UVA和许多世界知名大学联合办有同步网上比赛，因此那里强人无数，不过你先要使自己具有听懂他们在说什么的素质：）

    3、ZOJ：

    ZOJ是浙江大学建立的ONLINE JUDGE，是中国大学建立的第一个同类站点，也是最好和人气最高的一个，笔者和许多班里的同学就是在这里练习。ZOJ虽然也定位为一个英文网站，但是这里的中国学生比较多，因此让人觉得很亲切。这里目前有500多道题目，难易分配适中，且涵盖了各大洲的题目类型并配有索引，除此之外，ZOJ的JUDGE系统是几个网站中表现得比较好的一个，很少出现Wrong Answer和Presentation error混淆的情况。这里每月也办有一次网上比赛，只要是注册的用户都可以参加。

        说起中国的ONLINE JUDGE，去年才开始参加ACM竞赛的北京大学现在也建立了自己的提交系统；而我们学校也是去年开始参加比赛，现在也有可能推出自己的提交系统，如果能够做成，到时候大家就可以去上面做题了。同类网站的飞速发展标志着有越来越多的同学有兴趣进入信息学的领域探索，这是一件好事，同时也意味着更激烈的竞争，希望大家都能通过竞争锻炼自己、提高自己，并争取成为胜利者。

在DOS下的Microsoft Network Client和Windows 9x的DOS窗口等环境中，有许多很有用的但不包含在DOS自带的命令中的网络命令。那么，有哪些这样的命令呢？下面将它们中常用的命令介绍一下。

Arp

显示和修改“地址解析协议”(ARP) 所使用的到以太网的 IP 或令牌环物理地址翻译表。该命令只有在安装了 TCP/IP 协议之后才可用。
arp -a [inet_addr] [-N [if_addr]]
arp -d inet_addr [if_addr]
arp -s inet_addr ether_addr [if_addr]
参数
-a
通过询问 TCP/IP 显示当前 ARP 项。如果指定了 inet_addr，则只显示指定计算机的 IP 和物理地址。
-g
与 -a 相同。
inet_addr
以加点的十进制标记指定 IP 地址。
-N
显示由 if_addr 指定的网络界面 ARP 项。
if_addr
指定需要修改其地址转换表接口的 IP 地址（如果有的话）。如果不存在，将使用第一个可适用的接口。
-d
删除由 inet_addr 指定的项。
-s
在 ARP 缓存中添加项，将 IP 地址 inet_addr 和物理地址 ether_addr 关联。物理地址由以连字符分隔的 6 个十六进制字节给定。使用带点的十进制标记指定 IP 地址。项是永久性的，即在超时到期后项自动从缓存删除。
ether_addr
指定物理地址。

Finger

在运行 Finger 服务的指定系统上显示有关用户的信息。根据远程系统输出不同的变量。该命令只有在安装了 TCP/IP 协议之后才可用。
finger [-l] [user]@computer[...]
参数
-l
以长列表格式显示信息。
user
指定要获得相关信息的用户。省略用户参数以显示指定计算机上所有用户的信息：
@computer

Ftp

将文件传送到正在运行 FTP 服务的远程计算机或从正在运行 FTP 服务的远程计算机传送文件（有时称作 daemon）。Ftp 可以交互使用。单击“相关主题”列表中的“ftp 命令”以获得可用的“ftp”子命令描述。该命令只有在安装了 TCP/IP 协议之后才可用。Ftp 是一种服务，一旦启动，将创建在其中可以使用 ftp 命令的子环境，通过键入 quit 子命令可以从子环境返回到 Windows 2000 命令提示符。
　　　　 当 ftp 子环境运行时，它由 ftp 命令提示符代表。
ftp [-v] [-n] [-i] [-d] [-g] [-s:filename] [-a] [-w:windowsize] [computer]
参数
-v
禁止显示远程服务器响应。
-n
禁止自动登录到初始连接。
-i
多个文件传送时关闭交互提示。
-d
启用调试、显示在客户端和服务器之间传递的所有 ftp 命令。
-g
禁用文件名组，它允许在本地文件和路径名中使用通配符字符（* 和 ?）。（请参阅联机“命令参考”中的 glob 命令。）
-s: filename
指定包含 ftp 命令的文本文件；当 ftp 启动后，这些命令将自动运行。该参数中不允许有空格。使用该开关而不是重定向 (> )。
-a
在捆绑数据连接时使用任何本地接口。
-w:windowsize
替代默认大小为 4096 的传送缓冲区。
computer
指定要连接到远程计算机的计算机名或 IP 地址。如果指定，计算机必须是行的最后一个参数。

Nbtstat

该诊断命令使用 NBT（TCP/IP 上的 NetBIOS）显示协议统计和当前 TCP/IP 连接。该命令只有在安装了 TCP/IP 协议之后才可用。
nbtstat [-a remotename] [-A IP address] [-c] [-n] [-R] [-r] [-S] [-s] [interval]
参数
-a remotename
使用远程计算机的名称列出其名称表。
-A IP address
使用远程计算机的 IP 地址并列出名称表。
-c
给定每个名称的 IP 地址并列出 NetBIOS 名称缓存的内容。
-n
列出本地 NetBIOS 名称。“已注册”表明该名称已被广播 (Bnode) 或者 WINS（其他节点类型）注册。
-R
清除 NetBIOS 名称缓存中的所有名称后，重新装入 Lmhosts 文件。
-r
列出 Windows 网络名称解析的名称解析统计。在配置使用 WINS 的 Windows 2000 计算机上，此选项返回要通过广播或 WINS 来解析和注册的名称数。
-S
显示客户端和服务器会话，只通过 IP 地址列出远程计算机。
-s
显示客户端和服务器会话。尝试将远程计算机 IP 地址转换成使用主机文件的名称。
interval
重新显示选中的统计，在每个显示之间暂停 interval 秒。按 CTRL+C 停止重新显示统计信息。如果省略该参数，nbtstat 打印一次当前的配置信息。

Netstat

显示协议统计和当前的 TCP/IP 网络连接。该命令只有在安装了 TCP/IP 协议后才可以使用。
netstat [-a] [-e] [-n] [-s] [-p protocol] [-r] [interval]
参数
-a
显示所有连接和侦听端口。服务器连接通常不显示。
-e
显示以太网统计。该参数可以与 -s 选项结合使用。
-n
以数字格式显示地址和端口号（而不是尝试查找名称）。
-s
显示每个协议的统计。默认情况下，显示 TCP、UDP、ICMP 和 IP 的统计。-p 选项可以用来指定默认的子集。
-p protocol
显示由 protocol 指定的协议的连接；protocol 可以是 tcp 或 udp。如果与 -s 选项一同使用显示每个协议的统计，protocol 可以是 tcp、udp、icmp 或 ip。
-r
显示路由表的内容。
interval
重新显示所选的统计，在每次显示之间暂停 interval 秒。按 CTRL+B 停止重新显示统计。如果省略该参数，netstat 将打印一次当前的配置信息。

Ping

验证与远程计算机的连接。该命令只有在安装了 TCP/IP 协议后才可以使用。
ping [-t] [-a] [-n count] [-l length] [-f] [-i ttl] [-v tos] [-r count] [-s count] [[-j computer-list] | [-k computer-list]] [-w timeout] destination-list
参数
-t
Ping 指定的计算机直到中断。
-a
将地址解析为计算机名。
-n count
发送 count 指定的 ECHO 数据包数。默认值为 4。
-l length
发送包含由 length 指定的数据量的 ECHO 数据包。默认为 32 字节；最大值是 65,527。
-f
在数据包中发送“不要分段”标志。数据包就不会被路由上的网关分段。
-i ttl
将“生存时间”字段设置为 ttl 指定的值。
-v tos
将“服务类型”字段设置为 tos 指定的值。
-r count
在“记录路由”字段中记录传出和返回数据包的路由。count 可以指定最少 1 台，最多 台计算机。
指定要 ping 的远程计算机。

Rcp

在 Windows 2000 计算机和运行远程外壳端口监控程序 rshd 的系统之间复制文件。rcp 命令是一个连接命令，从 Windows 2000 计算机发出该命令时，也可以用于其他传输在两台运行 rshd 的计算机之间复制文件。rshd 端口监控程序可以在 UNIX 计算机上使用，而在 Windows 2000 上不能使用，所以 Windows 2000 计算机仅可以作为发出命令的系统参与。远程计算机必须也通过运行 rshd 提供 rcp 实用程序。
rcp [-a | -b] [-h] [-r] source1 source2 ... sourceN destination
参数
-a
指定 ASCII 传输模式。此模式在传出文件上将回车/换行符转换为回车符，在传入文件中将换行符转换为回车/换行符。该模式为默认的传输模式。
-b
指定二进制图像传输模式。没有执行回车/换行符转换。
-h
传输 Windows 2000 计算机上标记为隐藏属性的源文件。如果没有该选项，在 rcp 命令行上指定隐藏文件的效果与文件不存在一样。
-r
将源的所有子目录内容递归复制到目标。source 和 destination 都必须是目录，虽然即使源不是目录，使用 -r 也能够工作。但将没有递归。
source 和 destination
格式必须为 [computer[.user]:]filename。如果忽略了 [computer[.user]:] 部分，计算机将假定为本地计算机。如果省略了 [.user] 部分，将使用当前登录的 Windows 2000 用户名。如果使用了完全合格的计算机名，其中包含句点 (.) 分隔符，则必须包含 [.user]。否则，计算机名的最后部分将解释为用户名。如果指定了多个源文件，则 destination 必须是目录。
如果文件名不是以 UNIX 的正斜杠 (/) 或 Windows 2000 系统的反斜杠 (\) 打头，则假定相对于当前的工作目录。在 Windows 2000 中，这是发出命令的目录。在远程系统中，这是远程用户的登录目录。句点 (.) 表示当前的目录。在远程路径中使用转义字符（\、" 或 '），以便在远程计算机中使用通配符。

Rexec

在运行 REXEC 服务的远程计算机上运行命令。rexec 命令在执行指定命令前，验证远程计算机上的用户名，只有安装了 TCP/IP 协议后才可以使用该命令。
rexec computer [-l username] [-n] command
参数
computer
指定要运行 command 的远程计算机。
-l username
指定远程计算机上的用户名。
-r
将 rexec 的输入重定向到 NULL。
command
指定要运行的命令。

Route

控制网络路由表。该命令只有在安装了 TCP/IP 协议后才可以使用。
route [-f] [-p] [command [destination] [mask subnetmask] [gateway] [metric costmetric]]
参数
-f
清除所有网关入口的路由表。如果该参数与某个命令组合使用，路由表将在运行命令前清除。
-p
该参数与 add 命令一起使用时，将使路由在系统引导程序之间持久存在。默认情况下，系统重新启动时不保留路由。与 print 命令一起使用时，显示已注册的持久路由列表。忽略其他所有总是影响相应持久路由的命令。
command
指定下列的一个命令。
命令 目的
print 打印路由
add 添加路由
delete 删除路由
change 更改现存路由
destination
指定发送 command 的计算机。
mask subnetmask
指定与该路由条目关联的子网掩码。如果没有指定，将使用 255.255.255.255。
gateway
指定网关。
名为 Networks 的网络数据库文件和名为 Hosts 的计算机名数据库文件中均引用全部 destination 或 gateway 使用的符号名称。如果命令是 print 或 delete，目标和网关还可以使用通配符，也可以省略网关参数。
metric costmetric
指派整数跃点数（从 1 到 9999）在计算最快速、最可靠和（或）最便宜的路由时使用。
Rsh
在运行 RSH 服务的远程计算机上运行命令。该命令只有在安装了 TCP/IP 协议后才可以使用。
rsh computer [-l username] [-n] command
参数
computer
指定运行 command 的远程计算机。
-l username
指定远程计算机上使用的用户名。如果省略，则使用登录的用户名。
-n
将 rsh 的输入重定向到 NULL。
command
指定要运行的命令。

Tftp

将文件传输到正在运行 TFTP 服务的远程计算机或从正在运行 TFTP 服务的远程计算机传输文件。该命令只有在安装了 TCP/IP 协议后才可以使用。
tftp [-i] computer [get | put] source [destination]
参数
-i
指定二进制图像传送模式（也称为“八位字节”）。在二进制图像模式中，文件一个字节接一个字节地逐字移动。在传送二进制文件时使用该模式。
如果省略了 -i，文件将以 ASCII 模式传送。这是默认的传送模式。此模式将 EOL 字符转换为 UNIX 的回车符和个人计算机的回车符/换行符。在传送文本文件时应使用此模式。如果文件传送成功，将显示数据传输率。
computer
指定本地或远程计算机。
put
将本地计算机上的文件 destination 传送到远程计算机上的文件 source。
get
将远程计算机上的文件 destination 传送到本地计算机上的文件 source。
如果将本地计算机上的文件 file-two 传送到远程计算机上的文件 file-one，请指定 put。如果将远程计算机上的文件 file-two 传送到远程计算机上的文件 file-one，请指定 get。
因为 tftp 协议不支持用户身份验证，所以用户必须登录，并且文件在远程计算机上必须可以写入。
source
指定要传送的文件。如果本地文件指定为 -，则远程文件在 stdout 上打印出来（如果获取），或从 stdin（如果放置）读取。
destination
指定将文件传送到的位置。如果省略了 destination，将假定与 source 同名。

Tracert

该诊断实用程序将包含不同生存时间 (TTL) 值的 Internet 控制消息协议 (ICMP) 回显数据包发送到目标，以决定到达目标采用的路由。要在转发数据包上的 TTL 之前至少递减 1，必需路径上的每个路由器，所以 TTL 是有效的跃点计数。数据包上的 TTL 到达 0 时，路由器应该将“ICMP 已超时”的消息发送回源系统。Tracert 先发送 TTL 为 1 的回显数据包,并在随后的每次发送过程将 TTL 递增 1，直到目标响应或 TTL 达到最大值，从而确定路由。路由通过检查中级路由器发送回的“ICMP 已超时”的消息来确定路由。不过，有些路由器悄悄地下传包含过期 TTL 值的数据包，而 tracert 看不到。
tracert [-d] [-h maximum_hops] [-j computer-list] [-w timeout] target_name
参数
/d
指定不将地址解析为计算机名。
-h maximum_hops
指定搜索目标的最大跃点数。
-j computer-list
指定沿 computer-list 的稀疏源路由。
-w timeout
每次应答等待 timeout 指定的微秒数。
target_name
目标计算机的名称。

此外，还有IPCONFIG，DNR等命令，这里就不再一一介绍了。

XP有一个很无敌的命令，用来替换文件的replace，连正在使用的文件也能替换。非常无敌。 比如：在C：下建一个目录，c：aaa ，然后复制一首mp3到c:aaa并命名为c:aaaa.mp3 ，然后再复制另一首歌到C:a.mp3 ，然后用media player 播放c:aaaa.mp3 ，在命令提示符下输入：replace c:a.mp3 c:aaa ，过一会，是不是播放的歌已变为另一首。

用这个命令来替换系统文件真是太爽了，并且XP的系统文件保护也对它无效。 再也不用到安全模式下去替换文件了

格式

REPLACE [drive1:][path1]filename [drive2:][path2] [/A] [/P] [/R] [/W]

REPLACE [drive1:][path1]filename [drive2:][path2] [/P] [/R] [/S] [/W]

[drive1:][path1]filename 指定源文件。

[drive2:][path2] 指定要替换文件的

目录

/A 把新文件加入目标目录。不能和/S 或 /U 命令行开关搭配使用。 /P 替换文件或加入源文件之前会先提示您进行确认。 /R 替换只读文件以及未受保护的文件。 /S 替换目标目录中所有子目录的文件。 不能与 /A 命令选项搭配使用。

/W 等您插入磁盘以后再运行。

/U 只会替换或更新比源文件日期早的文件。 不能与 /A 命令行开关搭配使用。

ps:要是病毒或者黑客也用这个命令那就危险了

方法2。重载TControl的WndProc方法
　　还是先谈谈VCL的继承策略。VCL中的继承链的顶部是TObject基类。一切的VCL组件和对象都继承自TObject。

　　打开BCB帮助查看TControl的继承关系：

　　TObject->TPersistent->TComponent->TControl

　　呵呵，原来TControl是从TPersistent类的子类TComponent类继承而来的。TPersistent抽象基类具有使用流stream来存取类的属性的能力。

　　TComponent类则是所有VCL组件的父类。

　　这就是所有的VCL组件包括您的自定义组件可以使用dfm文件存取属性的原因『当然要是TPersistent的子类，我想您很少需要直接从TObject类来派生您的自定义组件吧』。 TControl类的重要性并不亚于它的父类们。在BCB的继承关系中，TControl类的是所有VCL可视化组件的父类。实际上就是控件的意思吧。所谓可视化是指您可以在运行期间看到和操纵的控件。这类控件所具有的一些基本属性和方法都在TControl类中进行定义。

　　TControl的实现在\Borland\CBuilder5\Source\Vcl\control.pas中可以找到。『可能会有朋友问你怎么知道在那里？使用BCB提供的Search -> Find in files很容易找到。或者使用第三方插件的grep功能。』

　　好了，进入VCL的源码吧。说到这里免不了要抱怨一下Borland。哎，为什么要用pascal实现这一切.....:-(

　　TControl继承但并没有重写TObject的Dispatch()方法。反而提供了一个新的方法就是xycleo提到的WndProc()。一起来看看Borland的工程师们是怎么写的吧。

procedure TControl.WndProc(var Message: TMessage);
var
Form: TCustomForm;
begin
//由拥有control的窗体来处理设计期间的消息
if (csDesigning in ComponentState) then
begin
Form := GetParentForm(Self);
if (Form <> nil) and (Form.Designer <> nil) and
Form.Designer.IsDesignMsg(Self, Message) then Exit;
end
//如果需要，键盘消息交由拥有control的窗体来处理
else if (Message.Msg >= WM_KEYFIRST) and (Message.Msg <= WM_KEYLAST) then
begin
Form := GetParentForm(Self);
if (Form <> nil) and Form.WantChildKey(Self, Message) then Exit;
end
//处理鼠标消息
else if (Message.Msg >= WM_MOUSEFIRST) and (Message.Msg <= WM_MOUSELAST) then
begin
if not (csDoubleClicks in ControlStyle) then
case Message.Msg of
WM_LBUTTONDBLCLK, WM_RBUTTONDBLCLK, WM_MBUTTONDBLCLK:
Dec(Message.Msg, WM_LBUTTONDBLCLK - WM_LBUTTONDOWN);
end;
case Message.Msg of
WM_MOUSEMOVE: Application.HintMouseMessage(Self, Message);
WM_LBUTTONDOWN, WM_LBUTTONDBLCLK:
begin
if FDragMode = dmAutomatic then
begin
BeginAutoDrag;
Exit;
end;
Include(FControlState, csLButtonDown);
end;
WM_LBUTTONUP:
Exclude(FControlState, csLButtonDown);
end;
end
// 下面一行有点特别。如果您仔细的话会看到这个消息是CM_VISIBLECHANGED.
// 而不是我们熟悉的WM_开头的标准Windows消息.
// 尽管Borland没有在它的帮助中提到有这一类的CM消息存在。但很显然这是BCB的
// 自定义消息。呵呵，如果您对此有兴趣可以在VCL源码中查找相关的内容。一定会有不小的收获。
else if Message.Msg = CM_VISIBLECHANGED then
with Message do
SendDockNotification(Msg, WParam, LParam);
// 最后调用dispatch方法。
Dispatch(Message);
end;

　　看完这段代码，你会发现TControl类实际上只处理了鼠标消息，没有处理的消息最后都转入Dispatch()来处理。

　但这里需要强调指出的是TControl自己并没有获得焦点Focus的能力。TControl的子类TWinControl才具有这样的能力。我凭什么这样讲？呵呵，还是打开BCB的帮助。很多朋友抱怨BCB的帮助实在不如VC的MSDN。毋庸讳言，的确差远了。而且这个帮助还经常有问题。但有总比没有好啊。

　　言归正传，在帮助的The TWinControl Branch 分支下，您可以看到关于TWinControl类的简介。指出TWinControl类是所有窗体类控件的基类。所谓窗体类控件指的是这样一类控件：

　　1. 可以在程序运行时取得焦点的控件。

　　2. 其他的控件可以显示数据，但只有窗体类控件才能和用户发生键盘交互。

　　3. 窗体类控件能够包含其他控件(容器)。

　　4. 包含其他控件的控件又称做父控件。只有窗体类控件才能够作为其他控件的父控件。

　　5. 窗体类控件拥有句柄。

　　除了能够接受焦点之外，TWinControl的一切都跟TControl没什么分别。这一点意味着TwinControl可以对许多的标准事件作出响应，Windows也必须为它分配一个句柄。并且与这个主题相关的最重要的是，这里提到是由BCB负责来对控件进行重画以及消息处理。这就是说，TwinControl封装了这一切。

　　似乎扯的太远了。但我要提出来的问题是TControl类的WndProc方法中处理了鼠标消息。但这个消息只有它的子类TwinControl才能够得到啊!？

　　这怎么可以呢... Borland是如何实现这一切的呢？这个问题实在很奥妙。为了看个究竟，再次深入VCL吧。

　　还是在control.pas中，TWinControl继承了TControl的WndProc方法。源码如下：

procedure TWinControl.WndProc(var Message: TMessage);
var
Form: TCustomForm;
KeyState: TKeyboardState;
WheelMsg: TCMMouseWheel;
begin
case Message.Msg of
WM_SETFOCUS:
begin
Form := GetParentForm(Self);
if (Form <> nil) and not Form.SetFocusedControl(Self) then Exit;
end;
WM_KILLFOCUS:
if csFocusing in ControlState then Exit;
WM_NCHITTEST:
begin
inherited WndProc(Message);
if (Message.Result = HTTRANSPARENT) and (ControlAtPos(ScreenToClient(
SmallPointToPoint(TWMNCHitTest(Message).Pos)), False) <> nil) then
Message.Result := HTCLIENT;
Exit;
end;
WM_MOUSEFIRST..WM_MOUSELAST:
//下面这一句话指出，鼠标消息实际上转入IsControlMouseMsg方法来处理了。
if IsControlMouseMsg(TWMMouse(Message)) then
begin
if Message.Result = 0 then
DefWindowProc(Handle, Message.Msg, Message.wParam, Message.lParam);
Exit;
end;
WM_KEYFIRST..WM_KEYLAST:
if Dragging then Exit;
WM_CANCELMODE:
if (GetCapture = Handle) and (CaptureControl <> nil) and
(CaptureControl.Parent = Self) then
CaptureControl.Perform(WM_CANCELMODE, 0, 0);
else
with Mouse do
if WheelPresent and (RegWheelMessage <> 0) and
(Message.Msg = RegWheelMessage) then
begin
GetKeyboardState(KeyState);
with WheelMsg do
begin
Msg := Message.Msg;
ShiftState := KeyboardStateToShiftState(KeyState);
WheelDelta := Message.WParam;
Pos := TSmallPoint(Message.LParam);
end;
MouseWheelHandler(TMessage(WheelMsg));
Exit;
end;
end;
inherited WndProc(Message);
end;
鼠标消息是由IsControlMouseMsg方法来处理的。只有再跟到IsControlMouseMsg去看看啦。源码如下：

function TWinControl.IsControlMouseMsg(var Message: TWMMouse): Boolean;
var
//TControl出现啦
Control: TControl;
P: TPoint;
begin
if GetCapture = Handle then
begin
Control := nil;
if (CaptureControl <> nil) and (CaptureControl.Parent = Self) then
Control := CaptureControl;
end else
Control := ControlAtPos(SmallPointToPoint(Message.Pos), False);
Result := False;
if Control <> nil then
begin
P.X := Message.XPos - Control.Left;
P.Y := Message.YPos - Control.Top;
file://TControl的Perform方法将消息交由WndProc处理。
Message.Result := Control.Perform(Message.Msg, Message.Keys, Longint(PointToSmallPoint(P)));
Result := True;
end;
end;



　　原来如此，TWinControl最后还是将鼠标消息交给TControl的WndProc来处理了。这里出现的Perform方法在BCB的帮助里可以查到是TControl类中开始出现的方法。它的作用就是将指定的消息传递给TControl的WndProc过程。

　　结论就是TControl类的WndProc方法的消息是由TwinControl类在其重载的WndProc方法中调用IsControlMouseMsg方法后使用Peform方法传递得到的。

　　由于这个原因，BCB和Delphi中的TControl类及其所有的派生类都有一个先天的而且是必须的限制。那就是所有的TControl类及其派生类的Owner必须是TwinControl类或者TWinControl的派生类。Owner属性最早可以在TComponent中找到，一个组件或者控件是由它的Owner拥有并负责释放其内存的。这就是说，当Owner从内存中释放的时候，它所拥有的所有控件占用的内存也都被释放了。Owner最好的例子就是Form。Owner同时也负责消息的分派，当Owner接收到消息的时候，它负责将应该传递给其所拥有的控件的消息传递给它们。这样这些控件就能够取得处理消息的能力。TImage就是个例子：你可以发现Borland并没有让TImage重载TControl的WndProc方法，所以TImage也只有处理鼠标消息的能力，而这种能力正是来自TControl的。

　　唧唧崴崴的说了一大堆。终于可以说处理消息的第二种方法就是重载TControl的WndProc方法了。例程如下：

void __fastcall TForm1::WndProc(TMessage &Message)
{
switch (Message.Msg)
{
case WM_CLOSE:
OnCLOSE(Message); // 处理WM_CLOSE消息的方法
break;
}
TForm::WndProc(Message);
}

　　乍看起来,这和上次讲的重载Dispatch方法好象差不多。但实际上还是有差别的。差别就在先后次序上，从前面TControl的WndProc可以看到，消息是先交给WndProc来处理，最后才调用Dispatch方法的啦。

　　这样，重载WndProc方法可以比重载Dispatch方法更早一点点得到消息并处理消息。

时至今日，学习Windows编程的兄弟们都知道消息机制的重要性。所以理解消息机制也成了不可或缺的功课。

　　大家都知道，Borland的C++ Builder以及Delphi的核心是VCL。作为Win32平台上的开发工具，封装Windows的消息机制当然也是必不可少的。

　　那么，在C++ Builder中处理消息的方法有哪些呢？它们之间的区别又在哪里？如果您很清楚这些，呵呵，对不起啦，请关掉这个窗口。 如果不清楚那就和我一起深入VCL的源码看个究竟吧。『注:BCB只有Professional和Enterprise版本才带有VCL源码。当然，大伙的版本都有源码的。我没猜错吧 :-)』

　　方法1。使用消息映射(Message Map)重载TObject的Dispatch虚成员函数

　　这个方法大家用的很多。形式如下

BEGIN_MESSAGE_MAP

VCL_MESSAGE_HANDLER( … …)

END_MESSAGE_MAP( …)


　　但这几句话实在太突兀，C++标准中没有这样的定义。不用讲，这显然又是宏定义。它们到底怎么来的呢？CKER第一次见到它们的时候，百思不得其解。嘿嘿，不深入VCL，怎么可能理解？

在\Borland\CBuilder5\Include\Vcl找到sysmac.h，其中有如下的预编译宏定义：

#define BEGIN_MESSAGE_MAP virtual void __fastcall Dispatch(void *Message) \
{ \
switch (((PMessage)Message)->Msg) \
{

#define VCL_MESSAGE_HANDLER(msg,type,meth) \
case msg: \
meth(*((type *)Message)); \
break;

// NOTE: ATL defines a MESSAGE_HANDLER macro which conflicts with VCL's macro. The
// VCL macro has been renamed to VCL_MESSAGE_HANDLER. If you are not using ATL,
// MESSAGE_HANDLER is defined as in previous versions of BCB.
file://
#if !defined(USING_ATL) && !defined(USING_ATLVCL) && !defined(INC_ATL_HEADERS)
#define MESSAGE_HANDLER VCL_MESSAGE_HANDLER
#endif // ATL_COMPAT

#define END_MESSAGE_MAP(base)
default: \
base::Dispatch(Message); \
break; \
} \
}


　　这样对如下的例子：

BEGIN_MESSAGE_MAP

VCL_MESSAGE_HANDLER(WM_PAINT,TMessage,OnPaint)

END_MESSAGE_MAP(TForm1)


　　在预编译时，就被展开成如下的代码

virtual void __fastcall Dispatch(void *Message)
{
switch (((PMessage)Message)->Msg)
{
case WM_PAINT:
OnPaint(*((TMessage *)Message)); //消息响应句柄，也就是响应消息的成员函数，在Form1中定义
break;

default:
Form1::Dispatch(Message);
break;
}
}


　　这样就很顺眼了，对吧。对这种方法有两点要解释一下：

　　1。virtual void __fastcall Dispatch(void *Message) 这个虚方法的定义最早可以在TObject的定义中找到。打开BCB的帮助，查找TForm的Method(方法)，你会发现这里很清楚的写着Dispatch方法继承自TObject。如果您关心VCL的继承机制的话，您会发现TObject是所有VCL对象的基类。TObject的抽象凝聚了Borland的工程师们的心血。如果有兴趣。您应该好好查看一下TObject的定义。

　　很显然，所有Tobject的子类都可以重载基类的Dispatch方法，来实现自己的消息调用。如果Dispatch方法找不到此消息的定义，会将此消息交由TObject::DefaultHandler方法来处理。抽象基类TObject的DefaultHandler方法实际上是空的。同样要由继承子类重载实现它们自己的消息处理过程。

　　2。很多时候，我见到的第二行是这样写的：

　　MESSAGE_HANDLER(WM_PAINT,TMessage,OnPaint)

　　在这里，您可以很清楚的看到几行注解，意思是ATL中同样包含了一个MESSAGE_HANDLER的宏定义，这与VCL发生了冲突。为了解决这个问题，Borland改用VCL_MESSAGE_HANDLER这样的写法。

　　当您没有使用ATL的时候，MESSAGE_HANDLER将转换成VCL_MESSAGE_HANDLER。但如果您使用了ATL的话，就会有问题。所以我建议您始终使用VCL_MESSAGE_HANDLER的写法，以免出现问题。

 还在Dos时代，人们就在寻求一种多任务的实现。于是出现了TSR类型的后台驻留程序，比较有代表性的有Side Kick、Vsafe等优秀的TSR程序，这类程序的出现和应用确实给用户使用计算机带来了极大的方便，比如Side Kick，我们编程可以在不用进编辑程序的状态下，一边编辑源程序，一边编译运行，非常方便。但是，Dos单任务操作系统的致命缺陷注定了在Dos下不可能开发出真正的多任务程序。进入Windows3.1时代，这种情况依然没有根本的改变，一次应用只能做一件事。比如数据库查询，除非应用编得很好，在查询期间整个系统将不响应用户的输入。

　　进入了Windows NT和Windows 9x时代，情况就有了彻底的改观，操作系统从真正意义上实现了多任务（严格地说，Win9x还算不上）。一个应用程序，在需要的时候可以有许多个执行线程，每个线程就是一个小的执行程序，操作系统自动使各个线程共享CPU资源，确保任一线程都不能使系统死锁。这样，在编程的时候，可以把费时间的任务移到后台，在前台用另一个线程接受用户的输入。对那些对实时性要求比较高的编程任务，如网络客户服务、串行通信等应用时，多线程的实现无疑大大地增强了程序的可用性和稳固性。

　　在Windows NT和Windows 9x中，多线程的编程实现需要调用一系列的API函数，如CreateThread、ResumeThread等，比较麻烦而且容易出错。我们使用Inprise公司的新一代RAD开发工具C＋＋Builder，可以方便地实现多线程的编程。与老牌RAD工具Visual Basic和Delphi比，C＋＋Builer不仅功能非常强大，而且它的编程语言是C＋＋，对于系统开发语言是C的Windows系列操作系统，它具有其它编程语言无可比拟的优势。利用C＋＋Builder提供的TThread对象，多线程的编程变得非常简便易用。那么，如何实现呢？且待我慢慢道来，让你体会一下多线程的强大功能。

　　1. 创建多线程程序：

　　首先，先介绍一下实现多线程的具体步骤。在C＋＋Builder中虽然用Tthread对象说明了线程的概念，但是Tthread对象本身并不完整，需要在TThread下新建其子类，并重载Execute方法来使用线程对象。在C＋＋Builder下可以很方便地实现这一点。

　　在C＋＋Builder IDE环境下选择菜单File|New，在New栏中选中Thread Object，按OK，接下来弹出输入框，输入TThread对象子类的名字MyThread，这样C＋＋Builder自动为你创建了一个名为TMyThread的TThread子类。同时编辑器中多了一个名为Unit2.cpp的单元,这就是我们创建的TMyThread子类的原码，如下：

　　＃include
　　＃pragma hdrstop
　　
　　＃include “Unit2.h”
　　＃pragma package(smart_init)
　　//－－－－－－－－－－－－－－－－－－－－－
　　// Important: Methods and properties of objects in VCL can only be
　　// used in a method called using Synchronize, for example:
　　//
　　// Synchronize(UpdateCaption);
　　//
　　// where UpdateCaption could look like:
　　//
　　// void __fastcall MyThread::UpdateCaption()
　　// {
　　// Form1－>Caption = “Updated in a thread”;
　　// }
　　//－－－－－－－－－－－－－－－－－－－－
　　__fastcall MyThread::MyThread(bool CreateSuspended)
　　 : TThread(CreateSuspended)
　　{
　　}
　　//－－－－－－－－－－－－－－－－－－－－
　　void __fastcall MyThread::Execute()
　　{
　　 //－－－－ Place thread code here －－－－
　　}
　　//－－－－－－－－－－－－－－－－－－－－－

　　其中的Execute（）函数就是我们要在线程中实现的任务的代码所在处。在原代码中包含Unit2.cpp，这个由我们创建的TMyThread对象就可以使用了。使用时，动态创建一个TMyThread 对象，在构造函数中使用Resume（）方法，那么程序中就增加了一个新的我们自己定义的线程TMyThread，具体执行的代码就是Execute（）方法重载的代码。要加载更多的线程，没关系，只要继续创建需要数量的TMyThread 对象就成。

　　以上我们初步地实现了在程序中创建一个自定义的线程，并使程序实现了多线程应用。但是，多线程应用的实现，并不是一件简单的工作，还需要考虑很多使多个线程能在系统中共存、互不影响的因素。比如，程序中公共变量的访问、资源的分配，如果处理不当，不仅线程会死锁陷入混乱，甚至可能会造成系统崩溃。总的来讲，在多线程编程中要注意共享对象和数据的处理，不能忽视。因此，下面我们要讲的就是多线程中常见问题:

　2. 多线程中VCL对象的使用

　　我们都知道，C＋＋Builder编程是建立在VCL类库的基础上的。在程序中经常需要访问VCL对象的属性和方法。不幸的是，VCL类库并不保证其中对象的属性和方法是线程访问安全的（Thread_safe），访问VCL对象的属性或调用其方法可能会访问到不被别的线程所保护的内存区域而产生错误。因此，TThread对象提供了一个Synchronize方法，当需要在线程中访问VCL对象属性或调用方法时，通过Synchronize方法来访问属性或调用方法就能避免冲突，使各个线程之间协调而不会产生意外的错误。如下所示：

　　void __fastcall TMyThread::PushTheButton(void)
　　
　　{
　　 Button1－>Click();
　　}
　　
　　void __fastcall TMyThread::Execute()
　　{
　　 ...
　　 Synchronize((TThreadMethod)PushTheButton);
　　 ...
　　}

　　对Button1－〉Click（）方法的调用就是通过Synchronize（）方法来实现的，它可以自动避免发生多线程访问冲突。在C＋＋Builder中，虽然有一些VCL对象也是线程访问安全的（如TFont、TPen、TBrush等），可以不用Sychronize（）方法对它们的属性方法进行访问调用以提高程序性能，但是，对于更多的无法确定的VCL对象，还是强烈建议使用Synchronize（）方法确保程序的可靠性。

　　3. 多线程中公共数据的使用

　　程序设计中难免要在多个线程中共享数据或者对象。为了避免在多线程中因为同时访问了公共数据块而造成灾难性的后果，我们需要对公共数据块进行保护，直到一个线程对它的访问结束为止。这可以通过临界区域（Critical Section）的使用来实现，所幸的是在C＋＋Builder中，给我们提供了一个TCriticalSection对象来进行临界区域的划定。该对象有两个方法，Acquire（）和Release（）。它设定的临界区域可以保证一次只有一个线程对该区域进行访问。如下例所示：

　　class MyThread : public TThread
　　{
　　 ...
　　private:
　　TCriticalSection pLockX；
　　int x;
　　float y;
　　...
　　};
　　void __fastcall MyThread::Execute()
　　{
　　...
　　pLockX－>Acquire();//Here pLockX is a Global CriticalSection variable.
　　x＋＋;
　　y=sin(x);
　　pLockX－>Release();
　　...
　　}

　　这样，对公共变量x，y的访问就通过全局TCriticalSection 对象保护起来，避免了多个线程同时访问的冲突。

　　4. 多线程间的同步

　　当程序中多个线程同时运行，难免要遇到使用同一系统资源，或者一个线程的运行要依赖另一个线程的完成等等，这样需要在线程间进行同步的问题。由于线程同时运行，无法从程序本身来决定运行的先后快慢，使得线程的同步看起来很难实现。所幸的是Windows系统是多任务操作系统，系统内核为我们提供了事件（Event）、Mutex、信号灯(semaphore)和计时器4种对象来控制线程间的同步。在C＋＋Builder中，为我们提供了用于创建Event的TEvent 对象供我们使用。

　　当程序中一个线程的运行要等待一项特定的操作的完成而不是等待一个特定的线程完成时，我们就可以很方便地用TEvent对象来实现这个目标。首先创建一个全局的TEvent对象作为所有线程可监测的标志。当一个线程完成某项特定的操作时，调用TEvent对象的SetEvent（）方法，这样将设置这个标志，其他的线程可以通过监测这个标志获知操作的完成。相反，要取消这个标志，可以调用ResetEvent（）方法。在需要等待操作完成的线程中使用WaitFor（）方法，将一直等待这个标志被设置为止。注意WaitFor（）方法的参数是等待标志设置的时间，一般用INFINITE表示无限等待事件的发生，如果其它线程运行有误，很容易使这个线程死住（等待一个永不发生的事件）。

　　其实直接用Windows API函数也可以很方便地实现事件（Event）、信号灯（semaphore）控制技术。尤其是C＋＋Builder，在调用Windows API方面有着其它语言无可比拟的优势。所用的函数主要有：CreateSemaphore（）、CreateEvent（）、WaitForSingleObject（）、ReleaseSemaphore（）、SetEvent（）等等，这里就不赘述了。

　　本文结合Inprise（Borland）公司开发的强大的RAD工具C＋＋Builder的编程，对Windows下的多线程编程作了比较全面的介绍。其实多线程的实现并不神秘，看了本文，你也可以编出自己的多线程程序，真正体会多任务操作系统的威力。

　　附：本文是本人在使用C＋＋Builder一年来的一些实践体会。在完成自己的项目的同时，发现对多线程的编程一般的书籍都介绍得比较少，而实际应用中，多线程编程又是如此的重要，因此，本文通过对多线程编程比较全面的介绍，愿能达到抛砖引玉之效。

级别: 中级

        
int has_initialized = 0;

void *managed_memory_start;

void *last_valid_address;

      

        
/* Include the sbrk function */

#include <unistd.h>

void malloc_init()

{

	/* grab the last valid address from the OS */

	last_valid_address = sbrk(0);


	/* we don't have any memory to manage yet, so
	 *just set the beginning to be last_valid_address
	 */

	managed_memory_start = last_valid_address;

	/* Okay, we're initialized and ready to go */

 	has_initialized = 1;

}

      

        
struct mem_control_block {

	int is_available;

	int size;

};

      

        
void free(void *firstbyte) {

	struct mem_control_block *mcb;

	/* Backup from the given pointer to find the
	 * mem_control_block
	 */

	mcb = firstbyte - sizeof(struct mem_control_block);

	/* Mark the block as being available */

	mcb->is_available = 1;

	/* That's It!  We're done. */

	return;
}

      

        

1. If our allocator has not been initialized, initialize it.

2. Add sizeof(struct mem_control_block) to the size requested.

3. start at managed_memory_start.

4. Are we at last_valid address?

5. If we are:

   A. We didn't find any existing space that was large enough
      -- ask the operating system for more and return that.

6. Otherwise:

   A. Is the current space available (check is_available from
      the mem_control_block)?

   B. If it is:

      i)   Is it large enough (check "size" from the
           mem_control_block)?

      ii)  If so:

           a. Mark it as unavailable

           b. Move past mem_control_block and return the
              pointer

      iii) Otherwise:

           a. Move forward "size" bytes

           b. Go back go step 4

   C. Otherwise:

      i)   Move forward "size" bytes

      ii)  Go back to step 4

      

        
void *malloc(long numbytes) {

	/* Holds where we are looking in memory */

	void *current_location;

	/* This is the same as current_location, but cast to a
	 * memory_control_block
	 */

	struct mem_control_block *current_location_mcb;

	/* This is the memory location we will return.  It will
	 * be set to 0 until we find something suitable
	 */

	void *memory_location;

	/* Initialize if we haven't already done so */

	if(! has_initialized) 	{

		malloc_init();

	}

	/* The memory we search for has to include the memory
	 * control block, but the users of malloc don't need
	 * to know this, so we'll just add it in for them.
	 */

	numbytes = numbytes + sizeof(struct mem_control_block);

	/* Set memory_location to 0 until we find a suitable
	 * location
	 */

	memory_location = 0;

	/* Begin searching at the start of managed memory */

	current_location = managed_memory_start;

	/* Keep going until we have searched all allocated space */

	while(current_location != last_valid_address)

	{

		/* current_location and current_location_mcb point
		 * to the same address.  However, current_location_mcb
		 * is of the correct type, so we can use it as a struct.
		 * current_location is a void pointer so we can use it
		 * to calculate addresses.
		 */

		current_location_mcb =

			(struct mem_control_block *)current_location;

		if(current_location_mcb->is_available)

		{

			if(current_location_mcb->size >= numbytes)

			{

				/* Woohoo!  We've found an open,
				 * appropriately-size location.
				 */

				/* It is no longer available */

				current_location_mcb->is_available = 0;

				/* We own it */

				memory_location = current_location;

				/* Leave the loop */

				break;

			}

		}

		/* If we made it here, it's because the Current memory
		 * block not suitable; move to the next one
		 */

		current_location = current_location +

			current_location_mcb->size;

	}

	/* If we still don't have a valid location, we'll
	 * have to ask the operating system for more memory
	 */

	if(! memory_location)

	{

		/* Move the program break numbytes further */

		sbrk(numbytes);

		/* The new memory will be where the last valid
		 * address left off
		 */

		memory_location = last_valid_address;

		/* We'll move the last valid address forward
		 * numbytes
		 */

		last_valid_address = last_valid_address + numbytes;

		/* We need to initialize the mem_control_block */

		current_location_mcb = memory_location;

		current_location_mcb->is_available = 0;

		current_location_mcb->size = numbytes;

	}

	/* Now, no matter what (well, except for error conditions),
	 * memory_location has the address of the memory, including
	 * the mem_control_block
	 */

	/* Move the pointer past the mem_control_block */

	memory_location = memory_location + sizeof(struct mem_control_block);

	/* Return the pointer */

	return memory_location;

 }

      

        
gcc -shared -fpic malloc.c -o malloc.so

      

        
LD_PRELOAD=/path/to/malloc.so

export LD_PRELOAD

      

        
/* Structure Definitions*/

/* Base structure that holds a refcount */

struct refcountedstruct

{

	int refcount;

}

/* All refcounted structures must mirror struct
 * refcountedstruct for their first variables
 */

/* Refcount maintenance functions */

/* Increase reference count */

void REF(void *data)

{

	struct refcountedstruct *rstruct;

	rstruct = (struct refcountedstruct *) data;

	rstruct->refcount++;

}

/* Decrease reference count */

void UNREF(void *data)

{

	struct refcountedstruct *rstruct;

	rstruct = (struct refcountedstruct *) data;

	rstruct->refcount--;

	/* Free the structure if there are no more users */

	if(rstruct->refcount == 0)

	{

		free(rstruct);

	}

}

      

        
/* EXAMPLES OF USAGE */


/* Data type to be refcounted */

struct mydata

{

	int refcount; /* same as refcountedstruct */

	int datafield1; /* Fields specific to this struct */

	int datafield2;

	/* other declarations would go here as appropriate */

};


/* Use the functions in code */

void dosomething(struct mydata *data)

{

	REF(data);

	/* Process data */

	/* when we are through */

	UNREF(data);

}


struct mydata *globalvar1;

/* Note that in this one, we don't decrease the
 * refcount since we are maintaining the reference
 * past the end of the function call through the
 * global variable
 */

void storesomething(struct mydata *data)

{

	REF(data); /* passed as a parameter */

	globalvar1 = data;

	REF(data); /* ref because of Assignment */

	UNREF(data); /* Function finished */

}

      

        
#include <obstack.h>

#include <stdlib.h>

/* Example code listing for using obstacks */

/* Used for obstack macros (xmalloc is
   a malloc function that exits if memory
   is exhausted */

#define obstack_chunk_alloc xmalloc

#define obstack_chunk_free free

/* Pools */

/* Only permanent allocations should go in this pool */

struct obstack *global_pool;

/* This pool is for per-connection data */

struct obstack *connection_pool;

/* This pool is for per-request data */

struct obstack *request_pool;

void allocation_failed()

{

	exit(1);

}

int main()

{

	/* Initialize Pools */

	global_pool = (struct obstack *)

		xmalloc (sizeof (struct obstack));

	obstack_init(global_pool);

	connection_pool = (struct obstack *)

		xmalloc (sizeof (struct obstack));

	obstack_init(connection_pool);

	request_pool = (struct obstack *)

		xmalloc (sizeof (struct obstack));

	obstack_init(request_pool);

	/* Set the error handling function */

	obstack_alloc_failed_handler = &allocation_failed;

	/* Server main loop */

	while(1)

	{

		wait_for_connection();

		/* We are in a connection */

		while(more_requests_available())

		{

			/* Handle request */

			handle_request();

			/* Free all of the memory allocated

			 * in the request pool

			 */

			obstack_free(request_pool, NULL);

		}

		/* We're finished with the connection, time

		 * to free that pool

		 */

		obstack_free(connection_pool, NULL);

	}

}

int handle_request()

{

	/* Be sure that all object allocations are allocated
	 * from the request pool
	 */

	int bytes_i_need = 400;

	void *data1 = obstack_alloc(request_pool, bytes_i_need);

	/* Do stuff to process the request */

	/* return */

	return 0;

}