3、我是不是需要NTFS？

Windows 2000/XP在文件系统上是向下兼容的，它可以很好地支持FAT16/FAT32和NTFS，其中NTFS是Windows NT/2000/XP专用格式，它能更充分有效地利用磁盘空间、支持文件级压缩、具备更好的文件安全性。如果你只安装Windows 2000/XP，建议选择NTFS文件系统。如果多重引导系统，则系统盘（C盘）必须为FAT16或FAT32，否则不支持多重引导。当然，其他分区的文件系统可以为NTFS。

4、如何将FAT分区转换为NTFS？

Windows 2000/XP提供了分区格式转换工具“Convert.exe”。Convert.exe是Windows 2000附带的一个DOS命令行程序，通过这个工具可以直接在不破坏FAT文件系统的前提下，将FAT转换为NTFS。它的用法很简单，先在Windows 2000环境下切换到DOS命令行窗口，在提示符下键入：

D:>convert 需要转换的盘符 /FS:NTFS
如系统E盘原来为FAT16/32，现在需要转换为NTFS，可使用如下格式：
D:>convert e: /FS:NTFS
所有的转换将在系统重新启动后完成。

此外，你还可以使用专门的转换工具，如著名的硬盘无损分区工具Partition Magic，使用它完成磁盘文件格式的转换也是非常容易的。首先在界面中的磁盘分区列表中选择需要转换的分区。从界面按钮条中选择“Convert Partition”按钮，或者是从界面菜单条“Operations”项下拉菜单中选择“Convert”命令。激活该项功能界面。在界面中选择转换输出为“NTFS”，之后单击“OK”按钮返回程序主界面。单击界面右下角的“Apply”添加设置。此后系统会重新引导启动，并完成分区格式的转换操作。

5、虽然NTFS格式分区比较优越，但是在这个分区下如何找回意外丢失的文件？

你可以使用专门的软件，如Final Data for NTFS，或者是Get Data Back for NTFS。这两个软件的文件恢复效果都不错，如果在文件删除后没有任何文件操作，恢复率接近100%。所以不要等到文件删除后才安装这个软件，最好是与Windows系统一起安装，并在出现文件误删除后立刻执行恢复操作，一般可以将删除的文件恢复回来。

6、我的Windows 2000/XP安装在C盘（NTFS格式），如果在DOS状态下不能进入C盘，当Windows崩溃时怎么办？

你可以使用Windows 2000/XP的安装光盘启动来修复Windows，或者是制作Windows 2000/XP的安装启动应急盘。注意：Windows 2000的安装盘制作程序在程序的安装光盘中，而Windows XP的应急盘制作是独立提供的，需要从微软的网站下载。

7、Final Data for NTFS或Get Data Back for NTFS可以修复被意外格式化的硬盘吗？

可以。这两个软件都可以恢复格式化删除的数据（低级格式化除外）。常规格式化删除的只是数据信息，低级格式化则删除全部数据区，当硬盘技术还不像现在这样发达的时候，磁盘表面很容易磨损。硬盘使用者对经常出现的读错误，往往采用低级格式化。修复被格式化的硬盘，只能将这个硬盘拆下来，安装到其他的计算机中，之后执行文件修复操作。Final Data甚至可以修复由CIH病毒破坏的硬盘。（作者：Lily）

转自: 南京大学小百合站


1、一定要打预防针！

　　在修之前，向MM反复声明，这电脑故障是有硬件和软件之分的，如果是硬件故障，例
如显卡风扇不转了，显示器连线老化，显示器分辨率超出显示器指标，等等都会导致黑屏
啊，这个我不回家用专门的工具是修不好的！

　　这样一旦真的没修好，就立刻耸肩膀作无奈装：真的是硬件问题，还是送去保修吧。
而MM当作硬件问题去保修，JS大人即使发现是软件问题，也会毫不犹豫作为硬件问题处理
，所以决计不会有败露的麻烦

　　2、重装是万能药方！

　　不管发生什么，只要MM同意，一律重装系统！这是最简单的方法，虽然很菜。但是如
果要感动MM，这也是最好的方法，因为MM会在漫长的等待中觉得你真是很有耐心和爱心的
好男人！哈哈哈哈，太阴险了，所以给恐龙修电脑，一般还是对症下药，速战速决，不要
绿我，确实当恐龙看上你的时候，你就知道这不是RPWT，而是生命问题！

　　3、关心要无所不在！

　　如果选择重装，一定要反复问MM：真的可以吗？MM第一遍一般就说可以，这时候要问
：没有重要的照片、文档吗？MM会犹豫，但是还是会说不要好了；这时候接着问：QQ聊天
记录也会丢掉的！MM会说不要了；记着这时要作思考状，然后问：有没有重要的邮件啊，
邮件也会丢掉的。一般啊，很多MM这个时候会反悔，她们就会觉得你是超级贴心人了。


　　如果选择打开机箱，一定要作惊讶状！怎么这么多灰尘啊！！！（我只见过一个MM的
机箱里没有灰尘的，她是实在太爱干净了）这时候MM一般都会不知道怎么回答，你立刻要
作出为电脑难过的样子：这么好的电脑，灰尘太多怎么跑得快啊，散热也会受影响的，当
然容易出问题了。哈哈哈哈，MM内疚的同时就会觉得你这个人特别懂得爱惜珍惜疼惜是新
好男人。

　　技术篇：

　　1、MM电脑出的通常都是弱智问题

　　所以不要用特别专业的眼光去分析，一般都是系统设置没设置好，例如曾经一个MM，
帮她新配的电脑，说音箱左边的不响，过去检查，果然不响，怎么调都只有电流声，心想
坏了，买到坏的了，结果不死心一看，音量控制里她全搁到右声道了，昏死！

　　对于显示屏黑屏这种事情，要多看看显示器开关有没有开，显示器有没有插上电源，
显示器线有没有连到主机等等问题！

　　稍微高级一点，看看BIOS设定，显示器分辨率设定，对比度设定等等

　　再高级一点，看看是不是显卡风扇停转了

　　在有别的电脑的情况下，和别的电脑对调一下显示器看看，容易分辨是不是显示器的
问题，但是要注意，要是女生寝室的话，慎用！！！因为女生寝室一般好像关系都不好，
就是好也不愿意为别人的电脑奉献自己的电脑，这一点和男生寝室不一样，要鄙视一下！


　　要想帅，带上可以外接显示器的本本去，要轻薄的，2.3kg以上就不要驮过去丢脸了


　　2、要想酷、拆机箱

　　不管是不是硬件问题，如果你想MM崇拜到要嫁给你的地步，记住一定要带上一根较大
的十字起子，推荐电脑城装机的那种，很长很长的，超帅！我一般带上两根，一个十字头
，一个一字头，一个红色有机玻璃柄，一个绿色玻璃柄，就像两把短剑，有了这两柄利器
，感觉立马不一样！MM立刻觉得你就是专业的，如果MM看到后觉得害怕，别忘趁势解释一
句：修的多了，随身带着方便，你的问题不一定那么大，或许用不上。MM这个时候只会希
望自己的电脑坏的彻底一点，好见识你挥动长剑的潇洒身姿！哈哈哈哈，这句是丫丫而已
。

　　3、熟练掌握BIOS设定的窍门是看说明书！

　　其实很多时候问题和解决问题的方法都在BIOS设定上，例如老肯必须掌握的光驱启动
，就在BIOS设定里面，这个时候万一忘记了怎么办，求助于说明书吧！！！其实在说明书
中，一般都有详尽的说明，甚至包括常见问题的解决方法，只是MM们比较娇嫩，不适宜阅
读这么生硬的文字罢了你的责任就是阅读它们！！！

　　不要觉得临时看说明书很丢脸！如果说拆机箱可以展现你武的一面，那么你专注阅读
的神情正是你展现自己文的一面最好机会！！！能文能武才是你获取MM芳心的致胜法宝，
只知道挥着袖子与主板上的灰尘大战的土匪只会让MM觉得这些喜欢硬件的GG都是脏兮兮的
疯子。

　　而你要求获得主板、显卡及其他相关说明书最好的方法，要么就是一开始索要，一进
门就让她把她放这些东西的盒子搬出来放好；要么就是拆开机箱以后，惊讶一句：啊！这
不是公版设计，我要看一下出厂时的说明书！！！甭管是什么设计，你这一句话出去，MM
只会觉得你暴有水准，一眼就能看出是什么设计，其实她们也不知道什么叫公版设计母版
设计的。

　　感情篇

　　1、MM的电脑永远都是最好的

　　MM一般最要面子（当然GG也要，例如老肯），但是找你修电脑总是电脑出了问题，所
以你这个时候一定不能在伤口上散盐，切忌在修电脑的时候说：啊这种配置啊，该升级了
。或者：这种杂牌的显卡最好不要用。或者：AOC的显示器最烂了。表以为这样可以显示你
对硬件市场品牌的了解和个人的品位，这只会让MM恨死你！早期我就犯过类似口不遮拦的
错误，结果有一段时间MM们电脑坏了也不敢来找我，唉，前车之鉴啊！

　　对于MM的电脑，如果牌子好，哪怕是集成主板，也要说这个牌子我最喜欢了，稳定性
超好，这次多半是软件问题，D版毛病就是多！（甭管她机子装的系统是不是正版，用的软
件总有盗版吧）如果牌子不好，立刻说，这个牌子性价比一直就是最好的，你真会过日子
！不要忘记说“你真会过日子”的时候，一定要注视MM面带百分百诚恳的微笑！！！如果
真的什么都不行，就是完全该被淘汰的机子，尽量就不要说话了！！！说什么只会让场面
更难堪！！！

　　把电脑当作MM的脸，你就知道该怎么做了！

　　2、准确把握时间营造相遇空间

　　一般MM让你修电脑，如果答谢的话，一般都是请你吃饭，如果她请你吃饭的规格远远
超过正常修电脑的花费，不妨检查一下电脑是否有人为破坏的因素

　　对于不同的MM，土匪当然是有的求之不得，有的避之不及因而准确控制维修过程的时
间就很重要。这里教初学者一些计算时间的方法：

　　用GHOST装一个XP系统，一般是25分钟左右（如果你很熟练，20分钟内就够了）

　　用自动方式装一个XP系统，大约是1个小时（具体没算过，如果是烂威盛主板，装好驱
动还不止）

　　装一个OFFICE，大约还是要半个小时（这个可以在自定义里中选择，想拖延时间就全
选，大概可以多争取半小时）

　　时间还不到吃饭时间，或者时间到了吃饭时间但是你不想去，都可以通过装软件来慢
慢消耗，实在不行，就卸载了多装几遍！

　　当你长年累月修电脑产生厌烦心理时，推荐使用市面上的高度集成版的XP的GHOST版，
一次把乱七八糟的软件都给装上了，整个时间和装一个XP干净系统也差不多，装完就走人
，又快又省事如果老肯可以到这个境界的话，应该是已经结婚了。

　　3、修理MM电脑的过程也是检查MM人品的过程

　　实际上利用修电脑这一机会来泡MM的土匪，一般平时都是花了较多时间陪着自己的电
脑和网友，没有太多时间和固定场所（例如大学自修室、英语角或者公共社交场所）接触
真实MM的人。很多这方面的高手也都是成功地在修好电脑的同时弥补了自己姻缘的缺憾，
顺利找到另一半！但是并不是所有的相遇都是美满的结局，这除了土匪个人的RPWT，主要
还在于他们在修理电脑的时候没有注意MM们的RPWT。给出一些个人建议：

　　如果MM只会站在一边看着你修，连杯水都不给你倒，除非她年纪太小太不懂事，不然
这样的MM基本不懂关心照顾别人，也不懂尊重别人的劳动和付出。这样的MM若不是超级大
美女，还是算了！

　　如果MM会一直问这问那，特别是如果主要问你为什么要这样修的原因，这种MM不够重
视分工，喜欢主导一切，不能够尊重权威和相信理性，娶回家只会让你多一个唠唠叨叨的
监工。如果你不喜欢被人呼来唤去，没有自疟倾向，这种MM还是算了！

　　如果MM一直问你要不要喝水，要不要歇一会儿，还问一些和修电脑无关的情况，例如
问你这么好的技术都怎么学来的啊，如果殷勤到一反常态的地步，恭喜你！这个MM想泡你
！！！如果这个MM一贯对人热情，那么这种MM属于擅长公关，有很强的管理和组织能力，
这种MM也会成为未来家中的主管，但是好在是一种以人为本的管理，你不至于太痛苦这样
的MM，只要平时不是那种过分往上爬巴结领导的类型，实际上还算不错的选择

　　如果MM话并不多，默默地给你倒杯水，然后再一旁看着，不时跑过来帮你递东西，这
种是贤妻良母型，是那种甘愿在背后默默支持你的类型，你要是事业主导型的土匪，毫不
犹豫泡这个MM吧！！！极品赞不绝口。（就是恐龙也不妨考虑一下）

　　如果MM给你东西吃，证明对你不见外；从来没见过的MM话，证明对你很有好感！小子
，你赚了！

　　MM站着看你修电脑，有座位不坐，离得近的是关心电脑！离得远的还站着，如果不是
眼睛超好的那种，这种MM有同甘共苦的意识，一般富有同情心，比较爱国（自己到时候对
照一下）

　　MM坐着看你修电脑，正常；MM坐着但是不看你，眼光会游移到别的地方或者做自己的
小动作，死了心吧！她已经有意中人了！

　　MM躺着看你修电脑（还真的有！）遇到的都是和我太熟悉的才这样！第一次就这样没
遇到过，真有的话，就是RPWT！！！

　　MM在你修电脑的时候去洗澡了（遇到一次！）这个MM如果不是三天没洗澡，那就是把
你当成家人看待了，我觉得关系很熟这样的话就不算什么；如果第一次就这样，建议逃走
或者躺下！！！

　　MM修电脑的时候把父母介绍给你（到她家修电脑）或者给你看她存在电脑上家人的照
片，她很希望成为你重要的朋友。

J2EE 面试题综合
/**
 * By metaphy 2005-11-12
 * Version: 0.01
 * 注:题目答案来源于metaphy过去的知识或网络,metaphy不能保证其正确或完整性,仅供参考
*/
[基础问答]
1.下面哪些类可以被继承?
java.lang.Thread (T)
java.lang.Number (T)
java.lang.Double (F)
java.lang.Math  (F)
java.lang.Void  (F)
java.lang.Class  (F)
java.lang.ClassLoader (T)

2.抽象类和接口的区别
(1)接口可以被多重implements,抽象类只能被单一extends
(2)接口只有定义,抽象类可以有定义和实现
(3)接口的字段定义默认为:public static final, 抽象类字段默认是"friendly"(本包可见)

3.Hashtable的原理,并说出HashMap与Hashtable的区别
HashTable的原理:通过节点的关键码确定节点的存储位置,即给定节点的关键码k,通过一定的函数关系H(散列函数),得到函数值H(k),将此值解释为该节点的存储地址.
HashMap 与Hashtable很相似,但HashMap 是非同步(unsynchronizded)和可以以null为关键码的.

4.forward和redirect的区别
forward: an internal transfer in servlet
redirect: 重定向,有2次request,第2次request将丢失第一次的attributs/parameters等

5.什么是Web容器?
实现J2EE规范中web协议的应用.该协议定义了web程序的运行时环境,包括:并发性,安全性,生命周期管理等等.

6.解释下面关于J2EE的名词
(1)JNDI:Java Naming & Directory Interface,JAVA命名目录服务.主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能.
(2)JMS：Java Message Service,JAVA消息服务.主要实现各个应用程序之间的通讯.包括点对点和广播.
(3)JTA：Java Transaction API,JAVA事务服务.提供各种分布式事务服务.应用程序只需调用其提供的接口即可.
(4)JAF: Java Action FrameWork,JAVA安全认证框架.提供一些安全控制方面的框架.让开发者通过各种部署和自定义实现自己的个性安全控制策略.
(5)RMI:Remote Method Interface,远程方法调用

7.EJB是基于哪些技术实现的？并说 出SessionBean和EntityBean的区别，StatefulBean和StatelessBean的区别.
EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现.
SessionBean在J2EE应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调用其他EJB组件.EntityBean被用来代表应用系统中用到的数据.对于客户机，SessionBean是一种非持久性对象，它实现某些在服务器上运行的业务逻辑;EntityBean是一种持久性对象，它代表一个存储在持久性存储器中的实体的对象视图，或是一个由现有企业应用程序实现的实体.
Session Bean 还可以再细分为 Stateful Session Bean 与 Stateless Session Bean .这两种的 Session Bean都可以将系统逻辑放在 method之中执行，不同的是 Stateful Session Bean 可以记录呼叫者的状态，因此通常来说，一个使用者会有一个相对应的 Stateful Session Bean 的实体.Stateless Session Bean 虽然也是逻辑组件，但是他却不负责记录使用者状态，也就是说当使用者呼叫 Stateless Session Bean 的时候，EJB Container 并不会找寻特定的 Stateless Session Bean 的实体来执行这个 method.换言之，很可能数个使用者在执行某个 Stateless Session Bean 的 methods 时，会是同一个 Bean 的 Instance 在执行.从内存方面来看， Stateful Session Bean 与 Stateless Session Bean 比较， Stateful Session Bean 会消耗 J2EE Server 较多的内存，然而 Stateful Session Bean 的优势却在于他可以维持使用者的状态.

8.XML的解析方法
Sax,DOM,JDOM

9.什么是Web Service?
Web Service就是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。
Web Service所使用的是Internet上统一、开放的标准，如HTTP、XML、SOAP（简单对象访问协议）、WSDL等，所以Web Service可以在任何支持这些标准的环境（Windows,Linux）中使用。
注：SOAP协议（Simple Object Access Protocal,简单对象访问协议）,它是一个用于分散和分布式环境下网络信息交换的基于XML的通讯协议。在此协议下，软件组件或应用程序能够通过标准的HTTP协议进行通讯。它的设计目标就是简单性和扩展性，这有助于大量异构程序和平台之间的互操作性，从而使存在的应用程序能够被广泛的用户访问。

优势：
(1).跨平台；
(2).SOAP协议是基于XML和HTTP这些业界的标准的，得到了所有的重要公司的支持。
(3).由于使用了SOAP，数据是以ASCII文本的方式而非二进制传输，调试很方便；并且由于这样，它的数据容易通过防火墙，不需要防火墙为了程序而单独开一个“漏洞”。
(4).此外，WebService实现的技术难度要比CORBA和DCOM小得多。
(5).要实现B2B集成，EDI比较完善与比较复杂；而用WebService则可以低成本的实现，小公司也可以用上。
(6).在C/S的程序中，WebService可以实现网页无整体刷新的与服务器打交道并取数。
缺点：
(1).WebService使用了XML对数据封装，会造成大量的数据要在网络中传输。
(2).WebService规范没有规定任何与实现相关的细节，包括对象模型、编程语言，这一点，它不如CORBA。

10.多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify

11.JSP中动态INCLUDE与静态INCLUDE的区别？
动态INCLUDE用jsp:include动作实现
<jsp:include page="included.jsp" flush="true"/>
它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面
<%@ include file="included.htm" %>
 

[Java编程与程序运行结果]
1.Java编程,打印昨天的当前时刻
public class YesterdayCurrent{
  public void main(String[] args){
    Calendar cal = Calendar.getInstance();
    cal.add(Calendar.DATE, -1);
    System.out.println(cal.getTime());
  }
}

2.文件读写,实现一个计数器
  public int getNum(){
        int i = -1;
        try{
            String stri="";
            BufferedReader in = new BufferedReader(new FileReader(f));
            while((stri=in.readLine())!=null){
                i = Integer.parseInt(stri.trim());
            }
            in.close();
        }catch(Exception e){
            e.printStackTrace();
        }
        return i;
    }
    public void setNum(){
        int i = getNum();
        i++;       
        try{
            PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter(f,false))); 
            out.write(String.valueOf(i));            //可能是编码的原因，如果直接写入int的话，将出现java编码和windows编码的混乱，因此此处写入的是String
            out.close() ;
        }catch(Exception e){
            e.printStackTrace();
        }
    }
3. 指出下面程序的运行结果:
class A{
    static{
        System.out.print("1");
    }
    public A(){
        System.out.print("2");
    }
}
class B extends A{
    static{
        System.out.print("a");
    }
    public B(){
        System.out.print("b");
    }  
}
public class Hello{
    public static void main(String[] ars){
        A ab = new B(); //执行到此处,结果: 1a2b
 ab = new B(); //执行到此处,结果: 1a2bab
    }
}
注:类的static 代码段,可以看作是类首次加载(被虚拟机加载)执行的代码,而对于类的加载,首先要执行其基类的构造,再执行其本身的构造
4.写一个Singleton模式的例子
public class Singleton{
 private static Singleton single = new Singleton();
 private Singleton(){}
 public Singleton getInstance(){
  return single;
 }
}

[数据库]
1.删除表的重复记录
如果记录完全相同才算重复记录,那么:  (sql server2000下测试通过)
select distinct * into #tmpp from tid
delete from tid     
insert into tid select * from #tmpp
drop table #tmpp
如果有id主键(数字,自增1的那种),那么:(sql server2000下测试通过)
delete from tableA where id not in
(select id = min(id) from tableA group by name)

2.delete from tablea ＆ truncate table tablea的区别
truncate 语句执行速度快,占资源少,并且只记录页删除的日志；
delete 对每条记录的删除均需要记录日志

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=529244

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=535970

关于UDP穿透NAT的中文资料在网络上是很少的，仅有<<P2P之UDP穿透NAT的原理与实现(shootingstars)>>这篇文章有实际的参考价值。本人近两年来也一直从事P2P方面的开发工作，比较有代表性的是个人开发的BitTorrent下载软件 - FlashBT(变态快车). 对P2P下载或者P2P的开发感兴趣的朋友可以访问软件的官方主页: http://www.hwysoft.com/chs/ 下载看看，说不定有收获。写这篇文章的主要目的是懒的再每次单独回答一些网友的提问, 一次性写下来, 即节省了自己的时间，也方便了对于P2P的UDP穿透感兴趣的网友阅读和理解。对此有兴趣和经验的朋友可以给我发邮件或者访问我的个人Blog留言: http://hwycheng.blogchina.com. 您可以自由转载此篇文章，但是请保留此说明。

再次感谢shootingstars网友的早期贡献. 表示谢意。

NAT(The IP Network Address Translator) 的概念和意义是什么?

NAT, 中文翻译为网络地址转换。具体的详细信息可以访问RFC 1631 - http://www.faqs.org/rfcs/rfc1631.html, 这是对于NAT的定义和解释的最权威的描述。网络术语都是很抽象和艰涩的，除非是专业人士，否则很难从字面中来准确理解NAT的含义。

要想完全明白NAT 的作用，我们必须理解IP地址的两大分类，一类是私有IP地址，在这里我们称作内网IP地址。一类是非私有的IP地址，在这里我们称作公网IP地址。关于IP地址的概念和作用的介绍参见我的另一篇文章: http://hwycheng.blogchina.com/2402121.html

内网IP地址: 是指使用A/B/C类中的私有地址, 分配的IP地址在全球不惧有唯一性，也因此无法被其它外网主机直接访问。公网IP地址: 是指具有全球唯一的IP地址，能够直接被其它主机访问的。

NAT 最初的目的是为使用内网IP地址的计算机提供通过少数几台具有公网的IP地址的计算机访问外部网络的功能。NAT 负责将某些内网IP地址的计算机向外部网络发出的IP数据包的源IP地址转换为NAT自己的公网的IP地址，目的IP地址不变, 并将IP数据包转发给路由器，最终到达外部的计算机。同时负责将外部的计算机返回的IP数据包的目的IP地址转换为内网的IP地址，源IP地址不变，并最终送达到内网中的计算机。

图一: NAT 实现了私有IP的计算机分享几个公网IP地址访问Internet的功能。

随着网络的普及，IPv4的局限性暴露出来。公网IP地址成为一种稀缺的资源，此时NAT 的功能局限也暴露出来，同一个公网的IP地址，某个时间只能由一台私有IP地址的计算机使用。于是NAPT(The IP Network Address/Port Translator)应运而生，NAPT实现了多台私有IP地址的计算机可以同时通过一个公网IP地址来访问Internet的功能。这在很大程度上暂时缓解了IPv4地址资源的紧张。

NAPT 负责将某些内网IP地址的计算机向外部网络发出的TCP/UDP数据包的源IP地址转换为NAPT自己的公网的IP地址，源端口转为NAPT自己的一个端口。目的IP地址和端口不变, 并将IP数据包发给路由器，最终到达外部的计算机。同时负责将外部的计算机返回的IP数据包的目的IP地址转换内网的IP地址，目的端口转为内网计算机的端口，源IP地址和源端口不变，并最终送达到内网中的计算机。

图二: NAPT 实现了私有IP的计算机分享一个公网IP地址访问Internet的功能。

在我们的工作和生活中, NAPT的作用随处可见，绝大部分公司的网络架构，都是通过1至N台支持NAPT的路由器来实现公司的所有计算机连接外部的Internet网络的。包括本人在写这篇文章的时候，也是在家中使用一台IBM笔记本通过一台宽带连接的台式机来访问Internet的。我们本篇文章主要讨论的NAPT的问题。

NAPT(The IP Network Address/Port Translator) 为何阻碍了P2P软件的应用?

通过NAPT 上网的特点决定了只能由NAPT内的计算机主动向NAPT外部的主机发起连接，外部的主机想直接和NAPT内的计算机直接建立连接是不被允许的。IM(即时通讯)而言，这意味着由于NAPT内的计算机和NAPT外的计算机只能通过服务器中转数据来进行通讯。对于P2P方式的下载程序而言，意味着NAPT内的计算机不能接收到NAPT外部的连接，导致连接数用过少，下载速度很难上去。因此P2P软件必须要解决的一个问题就是要能够在一定的程度上解决NAPT内的计算机不能被外部连接的问题。

NAT(The IP Network Address Translator) 进行UDP穿透的原理是什么?

TCP/IP传输时主要用到TCP和UDP协议。TCP协议是可靠的，面向连接的传输协议。UDP是不可靠的，无连接的协议。根据TCP和UDP协议的实现原理，对于NAPT来进行穿透，主要是指的UDP协议。TCP协议也有可能，但是可行性非常小，要求更高，我们此处不作讨论，如果感兴趣可以到Google上搜索，有些文章对这个问题做了探讨性的描述。下面我们来看看利用UDP协议来穿透NAPT的原理是什么:

图三: NAPT 是如何将私有IP地址的UDP数据包与公网主机进行透明传输的。

UDP协议包经NAPT透明传输的说明:

NAPT为每一个Session分配一个NAPT自己的端口号，依据此端口号来判断将收到的公网IP主机返回的TCP/IP数据包转发给那台内网IP地址的计算机。在这里Session是虚拟的，UDP通讯并不需要建立连接，但是对于NAPT而言，的确要有一个Session的概念存在。NAPT对于UDP协议 包的透明传输面临的一个重要的问题就是如何处理这个虚拟的Session。我们都知道TCP连接的Session以SYN包开始，以FIN包结束，NAPT可以很容易的获取到TCP Session的生命周期，并进行处理。但是对于UDP而言，就麻烦了，NAPT并不知道转发出去的UDP协议包是否到达了目的主机，也没有办法知道。而且鉴于UDP协议的特点，可靠很差，因此NAPT必须强制维持Session的存在，以便等待将外部送回来的数据并转发给曾经发起请求的内网IP地址的计算机。NAPT具体如何处理UDP Session的超时呢？不同的厂商提供的设备对于NAPT的实现不近相同，也许几分钟，也许几个小时，些NAPT的实现还会根据设备的忙碌状态进行智能计算超时时间的长短。

图四: NAPT 将内部发出的UDP协议包的源地址和源端口改变传输给公网IP主机。

图五: NAPT 将收到的公网IP主机返回的UDP协议包的目的地址和目的端口改变传输给内网IP计算机现在我们大概明白了NAPT如何实现内网计算机和外网主机间的透明通讯。现在来看一下我们最关心的问题，就是NAPT是依据什么策略来判断是否要为一个请求发出的UDP数据包建立Session的呢？主要有一下几个策略:

A. 源地址(内网IP地址)不同，忽略其它因素, 在NAPT上肯定对应不同的Session B. 源地址(内网IP地址)相同，源端口不同，忽略其它的因素，则在NAPT上也肯定对应不同的Session C. 源地址(内网IP地址)相同，源端口相同，目的地址(公网IP地址)相同，目的端口不同，则在NAPT上肯定对应同一个Session D. 源地址(内网IP地址)相同，源端口相同，目的地址(公网IP地址)不同，忽略目的端口，则在NAPT上是如何处理Session的呢？

D的情况正式我们关心和要讨论的问题。依据目的地址(公网IP地址)对于Session的建立的决定方式我们将NAPT设备划分为两大类:

Symmetric NAPT: 对于到同一个IP地址，任意端口的连接分配使用同一个Session; 对于到不同的IP地址, 任意端口的连接使用不同的Session. 我们称此种NAPT为 Symmetric NAPT. 也就是只要本地绑定的UDP端口相同， 发出的目的IP地址不同，则会建立不同的Session.

图六: Symmetric 的英文意思是对称。多个端口对应多个主机，平行的，对称的!

Cone NAPT: 对于到同一个IP地址，任意端口的连接分配使用同一个Session; 对于到不同的IP地址，任意端口的连接也使用同一个Session. 我们称此种NAPT为 Cone NAPT. 也就是只要本地绑定的UDP端口相同， 发出的目的地址不管是否相同， 都使用同一个Session.

图七: Cone 的英文意思是锥。一个端口对应多个主机，是不是像个锥子?

现在绝大多数的NAPT属于后者，即Cone NAT。本人在测试的过程中，只好使用了一台日本的Symmetric NAT。还好不是自己的买的，我从不买日货, 希望看这篇文章的朋友也自觉的不要购买日本的东西。Win9x/2K/XP/2003系统自带的NAPT也是属于 Cone NAT的。这是值的庆幸的，因为我们要做的UDP穿透只能在Cone NAT间进行，只要有一台不是Cone NAT，对不起，UDP穿透没有希望了，服务器转发吧。后面会做详细分析!

下面我们再来分析一下NAPT 工作时的一些数据结构，在这里我们将真正说明UDP可以穿透Cone NAT的依据。这里描述的数据结构只是为了说明原理，不具有实际参考价值，真正感兴趣可以阅读Linux的中关于NAT实现部分的源码。真正的NAT实现也没有利用数据库的，呵呵，为了速度！

Symmetric NAPT 工作时的端口映射数据结构如下:

内网信息表:

[NAPT 分配端口] [ 内网IP地址 ] [ 内网端口 ] [ 外网IP地址 ] [ SessionTime 开始时间 ]

PRIMARY KEY( [NAPT 分配端口] ) -> 表示依据[NAPT 分配端口]建立主键，必须唯一且建立索引，加快查找. UNIQUE( [ 内网IP地址 ], [ 内网端口 ] ) -> 表示这两个字段联合起来不能重复. UNIQUE( [ 内网IP地址 ], [ 内网端口 ], [ 外网IP地址 ] ) -> 表示这三个字段联合起来不能重复.

映射表:

[NAPT 分配端口] [ 外网端口 ]

UNIQUE( [NAPT 分配端口], [ 外网端口 ] ) -> 表示这两个字段联合起来不能重复.

Cone NAPT 工作时的端口映射数据结构如下:

内网信息表:

[NAPT 分配端口] [ 内网IP地址 ] [ 内网端口 ] [ SessionTime 开始时间 ]

PRIMARY KEY( [NAPT 分配端口] ) -> 表示依据[NAPT 分配端口]建立主键，必须唯一且建立索引，加快查找. UNIQUE( [ 内网IP地址 ], [ 内网端口 ] ) -> 表示这两个字段联合起来不能重复.

外网信息表:

[ wid 主键标识 ] [ 外网IP地址 ] [ 外网端口 ]

PRIMARY KEY( [ wid 主键标识 ] ) -> 表示依据[ wid 主键标识 ]建立主键，必须唯一且建立索引，加快查找. UNIQUE( [ 外网IP地址 ], [ 外网端口 ] ) -> 表示这两个字段联合起来不能重复.

映射表: 实现一对多，的

[NAPT 分配端口] [ wid 主键标识 ]

UNIQUE( [NAPT 分配端口], [ wid 主键标识 ] ) -> 表示这两个字段联合起来不能重复. UNIQUE( [ wid 主键标识 ] ) -> 标识此字段不能重复.

看完了上面的数据结构是更明白了还是更晕了？ 呵呵! 多想一会儿就会明白了。通过NAT,内网计算机计算机向外连结是很容易的，NAPT会自动处理，我们的应用程序根本不必关心它是如何处理的。那么外部的计算机想访问内网中的计算机如何实现呢？我们来看一下下面的流程：

c 是一台在NAPT后面的内网计算机，s是一台有外网IP地址的计算机。c 主动向 s 发起连接请求，NAPT依据上面描述的规则在自己的数据结构中记录下来，建立一个Session. 然后 c 和 s 之间就可以实现双向的透明的数据传输了。如下面所示:

  c[192.168.0.6:1827] <-> [priv ip: 
192.168.0.1]NAPT[pub ip: 61.51.99.86:9881] <-> s[61.51.76.102:8098]

由此可见，一台外网IP地址的计算机想和NAPT后面的内网计算机通讯的条件就是要求NAPT后面的内网计算机主动向外网IP地址的计算机发起一个UDP数据包。外网IP地址的计算机利用收到的UDP数据包获取到NAPT的外网IP地址和映射的端口，以后就可以和内网IP的计算机透明的进行通讯了。

现在我们再来分析一下我们最关心的两个NAPT后面的内网计算机如何实现直接通讯呢? 两者都无法主动发出连接请求，谁也不知道对方的NAPT的公网IP地址和NAPT上面映射的端口号。所以我们要靠一个公网IP地址的服务器帮助两者来建立连接。当两个NAPT后面的内网计算机分别连接了公网IP地址的服务器后，服务器可以从收到的UDP数据包中获取到这两个NAPT设备的公网IP地址和这两个连接建立的Session的映射端口。两个内网计算机可以从服务器上获取到对方的NAPT设备公网IP地址和映射的端口了。

我们假设两个内网计算机分别为A和B，对应的NAPT分别为AN和 BN， 如果A在获取到B对应的BN的IP地址和映射的端口后，迫不急待的向这个IP 地址和映射的端口发送了个UDP数据包，会有什么情况发生呢？依据上面的原理和数据结构我们会知道，AN会在自己的数据结构中生成一条记录，标识一个新Session的存在。BN在收到数据包后，从自己的数据结构中查询，没有找到相关记录，因此将包丢弃。B是个慢性子，此时才慢吞吞的向着AN的IP地址和映射的端口发送了一个UDP数据包，结果如何呢？当然是我们期望的结构了，AN在收到数据包后，从自己的数据结构中查找到了记录，所以将数据包进行处理发送给了A。A 再次向B发送数据包时，一切都时畅通无阻了。OK, 大工告成！且慢，这时对于Cone NAPT而言，对于Symmetric NAPT呢？呵呵，自己分析一下吧...

NAPT(The IP Network Address/Port Translator) 进行UDP穿透的具体情况分析!

首先明确的将NAPT设备按照上面的说明分为: Symmetric NAPT 和 Cone NAPT, Cone NAPT 是我们需要的。Win9x/2K/XP/2003 自带的NAPT也为Cone NAPT。

第一种情况, 双方都是Symmetric NAPT:

此情况应给不存在什么问题，肯定是不支持UDP穿透。

第二种情况, 双方都是Cone NAPT:

此情况是我们需要的，可以进行UDP穿透。

第三种情况, 一个是Symmetric NAPT, 一个是Cone NAPT:

此情况比较复杂，但我们按照上面的描述和数据机构进行一下分析也很容易就会明白了, 分析如下,

假设: A -> Symmetric NAT, B -> Cone NAT

1. A 想连接 B, A 从服务器那儿获取到 B 的NAT地址和映射端口, A 通知服务器，服务器告知 B A的NAT地址和映射端口, B 向 A 发起连接，A 肯定无法接收到。此时 A 向 B 发起连接， A 对应的NAT建立了一个新的Session，分配了一个新的映射端口， B 的 NAT 接收到UDP包后，在自己的映射表中查询，无法找到映射项，因此将包丢弃了。

2. B 想连接 A, B 从服务器那儿获取到 A 的NAT地址和映射端口, B 通知服务器, 服务器告知 A B的NAT地址和映射端口,A 向 B 发起连接, A 对应的NAT建立了一个新的Session，分配了一个新的映射端口B肯定无法接收到。此时 B 向 A 发起连接, 由于 B 无法获取 A 建立的新的Session的映射端口，仍是使用服务器上获取的映射端口进行连接， 因此 A 的NAT在接收到UDP包后，在自己的映射表中查询，无法找到映射项, 因此将包丢弃了。

根据以上分析，只有当连接的两端的NAT都为Cone NAT的情况下，才能进行UDP的内网穿透互联。

NAPT(The IP Network Address/Port Translator) 进行UDP穿透如何进行现实的验证和分析!

需要的网络结构如下:

三个NAT后面的内网机器，两个外网服务器。其中两台Cone NAPT，一台 Symmetric NAPT。

验证方法:

可以使用本程序提供的源码，编译，然后分别运行服务器程序和客户端。修改过后的源码增加了客户端之间直接通过IP地址和端口发送消息的命令，利用此命令，你可以手动的验证NAPT的穿透情况。为了方便操作，推荐你使用一个远程登陆软件，可以直接在一台机器上操作所有的相关的计算机，这样很方便，一个人就可以完成所有的工作了。呵呵，本人就是这么完成的。欢迎有兴趣和经验的朋友来信批评指正，共同进步。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=525238

//****************************************
char * change(char *ps,char *pt);      //处理路径中的反斜杠问题。因为在字符串中要用\\表示\
int  searchkey(char *word,struct key tab[],int n);//二分法查找关键字
int  searchsymbol(char c,struct symbol tab[],int n);
void getword(int c,FILE * p);
//****************************************
//用到的结构数组：
struct  key{          //关键字表
    char*   word;
    int     value;
}keytab[] = {
         "else",  0,
         "if",    1,
         "int",   2,
         "return",3,
         "void",  4,
         "while", 5,
};
//****
struct   symbol{        //符号表
      char  c;
      int   value;
}symboltab[] = {
        '(', 0,
        ')', 1,
        '*', 2,
        '+', 3,
        ',', 4,
        '-', 5,
        '/', 6,
        ';', 7,
        '<', 8,
        '=', 9,
        '>', 10,
        '[', 11,
        ']', 12,
        '{', 13,
        '}', 14,
};
//*****************************************

//用到的常量
enum{MAX = 50,
     NKEYS = sizeof keytab / sizeof keytab[0],
     NSYMBOL = sizeof symboltab / sizeof symboltab[0]
};
//*****************************************

//用到的全局变量
int flagnum = 0;  //用来防止出现10t这种情况被当作数字处理。这种情况程序报错
int countnum = 0;
int countid  = 0;
int countfault = 0;
int type[] = {0,1,2,3,4};            //词法分析中的类型  依次为 关键字，数字，id，符号
char array[MAX];           //存放getword中的字符串

//*****************************************

main()
{
 int c;
 int flag;     //判断搜索函数是否成功返回
    char s[MAX];       //数组s，t用来存放读取文件的路径
 char t[2 * MAX];
 char *ps = s;
 char *pt = t;
    FILE * p = NULL;

    printf("input the path of the file\n");
 scanf("%s",s);
    p = fopen( change(ps,pt),"r" );     //打开文件
    if( p == NULL ){                   //如果输入的文件路径不对或文件不存在
        printf("open fail!\n");
        exit(0);
    } 
 printf("data \t (type,value)\n");
    while( ( c = fgetc(p) ) != EOF ){
  if ( isspace(c) )       // 如果是空白字符
   continue;
  else if ( isalpha(c) ){
    getword(c,p);
             flag = searchkey(array,keytab,NKEYS);
    if ( flag >= 0 )                      //如果是关键字
     printf("%s\t(%d,%d)\n",array,type[0],flag);
    else{                                 //如果以字母开头，但不是关键字
     printf("%s\t(%d,%d)\n",array,type[2],countid);
                 countid ++;
    }
  }else if ( isdigit(c) ){         //如果是数字
              flagnum = 0;        /*解决getword中的一个bug。如果一个数字之前有超过1个的字符串，如in 2。则后面所有的数字都不能被正确分析*/

     getword(c,p);
     if ( flagnum == 0 )
      printf("%s\t(%d,%d)\n",array,type[1],countnum);
     else
      printf("%s\t(%d,%d)\t illegal input \n",array,type[4],countfault);
  }else if ( ispunct(c) ){        //如果是符号
              flag = searchsymbol(c,symboltab,NSYMBOL);
     if ( flag >= 0 )
      printf("%c\t(%d,%d)\n",c,type[3],flag);
     else{
     printf("%c\t(%d,%d)\n",c,type[4],countfault);  //出错处理
                 countfault ++;
     }
  }else{
   printf("%c\t(%d,%d)\n",c,type[4],countfault);       //出错处理
   countfault ++;
  }
 }
 return 0;
}

//*******************************************
char * change(char *ps,char *pt)     /*处理反斜杠的问题*/
{
 char *p = pt;
 char c;

 while( (c = *pt++ = *ps++) != '\0' )
  if( c == '\\' )
   *pt = '\\';
 return p;
}

//******************************************
int  searchkey(char *word,struct key tab[],int n)
{
 int cond;
 int low,high,mid;

 low = 0;
 high = n -1;
 while ( low <= high ){
  mid = (low +high) / 2;
  if ( ( cond = strcmp(word,tab[mid].word) ) < 0 )
   high = mid - 1;
  else if ( cond > 0 )
   low = mid + 1;
  else
   return mid;
 }
 return -1;
}

//**********************************************
int  searchsymbol(char c,struct symbol tab[],int n)
{
 
    int low,high,mid;

    low = 0;
 high = n -1;
 while ( low <= high ){
  mid = (low +high) / 2;
  if ( c < tab[mid].c)
   high = mid - 1;
  else if(c > tab[mid].c)
   low = mid + 1;
  else
   return mid;
 }
 return -1;
}
//*******************************************
void getword(int c,FILE * p)
{
 int i = 0;
 array[i] = c;
 while( (c = fgetc(p)) != ' ' && c != '\n'){
  if ( isalpha(c) | ispunct(c) )             //如果数字中有字母或字符，则报错
   flagnum = 1;                                 /*一个可能引起错误的地方。已经解决（在读入数字后，把flagnum置0，再进入getword）*/
  array[++i] = c;
 }
 array[++i] = '\0';
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=526675

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=519218

作者： 张桂权

long a=10000, b, c=2800, d, e, f[2801], g;

main{ for(;b-c;) f[b++]=a/5;
for(;d=0,g=c*2;c-=14,printf("%.4d",e+d/a),e=d%a)
for(b=c; d+=f[b]*a, f[b]=d%--g, d/=g--, --b; d*=b); scanf("%s");}

简短的4行代码，就可以精确计算机出800位的PI（圆周率）值。
实在太震撼人心了。这样的程序也能运行，竟然还能能完成这样让人难以置信的任务，真是太神了。
真让人百思不知其解了。不知道它是采用了哪一个级数公式，收敛速度如此之快？在《程序员》第十一期中还专门提供了这个程序源码。喜欢挑战的朋友请来试一试哦？

这是某一年The International Obfuscated C Code Contest（国际模糊C代码大赛）上的获奖作品（努力了，但是没有找到一个确切的时间）。这是属于C大师的盛会，因为这是一件极具挑战的活儿。

这是Linux/Unix/... 下的版本，需要更改才能在Windows平台上运行。

The International Obfuscated C Code Contest 的目标是：

在以下几条规则的前提下，编写晦涩难懂的（模糊的、混乱的）C程序。
1、通过一种讽刺的手段，来说明编程风格的重要性；
2、用怪异的代码来调试C编译器；
3、举例说明一些C语言的薄弱或精明之处；
4、为脆弱的C代码提供一个安全的讨论会。

Goals of the Contest

Obfuscate: tr.v. -cated, -cating, -cates. 1. a. To render obscure.
b. To darken. 2. To confuse: his emotions obfuscated his judgment.
[LLat. obfuscare, to darken : ob(intensive) + Lat. fuscare,
to darken < fuscus, dark.] -obfuscation n. obfuscatory adj

To write the most Obscure/Obfuscated C program under the rules below.
To show the importance of programming style, in an ironic way.
To stress C compilers with unusual code.
To illustrate some of the subtleties of the C language.
To provide a safe forum for poor C code. :-)

请访问下面的官方网站，如果希望了解更多的相关信息。

http://www.ioccc.org/
http://www.au.ioccc.org/

Pi to one MILLION decimal places

http://3.141592653589793238462643383279502884197169399375105820974944592.com/

二、 以下是另一个版本的程序。一样晦涩难懂。（1988年）

Here's another good one:

/*
 * Program to compute an approximation of pi
 * by Brian Westley, 1988
 * (requires pcc macro concatenation; try gcc -traditional-cpp)
 */

#define _ -F<00||--F-OO--;
int F=00,OO=00;
main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO()
{
            _-_-_-_
       _-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_
        _-_-_-_-_-_-_-_
            _-_-_-_
}

http://www.comedia.com/hot/jargon-4.2.3/html/entry/Obfuscated-C-Contest.html

这个程序更有意思了，可惜我还不明白其中的原理。希望大家讨论一下，谢谢 ！

        DDA称为数值微分画线算法，是直线生成算法中最简单的一种。原理相当简单，就是最直观的根据斜率的偏移程度，决定是以x为步进方向还是以y为步进方向。然后在相应的步进方向上，步进变量每次增加一个像素，而另一个相关坐标变量则为Yk_1=Yk+m（以x为步进变量为例，m为斜率）

        这个程序对于我的意义在于：可以在VC中利用GDI的画点函数---  SetPixel来实现它，终于可以告别C语言绘图还用TC的时代，呵呵~~~

void DDALine(float x1,float y1,float x2,float y2,int color,HDC hdc)

{

       float m;

       float dx,dy;

       float x,y;

       x1=(int)(x1+0.5);

       y1=(int)(y1+0.5);

       x=x1;

       y=y1;

       dx=x2-x1;

       dy=y2-y1;

       if(fabs(dx)>=fabs(dy))

              m=dy/dx;

       else

              m=dx/dy;

       while(x<=x2)

       {    

              SetPixel(hdc,x,y,color);

              if(fabs(dx)>=dy)

              {

                     y=y+m;

                     x++;

              }

              else

              {

                     x=x+m;

                     y++;

              }

       }

}

VC中的实现:

#include "GraphAlgorithm.h"

#include<windows.h>

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

long WINAPI WndProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam);

BOOL InitWindowsClass(HINSTANCE hInstance);

BOOL InitWindows(HINSTANCE hInstance,int nCmdShow);

HWND hWndMain;

LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);

//program starting.

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInst,LPSTR lpszCmdLine,int nCmdShow)

{

       MSG   msg;

       if(!InitWindowsClass(hInstance))

              return FALSE;

       if(!InitWindows(hInstance,nCmdShow))

              return FALSE;

       //Core message looping

       while(GetMessage(&msg,NULL,0,0))

       {

              TranslateMessage(&msg);

              DispatchMessage(&msg);

       }

       return msg.wParam;

}

//main wndProc function: message looping

long WINAPI WndProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam)

{

       HDC hDC;

       HBRUSH hBrush;

       HPEN hPen;

       PAINTSTRUCT PtStr;

       switch(iMessage)

       {

              case WM_PAINT:

                     //First draw,a black line

                     hDC=BeginPaint(hWnd,&PtStr);

                     hPen=(HPEN)GetStockObject(NULL_PEN);//get empty brush

                     SelectObject(hDC,hPen);

                     hBrush=(HBRUSH)GetStockObject(BLACK_BRUSH);

                     SelectObject(hDC,hBrush);

                     hPen=CreatePen(PS_SOLID,2,RGB(255,0,0));//create pen

                     SelectObject(hDC,hPen);

                     DDALine(0,0,200,200,1,hDC);

                     DeleteObject(hPen);

                     DeleteObject(hBrush);

                     EndPaint(hWnd,&PtStr);

                     return 0;

              case WM_DESTROY:

                     PostQuitMessage(0);

                     return 0;

              default:

                     return DefWindowProc(hWnd,iMessage,wParam,lParam);

       }

}

//Init the Window to show out.

BOOL InitWindows(HINSTANCE hInstance,int nCmdShow)

{

       HWND hWnd;

       hWnd=CreateWindow("WinFill",

                            "图形绘制算法示例程序",

                                   WS_OVERLAPPEDWINDOW,

                            CW_USEDEFAULT,

                            0,

                            CW_USEDEFAULT,

                            0,

                            NULL,   

                            NULL,

                            hInstance,

                            NULL    

                         );

       if(!hWnd)

              return FALSE;

       hWndMain=hWnd;

       ShowWindow(hWnd,nCmdShow);

       UpdateWindow(hWnd);

       return TRUE;

}

//Set wndClass Propertity

BOOL InitWindowsClass(HINSTANCE hInstance)

{

       WNDCLASS wndClass;

       wndClass.cbClsExtra=0;

       wndClass.cbWndExtra=0;

       wndClass.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH);

       wndClass.hCursor=LoadCursor(NULL,IDC_ARROW);

       wndClass.hIcon=LoadIcon(NULL,"END");

       wndClass.hInstance=hInstance;

       wndClass.lpfnWndProc=WndProc;

       wndClass.lpszClassName="WinFill";

       wndClass.lpszMenuName=NULL;

       wndClass.style=CS_HREDRAW|CS_VREDRAW;

       return RegisterClass(&wndClass);

}

       通过测试表明,当斜率较大时,如3以上,出现了些小锯齿.

   继续前进!!!

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=531093

学习Winsock编程，用TCP协议收发文件是必不可少的一个实践环节，而计算收发百分比的一行代码，很多人都写不对。

假设我们用DWORD（unsigned long）来表示文件长度，则长度的最大值是2³²－1，也就是4GB。虽然Win32 API能够返回两个DWORD表示长度，但是为了简便，我们还是原意接收4GB的人为限制。以下我们的讨论基于这个前提。

通常我们会使用一个DWORD表示length，一个DWORD表示pos。为了避免使用浮点数，很多人会这样写

DWORD percent = pos * 100 / length;

之所以把100乘在前面，是因为这个除法是整数除法，不这样的话，percent将永远是0。这样以来，pos*100便有了一个限制，它不能溢出，也就是不能大于2³²－1。这样，如果我们传送大于4GB/100＝40MB的文件，这个percent就会计算错误。

显然不能先做乘法，但还要不使用浮点运算，怎么写才对呢？

DWORD percent = 0;

if (pos > 0) percent = 100 / (length / pos);

开始我以为这样写是很好的办法，结果试一试就知道25%->33%->50%->100%，分别是分母为4，3，2，1的结果，这也不是正确的写法。

看来，不加长字长是没什么好办法了。好在windows支持8字节大整数运算，所以这样写是对的：

DWORD percent = (DWORD)((ULONGLONG)pos * 100 / length);

两次转型，不过也确实没什么别的办法，如果没有8字节整数，与其自己写还真不如用浮点运算得了。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=495909

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=502902

VC++6.0下测试通过.

#include <iostream.h>
#include <math.h>

long mult(long x,long y,int n);
int num(long x);

void main() //主函数
{
 long x,y;
 cout<<"input x and y:"<<endl;
 cin>>x>>y;
 cout<<mult(x,y,num(x))<<endl;
}

long mult(long x,long y,int n)
{
 long a,b,c,d,s;
 if (n=1)
  return x*y;
 else
 {
  a=long(x/pow(10,(n/2))); //取x的左半部分
  b=long(x%long(pow(10,(n/2)))); //取x的右半部分
  c=long(y/pow(10,(n/2))); //取y的左半部分
  d=long(y%long(pow(10,(n/2)))); //取y的右半部分
  s=mult(a,c,n)*pow(2,n)+(mult((a-b),(d-c),n)+mult(a,c,n)+mult(b,d,n))*pow(2,n/2)+mult(b,d,n); //书上的公式
  return (s);
 }
}

int num(long x) //判断输入的数字的位数
{
 int i=0;
 if(x-9<=0)
  return 1;
 else
 {
  while (x!=0)
  {
   i++;
   x=x/10;
  }
  return i;
 }
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=505113

我们以单精度浮点数来说明：
指数是8位，可表达的范围是0到255
而对应的实际的指数是－127到＋128
这里特殊说明，－127和＋128这两个数据在IEEE当中是保留的用作多种用途的
－127表示的数字是0
128和其他位数组合表示多种意义，最典型的就是NAN状态

从存储结构和算法上来讲，double和float是一样的，不一样的地方仅仅是float是32位的，double是64位的，所以double能存储更高的精度

任何数据在内存中都是以二进制（1或着0）顺序存储的，每一个1或着0被称为1位，而在x86CPU上一个字节是8位。比如一个16位（2字节）的short int型变量的值是1156，那么它的二进制表达就是：00000100 10000100。由于Intel CPU的架构是Little Endian（请参数机算机原理相关知识），所以它是按字节倒序存储的，那么就因该是这样：10000100 00000100，这就是定点数1156在内存中的结构.

我们先不考虑逆序存储的问题，先按照顺序的来讲，最后再把他们翻过来就行了。

现在让我们按照IEEE浮点数表示法，一步步的将float型浮点数12345.0f转换为十六进制代码。在处理这种不带小数的浮点数时，直接将整数部转化为二进制表示：1 11100010 01000000也可以这样表示：11110001001000000.0然后将小数点向左移，一直移到离最高位只有1位，就是最高位的1：1.11100010010000000一共移动了16位，在布耳运算中小数点每向左移一位就等于在以2为底的科学计算法表示中指数+1，所以原数就等于这样：1.11100010010000000 * ( 2 ^ 16 )好了，现在我们要的尾数和指数都出来了。显而易见，最高位永远是1，因为你不可能把买了16个鸡蛋说成是买了0016个鸡蛋吧？（呵呵，可别拿你买的臭鸡蛋甩我~），所以这个1我们还有必要保留他吗？（众：没有！）好的，我们删掉他。这样尾数的二进制就变成了：11100010010000000最后在尾数的后面补0，一直到补够23位：11100010010000000000000（MD，这些个0差点没把我数的背过气去~）

再回来看指数，一共8位，可以表示范围是0 - 255的无符号整数，也可以表示-128 - 127的有符号整数。但因为指数是可以为负的，所以为了统一把十进制的整数化为二进制时，都先加上127，在这里，我们的16加上127后就变成了143，二进制表示为：10001111
12345.0f这个数是正的，所以符号位是0，那么我们按照前面讲的格式把它拼起来：
0 10001111 11100010010000000000000
01000111 11110001 00100000 00000000
再转化为16进制为：47 F1 20 00，最后把它翻过来，就成了：00 20 F1 47。

有了上面的基础后，下面我再举一个带小数的例子来看一下为什么会出现精度问题。
按照IEEE浮点数表示法，将float型浮点数123.456f转换为十六进制代码。对于这种带小数的就需要把整数部和小数部分开处理。整数部直接化二进制：100100011。小数部的处理比较麻烦一些，也不太好讲，可能反着讲效果好一点，比如有一个十进制纯小数0.57826，那么5是十分位，位阶是1/10；7是百分位，位阶是1/100；8是千分位，位阶是1/1000……，这些位阶分母的关系是10^1、10^2、10^3……，现假设每一位的序列是{S1、S2、S3、……、Sn}，在这里就是5、7、8、2、6，而这个纯小数就可以这样表示：n = S1 * ( 1 / ( 10 ^ 1 ) ) + S2 * ( 1 / ( 10 ^ 2 ) ) + S3 * ( 1 / ( 10 ^ 3 ) ) + …… + Sn * ( 1 / ( 10 ^ n ) )。把这个公式推广到b进制纯小数中就是这样：
n = S1 * ( 1 / ( b ^ 1 ) ) + S2 * ( 1 / ( b ^ 2 ) ) + S3 * ( 1 / ( b ^ 3 ) ) + …… + Sn * ( 1 / ( b ^ n ) )

天哪，可恶的数学，我怎么快成了数学老师了！没办法，为了广大编程爱好者的切身利益，喝口水继续！现在一个二进制纯小数比如0.100101011就应该比较好理解了，这个数的位阶序列就因该是1/(2^1)、1/(2^2)、1/(2^3)、1/(2^4)，即0.5、0.25、0.125、0.0625……。乘以S序列中的1或着0算出每一项再相加就可以得出原数了。现在你的基础知识因该足够了，再回过头来看0.45这个十进制纯小数，化为该如何表示呢？现在你动手算一下，最好不要先看到答案，这样对你理解有好处。

我想你已经迫不及待的想要看答案了，因为你发现这跟本算不出来！来看一下步骤：1 / 2 ^1位（为了方便，下面仅用2的指数来表示位），0.456小于位阶值0.5故为0；2位，0.456大于位阶值0.25，该位为1，并将0.45减去0.25得0.206进下一位；3位，0.206大于位阶值0.125，该位为1，并将0.206减去0.125得0.081进下一位；4位，0.081大于0.0625，为1，并将0.081减去0.0625得0.0185进下一位；5位0.0185小于0.03125，为0……问题出来了，即使超过尾数的最大长度23位也除不尽！这就是著名的浮点数精度问题了（浮点十进制值通常没有完全相同的二进制表示形式。这是 CPU 所采用的浮点数据表示形式的副作用。为此，可能会经历一些精度丢失，并且一些浮点运算可能会产生意外的结果。）。不过我在这里不是要给大家讲《数值计算》，用各种方法来提高计算精度，因为那太庞杂了，恐怕我讲上一年也理不清个头绪啊。我在这里就仅把浮点数表示法讲清楚便达到目的了。

OK，我们继续。嗯，刚说哪了？哦对对，那个数还没转完呢，反正最后一直求也求不尽，加上前面的整数部算够24位就行了：1111011.01110100101111001。某BC问：“不是23位吗？”我：“倒，不是说过了要把第一个1去掉吗？当然要加一位喽！”现在开始向左移小数点，大家和我一起移，众：“1、2、3……”好了，一共移了6位，6加上127得131（怎么跟教小学生似的？呵呵~），二进制表示为：10000101，符号位为……再……不说了，越说越啰嗦，大家自己看吧：
0  10000101  11101101110100101111001
42  F6  E9  79
79  E9  F6  42

下面再来讲如何将纯小数转化为十六进制。对于纯小数，比如0.0456，我们需要把他规格化，变为1.xxxx * （2 ^ n ）的型式，要求得纯小数X对应的n可用下面的公式：
n = int( 1 + log (2)X );

0.0456我们可以表示为1.4592乘以以2为底的-5次方的幂，即1.4592 * ( 2 ^ -5 )。转化为这样形式后，再按照上面第二个例子里的流程处理：
1. 01110101100011100010001
去掉第一个1
01110101100011100010001
-5 + 127 = 122
0  01111010  01110101100011100010001
最后：
11 C7 3A 3D

另外不得不提到的一点是0.0f对应的十六进制是00 00 00 00，记住就可以了。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=532155

BigInteger.h 包涵了对节点的结构定义,以及类BigInteger的定义.

BigInteger.cpp 包涵了BigInteger类里面成员函数的具体内容.

main.cpp 主函数...

//BigInteger.h

struct Node        //定义了节点的结构
{
 char Num;
 Node *Prev,*Next;
};

class BigInteger      //定义BigInteger 类
{
 Node *Head,*End,*TempNode;
 void AddHead(char Num);
 void AddEnd(char Num);
 public:
  BigInteger();
  BigInteger(const BigInteger &BigNum);
  void GetNumber();
  void disp();
  BigInteger operator + (const BigInteger &BigNum);
  BigInteger operator * (const BigInteger &BigNum);
  BigInteger operator = (const BigInteger &BigNum);
  ~BigInteger();
};

//BigInteger.cpp

#include <iostream.h>
#include <stdio.h>
#include "BigInteger.h"

BigInteger::BigInteger()        //构造函数,将每个节点置空.
{
 Head=End=TempNode=NULL;
}

BigInteger::BigInteger(const BigInteger &BigNum)     //拷贝构造
{
 Node *p;
 Head=End=TempNode=NULL;
 p=BigNum.Head;
 while(p)
 {
  AddEnd(p->Num);
  p=p->Next;
 }
}

BigInteger::~BigInteger()        //析构
{
 Node *NextNode;
 if(Head==NULL)
  return;
 TempNode=Head;
 while(TempNode)
 {
  NextNode=TempNode->Next;
  delete TempNode;
  TempNode=NextNode;
 }
 Head=NULL;
 End=NULL;
 TempNode=NULL;
}

void BigInteger::AddHead(char Num)        //在链表头插入节点的操作
{
 TempNode=new Node;
 TempNode->Num=Num;
 TempNode->Prev=NULL;
 if(!Head)
 {
  Head=End=TempNode;
  TempNode->Next=NULL;
 }
 else
 {
  TempNode->Next=Head;
  Head->Prev=TempNode;
  Head=TempNode;
 }
}

void BigInteger::AddEnd(char Num)       //在链表尾插入节点的操作
{
 TempNode=new Node;
 TempNode->Num=Num;
 TempNode->Next=NULL;
 if(!Head)
 {
  Head=End=TempNode;
  TempNode->Prev=NULL;
 }
 else
 {
  TempNode->Prev=End;
  End->Next=TempNode;
  End=TempNode;
 }
}

void BigInteger::GetNumber()            //输入部分
{
 char key;
 int count=0,num=0;
 while((key=getchar())!=10)            //判断输入的是否是回车,不是的话将内容从后到前放到链表中.
 {
  if(key>='0' && key<='9')
  {
   num=key-'0';
   AddEnd(num);
   num=0;
  }
 }
}

BigInteger BigInteger::operator + (const BigInteger &BigNum2)    //重载"+"
{
 BigInteger &BigNum1=*this,result;
 Node *temp1,*temp2;
 int TempNum,rest=0;
 temp1=BigNum1.End;            //将临时链表首地址放置到输入链表的尾部
 temp2=BigNum2.End;
 while(temp1 && temp2)
 {
  TempNum=int(temp1->Num)+int(temp2->Num)+rest;         //节点内元素相加并加上进位rest
  if(TempNum>9)                  //判断相加结果是否会产生进位.
  {
   TempNum=TempNum-10;
   rest=1;
  }
  else
   rest=0;
  result.AddHead(char(TempNum));          //将结果放置到最终结果链表里
  temp1=temp1->Prev;
  temp2=temp2->Prev;
 }
 if(temp2)temp1=temp2;
 while(temp1)
 {
  int(TempNum)=int(temp1->Num)+rest;           //节点内元素加上进位rest
  if(TempNum>9)
  {
   TempNum=TempNum-10;
   rest=1;
  }
  else
   rest=0;
  result.AddHead(char(TempNum));             //将结果放置到最终结果链表里
  temp1=temp1->Prev;
 }
 if(rest)
  result.AddHead(char(rest));                //考虑最后的进位是否存在,如果存在则存入链表的首部.
 return result;
}

BigInteger BigInteger::operator * (const BigInteger &BigNum2)     //对*进行重载
{
 BigInteger &BigNum1=*this,temp,result;
 Node *temp1,*temp2,*tempa,*tempb;
 int TempNum,rest,i=0,rest2;
 temp1=BigNum1.End;
 temp2=BigNum2.End;
 while(temp2)        //由乘数的存在与否判断是否去乘被乘数的每个位
 {
  rest=0;
  while(temp1!=NULL)
  {
   TempNum=int(temp1->Num)*int(temp2->Num)+rest;
   if(TempNum>9)
   { 
    rest=TempNum/10;                 //进位由相乘结果与10做商求得
    TempNum=TempNum%10;                 //由相乘结果与10求模取个位
   }
   else
    rest=0;
   temp.AddHead(char(TempNum));        //存入临时链表
   temp1=temp1->Prev;
  }
  if(rest!=0)temp.AddHead(char(rest));
  for(int k=i;k>=1;k--)temp.AddEnd(char(0));       //判断应该在链表后面补几个0
  i++;            //每次乘完后计数,用来下一次的补0
  temp1=BigNum1.End;             //把被乘数重新置到尾,用来让乘数下一次去乘每个元素
  temp2=temp2->Prev;              //将乘数取出链表的前驱
  tempa=result.End;                  //下面进行的是将每次乘数与被乘数的相乘结果累加放到最终链表里等待输出
  if(result.Head!=NULL)           //下面过程与"+"重载基本一样,只是多了对临时链表的置空,所以不在做详细的注释.
  {
   result.End=temp.Head;
   result.Head=NULL;
  }
  tempb=temp.End;
  rest2=0;
  while(tempa!=NULL && tempb!=NULL)
  {
   TempNum=int(tempa->Num)+int(tempb->Num)+rest2;
   if(TempNum>9)
   {
    TempNum=TempNum-10;
    rest2=1;
   }
   else
    rest2=0;
   result.AddHead(char(TempNum));
   tempa=tempa->Prev;
   tempb=tempb->Prev;
  }
  if(tempb)tempa=tempb;
  while(tempa)
  {
   int(TempNum)=int(tempa->Num)+rest2;
   if(TempNum>9)
   {
    TempNum=TempNum-10;
    rest2=1;
   }
   else
    rest2=0;
   result.AddHead(char(TempNum));
   tempa=tempa->Prev;
  }
  if(rest2)
   result.AddHead(char(rest2));
  if(temp.Head!=NULL)
  {
   temp.End=temp.Head;
   temp.Head=NULL;
  }
  tempb=NULL;
 }
 return result;
}

BigInteger BigInteger::operator = (const BigInteger &BigNum)          //对=号进行重载
{
 if(this==&BigNum)
  return *this;
 Node *p;
 TempNode=Head=End=NULL;
 p=BigNum.Head;
 while(p)
 {
  AddEnd(p->Num);
  p=p->Next;
 }
 return *this;
}

void BigInteger::disp()                    //输出链表
{
 if(Head)
 {
  cout<<int(Head->Num);
  TempNode=Head->Next;
 }
 else return;
 while(TempNode)
 {
  cout<<int(TempNode->Num);
  TempNode=TempNode->Next;
 }
 cout<<endl;
}

//main.cpp

#include <iostream.h>
#include "BigInteger.h"

void main()
{
 BigInteger BigNum1,BigNum2,BigNum3;
 int c;
 cout<<"选择你要进行的操作:"<<endl;
 cout<<"1.大整数加法运算"<<endl;
 cout<<"2.大整数乘法运算"<<endl;
 cout<<"选择你需要进行的运算:"<<endl;
 cin>>c;
 switch(c)
 {
  case 1:
   { 
    cout<<"A:"<<endl;
    BigNum1.GetNumber();
    cout<<"B:"<<endl;
    BigNum2.GetNumber();
    BigNum3=BigNum1+BigNum2;
    cout<<"相加的结果是:"<<endl;
    BigNum3.disp();
   }break;
  case 2:
   {
    cout<<"A:"<<endl;
    BigNum1.GetNumber();
    cout<<"B:"<<endl;
    BigNum2.GetNumber();
    BigNum3=BigNum1*BigNum2;
    cout<<"相乘的结果是:"<<endl;
    BigNum3.disp();
   }break;
  default:break;
 }
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=535558

这个问题是在1982年由Lamport, Shostak, Pease提出，后少人问津。为了利于对“拜占廷将军”问题原意的理解和避免曲解，把英文解释奉上：
　Byzantine General Problem ——The problem of reaching a consensus among distributed units if some of them give misleading answers. The original problem concerns generals plotting a coup. Some generals lie about whether they will support a particular plan and what other generals told them. What percentage of liars can a decision making algorithm tolerate and still correctly determine a consensus?

在1982年被提出的“拜占廷将军问题”在今天被许多学者看好，然而在商业上还没有体现其价值。特别是中国的产业界把它放在了一个被遗忘的角落。

　　拜占庭问题讲的是，几个将军围困一座城池，大家必须商量一种策略，是进攻还是撤退。如果有的进攻，有的撤退就有可能打败仗。但将军中有叛国的，他们可能希望爱国的将军打败仗。拜占廷将军问题就是阐述了在这样的环境下，如何让爱国的将军能在最终达成一致意见。判国的将军虽然可以传递了虚假消息，也不会影响爱国的将军得到正确的决策。

　　拜占廷将军问题就是要让爱国的将军达成一致，而不是找叛国的将军。我们的入侵容忍体系就是这样，只要在众多服务器上得到的正确的计算结果，，那么我们就可以相信这个数据，而不需要去寻找到底谁是间谍。如果要容忍一个捣乱的服务器，在数量上究竟会需要几个服务器？“拜占廷将军”问题可以为我们解答这个问题：在进行混乱真实消息的传播中，两个将军中一个判国，另一个肯定打败仗，三个将军中如果有一个判国，则判国的将军一定有办法让两个爱国的将军不能达成一致，若再增加一个将军，既4个将军中如果只有一个判国，在不知道谁是判国者的情况下，存在一种算法使将军们达成一致，实际上就是三个爱国的将军能够达成一致，而不管判国的将军如何捣乱。既4个将军的团体能够容忍1个叛国将军。同样我们知道，当有t个判国者在捣乱而又无法找出他们的时候，存在一种算法或称做弹性协议，通过这种协议，能够保证爱国的将军达成一致。如果我们把能够容忍t个叛国者的协议叫t弹性协议，学者证明了，不存在3t个将军下的t弹性协议而一定存在3t+1或以上将军下的t弹性协议。就是说要有3t+1个或以上将军才能保证爱国的将军能够达成一致。既要想容忍t个判国者，必须保证总的将军的个数大于3t。

　这样看来，“拜占廷将军”问题应用于信息安全就是入侵容忍体系的重要技术基础之一。以上讲述的仅仅是“拜占廷将军”问题中简化描述，加之以叙述的形式，就是一个描述性的推理，实际上“拜占廷将军”问题程序计算的方法是很复杂的