许式伟
2007-1-7
现在，有很多C/C++程序员总是自命不凡，看不起其他开发人员。其实，或许别人更看不起他呢!
>> 有偏见的永远只是个体，而不是群体。作者加了后面那句，无疑证明有偏见的不是C/C++程序员，而正是他自己。
学生时代，我也曾醉心于C/C++，但时至今日，始终无法写出无懈可击的C++代码，所以我始终认为我不会C/C++。这些年，我一直在寻找编写C++代码的最佳模式。但是，老实说，我还没有见到过哪个称得上高手的C++程序员，也没有见到过写得Very good的C/C++代码。C/C++代码总是丑陋不堪，BUG丛生!
>> 这段话更加荒谬了。没见过优秀的C/C++代码？ C++标准库（STL）如此优雅。况且，有那么多经典的C/C++开源作品，以及无意之中泄漏的Windows NT核心源码，哪一样不是绝世之作？我为作者浅陋感到难过。
我用C语言编程已经超过20年了。我写过C语言的编译器、C语言的调试器、用C开发的其他语言、游戏、客户端程序和服务器程序，你说吧!还有什么是我没写过的。还有我的书架上充斥着折了角的K&R和Steele的书。我太了解C语言了，但是，我讨厌他。十分讨厌!
当我读到一篇博客，题目是"为什么每个程序员都应该学习C语言?"时，我真是鸡皮疙瘩满地。如果你真的是个专业的程序员的话，你肯定觉得这是个天大的笑话，尽管作者的本意也许不是这样的。这篇反驳的文章有点意思，但是还是没有抓住本质。所以我展开了说一下。有以下5个原因来说明，为什么那些会C语言，并且使用C语言的程序员，现在不但应该去用别的语言，而且应该忘记他们学习C语言过程中的那些烦人的东西。
1、内存分配
仅仅关于这一点我就能写整整一篇文章了，也许能写一本书，甚至还有可能写出能够塞满图书馆技术书籍那块，那么多的内容。内存分配和存储单元分配的存在确确实实是个大麻烦。你要不就是分配太少的内存不够用，要不就是分配了太多内存浪费掉。这里的问题就是：怎么把它初始化为零呢?还是干脆就不初始化它。但最挠头的步骤还是释放内存。所有已有的工具包都会帮助你确认，你是否已经释放了之前分配的每一位的内存，在释放完之后是否永远不使用它，并且会阻止你，永远不要释放它第两次。更严重的是，分配内存和释放内存在C语言中都是很慢的，非常慢。使用内存分配时，要考虑的各种特殊情况，我真是连想都不愿意去想，只要问题(对象)的大小合适，我更愿意使用栈空间或者事先分配的结构空间。如果这么做的话，我就有更值得烦恼的事了。话说回来，发明垃圾处理器那人真应该得诺贝尔奖。
>> 内存管理是程序设计中最经典的话题。GC无疑是内存管理一个伟大的变革，但是我只是把它看作内存管理的一个解决方案，而认为不是唯一的解决方案。比GC更加优雅的方案不见得没有。我比较倾向于在特定的情况下选择合适的内存管理方案，而不是没有任何选择的余地，而这正是C/C++的伟大之处。 所有那些GC语言（如Java、C#等）均把这个解决方案强加给程序员，这一定程度上来说减轻了程序员的负担，但是也同时约束了程序员的主观能动性。"分配内存和释放内存在C语言中都是很慢的"？不知道作者从哪里获得的结论。
2、多线程
我过去是喜欢C语言的，真的。直到我开始用C开发并维护多线程的服务器。在为连接相冲突的线程保护数据方面，C语言没有为程序员提供那怕一点点的帮助。你在使用单线程的日子里获得的每一个直觉、经验，用在多线程的时候都是错误的。至少JAVA有表示同步的关键字和备有证明文件(但是是个很奇怪的文件)的记忆体，但即使是这样，除非你使用新的javax.concurrent，否则也只能在那些巨大的平行摆放的机器们面前崩溃。回到C语言上：在模拟生产的环境下，坚持一个星期在数据中心调试一个死锁(这事真的发生过)。而JAVA却只需要Ctrl+Break!天哪!!!
>> C/C++语言本身确实没有太多MultiThead的支持，这种情况在C++0x出来后可望改变。但是，请记住C/C++永远倾向于你使用成熟的库来解决问题。
3、指针
指针太难以控制了，太阴险了;我甚至没有委婉一点的方式去形容它。我生命中每年都有几个月被用来调试那些奇怪的指针问题。我过去常常努力获取所有的诀窍，比方说难以理解的构成符、联合体和偏移量，以及重用最后两位做标记，还有所有其他的诀窍。但我发现这么做根本不值得。其他语言的静态引用就可以解决了。
>> 指针是C/C++过于灵活的体现。使用指针的代码可以写得很丑陋，但一样可以很优雅。——这一点上用何种语言不会有区别。我相信，可以写出优雅的Java代码，那么也一定可以写出同样优雅的C/C++代码。而反之则未必（因为有些C++某些范式是Java所不能支持的）。C/C++语言中的选择太多，这的确是令人困惑的，但不见得是劣势。我对C/C++程序员的建议是，多了解和使用C++标准库，而不是过于纠缠指针相关的细节。
4、过早的优化
说到诀窍，你是否曾经浪费脑细胞去研究究竟*p++是不是比p[i]快?你是否曾经花时间去试着做点变化来代替乘法，或者去尝试使循环中的倒置运行更快的方法?还在为传递一个参数的速度和反对添加结构，并且传递它的速度一样而苦恼不已?停吧!算法是速度的关键，程序员的水平决定了他会使用那些算法。知道这一点能让你的程序更好，更快一点并且让你的脑袋少扭几个筋。好吧，有一些例子也许可以这样做的……不，你就别那么做就行了!
>> 算法优化是程序设计的关键。但是通常情况下，所有语言（包括C/C++）的程序员研究的是关键路径的优化。研究*p++是不是比p[i]快？我相信这是标准库的实现者要考虑的事情。所不同的是，C/C++程序员也可以和标准库的作者一样去考虑这些细节，而其他语言的程序员被剥夺了这个权利。
说到优化，话题就多了。我曾经向C#的Dictionary中插入了1亿条整数（从1万多个文本文件中读入），结果发现程序运行了整整一个下午仍然没有完成。而我改用C++的std::map，20分钟就搞定了。再试试对50万条自定义的结构体数据进行排序，我相信你和我一样，会深深喜欢上C++的的高效而优雅。
5、测试
你最喜欢的C的单元测试的工具是哪个?嗯…一个也想不到?单元测试一定是一点也不重要，是吧?或者是太麻烦了，很难跟上进度，浪费时间。你可以把这个时间用到更加有用的事情上，让它只占用工作时间的1%，那还比较合适。或者在数据中心，通过优化的没有标记的图形来调试这个仅仅由100个同时在线使用者引起的问题。
>> C++的测试工具，作者居然一个都想不到，我只能猜想可能他是比较喜欢自己制造轮子的那一类。和JUnit对应的CppUnit，难道也想不到？提起CppUnit，我以前用它进行单元测试，但从实现架构上说，我认为它继承了Java代码的臃肿。我在WINX中提供了一个Mini版本的CppUnit，代码量大概只有几百行，功能绝不比CppUnit弱。（要了解WINX，请看这里）。
我本来应该继续再说一些原因的，但是5个现在就足够了;说完这些，现在感觉好点了。C以前是非常棒的…那是在1984年的时候。直到今天，那些用C写的新代码都让我感到惊喜…如果你让我比较的话，我觉得C++只是比C稍微好点。如果你想要学些老一点的语言，不妨尝试Forth，List，或者APL。这些老式的语言起码能教会你，用不同的而且优雅的方式去思考你的程序。
>> 新生的语言，必然会在吸收旧的语言上基础上进行改进。看一个语言的生命力，并不在于看它某些地方存在的不足。事物会发展，并趋于完善。相信C++0x出来后，C/C++语言又将获得新的生命力。单看Java、C#等几个新一代的语言，其中有如此多的C++烙印，就证明了C/C++的影响是巨大的。动不动说一门语言死了，是一种浅薄。
===========================================================================================
虽然C/C++对一般人而言的确是比较难以驾驭，但是它的威力是无人可以否认的。非常期待C++0x标准的出台。
那些说C语言已死的人只能表明他的无知和肤浅。
有道理
这说明你会用C#而已。
哪些是基于其它语言的。
是死是活，不言自明
那篇文章的作者我觉得很NB的，你看他文章提到的他采用的一些手法，都是高级人员才会去采用的。
“C语言已经死了”，你写了20年的C，对编程的认识还在这么低的层次上，不知道该怎么评价。
许式伟老兄，你也不必逐点反驳他。这些问题的关键不是在于用哪种语言，而是在于哪种解决方案更适合用户。
一点浅见，见笑了。
你错了!
虽然的确是两门语言,但又是相辅相成,紧密联系的.
C依靠C++向程序上层发展.
C++通过C以很自然的方式接触底层,发挥效率.
說實在，寫“C语言已经死了”的人很明顯是個菜鳥，以他那水平，根本不足評論這些～～
我個人很少用C。
C++之父B. Stroustrup近期言论 翻译者 : myan 出处: http://www.research.att.com/~bs/
(Part of)
I think I needn't say more, enough
2. 学习C++要花多长时间？
这要看你说的“学习”是什么意思了。如果你是一个Pascal程序员，你应该能很快地使你的C++水平达到与Pascal相近的程度；而如果你是一个C程序员，一天之内你就能学会使用C++进行更出色的C风格编程。另一方面，如果你想完全掌握C++的主要机制，例如数据抽象，面向对象编程，通用编程，面向对象设计等等，而此前又对这些东西不很熟悉的话，花上个一两年是不足为奇的。 那么是不是说这就是学习C++所需要的时间呢？也许再翻一番，我想打算成为更出色的设计师和程序员最起码也要这么长的时间。如果学习一种新的语言不能使我们的工作和思想方式发生深刻的变革，那又何苦来哉？跟成为一个钢琴家或者熟练掌握一门外语相比，学习一种新的、不同的语言和编程风格还算是简单的。
3. 了解C是学习C++的先决条件吗？
否！C++中与C相近的子集其实比C语言本身要好学，类型方面的错误会少一些，也不像C那样绕圈子，还有更好的支持库。所以应该从这个子集开始学习C++。
10. 如果不必和C兼容，你所创造的语言是不是就会是Java?
不是，差得远。如果人们非要拿C++和Java来作比较，我建议他们去阅读The Design and Evolution of C++，看看C++为什么是今天这个样子，用我在设计C++时遵从的原则来检验这两种语言。这些原则与SUN的Java开发小组所持的理念显然是不同的。除了表面语法的相似性之外，C++与Java是截然不同的语言。在很多方面，Java更像Smalltalk(译者按：我学习Java时用的是Sun的培训教材，里面清楚地写道：Java在设计上采用了与C++相似的语法，与Sm alltalk相似的语义。所以可以说Java与C++是貌合神离，与Smalltalk才是心有灵犀)。Java语言相对简单，这部分是一种错觉，部分是因为这种语言还不完整。随着时间的推移，Java在体积和复杂程度上都会大大增长。在体积上它会增长两到三倍，而且会出现一些实现相关的扩展或者库。这是一条每个成功的商业语言都必须走过的发展之路。随便分析一种你认为在很大范 围内取得了成功的语言，我知道肯定是无有例外者，而且实际上这非常有道理。
上边这段话是在Java 1.1推出之前写的。我确信Java需要类似模板的机制，并且需要增强对于固有类型的支持。简单地说，就是为了基本的完整性也应该做这些工作。另外还需要做很多小的改动，大部分是扩展。1998年秋，我从James Gosling(Java语言的创始人——译者)那里得到一份建议书，说是要在Java中增加固有类型、操作符重载以及数学计算支持。还有一篇论文，是数学分析领域的世界级大师，伯克利大学的W. Kahan教授所写的How Java’s Floating-Point Hurts Everyone Everywhere(“且看Java的浮点运算如何危害了普天下的芸芸众生”——译者)，揭露了Java的一些秘密。我发现在电视和出版物中关于Java的鼓吹是不准确的，而且气势汹汹，让人讨厌。大肆叫嚣凡是非Java的代码都是垃圾，这是对程序员的侮辱；建议把所有的保留代码都用Java重写，这是丧心病狂，既不现实也不负责任。Sun和他的追随者似乎觉得为了对付微软罪恶的“帝国时代”，就必须如此自吹自擂。但是侮辱和欺诈只会把那些喜欢使用不同编程语言的程序员逼到微软阵营里去。
Java并非平台无关，它本身就是平台。跟Windows一样，它也是一个专有的商业平台。也就是说，你可以为Windows/Intel编写代码，也可以为Java/JVM编写代码，在任何一种情况下，你都是在为一个属于某个公司的平台写代码，这些代码都是与该公司的商业利益扯在一起的。当然你可以使用任何一种语言，结合操作系统的机制来编写可供JVM执行的程序，但是JVM之 类的东西是强烈地偏向于Java语言的。它一点也不像是通用的、公平的、语言中立的VM/OS。私下里，我会坚持使用可移植的C++作大部分工作，用不同的语言作余下的工作。
(”Java is not platform-independent, it is the platform”，B. S的这句评语对于C++用户有着很大的影响，译者在国外的几个新闻组里看到，有些C++高手甚至把这句话作为自己的签名档，以表明对Java的态度和誓死捍卫C++的决心。实际上有很多程序员不光是把自己喜爱的语言当成一种工具，更当成一种信仰。——译者)
11. 您怎么看待C#语言？
就C#语言本身我没什么好说的。想让我相信这个世界还需要另外一个专有的语言可不是一件容易的事，而且这个语言还是专门针对某一个专有操作系统的，这就更让我难以接受。直截了当地说，我不是一个专有语言的痴迷者，而是一个开放的正式标准的拥护者。
13. 你愿不愿意将C++与别的语言比较？
抱歉，我不愿意。你可以在The Design and Evolution of C++的介绍性文字里找到原因。
有不少书评家邀请我把C++与其它的语言相比，我已经决定不做此类事情。在此我想重申一个我很久以来一直强调的观点：语言之间的比较没什么意义，更不公平。主流语言之间的合理比较要耗费很大的精力，多数人不会愿意付出这么大的代价。另外还需要在广泛的应用领域有充分经验，保持一种不偏不倚、客观独立的立场，有着公正无私的信念。我没时间，而且作为C++的创造者，在公正无私这一点 上我永远不会获得完全的信任。
人们试图把各种语言拿来比较长短，有些现象我已经一次又一次地注意到，坦率地说我感到担忧。作者们尽力表现的公正无私，但是最终都是无可救药地偏向于某一种特定的应用程序，某一种特定的编程风格，或者某一种特定的程序员文化。更糟的是，当某一种语言明显地比另一种语言更出名时，一些不易察觉的偷梁换柱就开始了：比较有名的语言中的缺陷被有意淡化，而且被拐弯抹角地加以掩饰；而同样 的缺陷在不那么出名的语言里就被描述为致命硬伤。类似的，有关比较出名的语言的技术资料经常更新，而不太出名的语言的技术资料往往是几年以前的，试问这种比较有何公正性和意义可言？所以我对于C++之外的语言的评论严格限制在一般性的特别特定的范畴里。
换言之，我认为C++是大多数人开发大部分应用程序时的最佳选择。
14. 别人可是经常拿他们的语言与C++比来比去，这让你感到不自在了吗？
当这些比较不完整或者出于商业目的时，我确实感觉不爽。那些散布最广的比较性评论大多是由某种语言，比方说Z语言的拥护者发表的，其目的是为了证明Z比其它的语言好。由于C++被广泛地使用，所以C++通常成了黑名单上的头一个名字。通常，这类文章被夹在Z语言的供货商提供的产品之中，成了其市场竞争的一个手段。令人震惊的是，相当多的此类评论引用那些在开发Z语言的公司中工作的 雇员的文章，而这些经不起考验文章无非是想证明Z是最好的。特别是在这些比较中确实有一些零零散散的事实，(所以更具欺骗性——译者)，毕竟没有一种语言在任何情况下都是最好的。C++当然不完美，不过请注意，特意选择出来的事实虽然好像正确，但有时是完全的误导。
以后再看到语言比较方面的文章时，请留心是谁写的，他的表述是不是以事实为依据，以公正为准绳，特别是评判的标准是不是对于所引述的每一种语言来说都公平合理。这可不容易做到。
19. 您看C++未来的走向如何？在接下来的10年里它会衰落吗？或者是基本保持现在的形式？或者发展变化呈不同的形式？
C++有着最美好的未来。用它你能写出伟大的代码。除了故意进行恶意欺诈，C++仍将是开发高性能、高复杂度系统的最好语言。据我所知，没有那种语言能在通用性、效率和精致三方面的统一上可与C++相题并论。
我没看到C++有衰落的征兆。在我能预见的未来里，它的用途还会不断增长。当然，在未来的十年里我们会看到一些变化，但不会像你想得那么显著。跟每一种语言一样，C++也会发展变化。“语言专家们”要求改进的喧嚣声震耳欲聋，但是系统开发者们的基本请求是保持稳定。
C++会改进，但是这些改进将主要是为了反映从实践中得来的经验教训，而不会是为了追风尚赶时髦。为了更高效地使用一些新的编程技术，比如通用编程技术，可能会增加一些小的特性。会有大量的库涌现，我预期会出现一种崭新的、更出色的库支持机制。我希望新的扩展主要集中在支持抽象方面的一般特性，而不是为支持某些特殊任务的特定机制。
例如，“属性”这个概念是很有用的，但我不认为在一种通用编程语言中有它的容身之地。用标准C++的一组类可以很容易地支持这一概念。如果我们感觉那族类对于“属性”这一概念的支持不尽如人意，也不会立刻跑去在语言里增加属性机制，而是仔细考虑如何改进类和模板以帮助库设计人员尽可能接近“属性”这个概念。也许通过改进函数对象的机制能够给这个问题一个满意的答复。
为了使C++在接下来的十几年中保持灵活可变，很基本的一点就是不要让标准C++赶什么学术或者商业的时髦。人们要求增加的特性中很大一部分通过使用现有的标准C++开发新库的方式都可以实现。还有，事实上人们渴望得到的很多特性已经被包括在标准C++中，并且被最新的编译器支持。对许多程序员来说，提高代码质量的最佳途径不是追求什么语言扩展，而是好好地、慢慢地品味最新的C++技术书籍(可惜我们到目前为止连这种机会都没有——译者)。
23. 在不少流行领域，C++正在渐渐失去光芒，因为它要求人们花很大的精力去对付一些很基本的工作，比如管理内存(因为没有垃圾收集机制)，管理模块之间的依赖性(因为没有包机制)，管理组件的版本。C++缺乏一些现代语言已经视为标准的特性。比如传言中最酷的Java语言就特别重视这些问题。那么在解决这些问题是否会导致C++的发展背离其根本宗旨呢？C++应该怎样发展以保证我们在这种语言上的投资能有合理的回报，而不是被迫去重新使用另一种语言？
我倒还没有注意到C++比以前用的少了。相反，我看到的指标表明C+的使用还在稳定地增长着。只不过这种基数很大的稳定增长以及在标准性、移植性和库方面的不断提高并没有造成什么具有欺骗性的新闻效应而已。我认为你所说的“失去光芒”只不过是市场推销和新闻意义上的现象。
如果你需要垃圾收集机制的话，你可以在C++应用程序中插入一个垃圾收集器。有不少自由的和商业的垃圾收集器已经在重要的实践中被证明是很出色的。
如果你不想使用垃圾收集机制，也没关系。你可以使用标准容器类，它们大大减少了对于显式分配和回收内存的需要。这样，使用现代的库和现代的编程风格，你能够避免大部分的内存管理问题。
同样的技术还能够用来避免一般资源的管理问题。并不是只有内存才会泄漏，线程句柄、文件、互斥锁、网络连接等都是重要的资源，为了建立可靠的系统，这些资源必须被正确的管理。如果你觉得有了垃圾收集机制就可以解决所有的资源管理问题，那么你最好赶快从美梦中醒来。
C++提供了很多机制来管理一般性的资源。关键的手段——“获取资源就是初始化”——可以使用函数对象来管理生存期问题。语言中关于对象的局部构造和异常机制对这项技术提供了支持。
某些语言的狂热支持者总是用讽刺漫画的笔法描述C++，然而C++实际上要好得多。特别是我觉得很多其他的特性已经泛滥不堪了，在C++中，通常这些特性能够很容易的被模拟出来。相反的，新的语言在推广的过程中总是不断地增加新的特性，这就是为什么从一种语言诞生到被广泛使用，其体积通常会增加个两三倍。目前，最为个人和组织，对于C++的最好投资就是去更好地理解标准C++和现 代的C++设计编程技术。大多数人使用C++的方式实际上停留80年代中期的水平，甚至比那更陈旧。
至于模块依赖性问题，我的观点是，在编程语言的工作和系统的工作之间应该有一个明显的界线，依赖关系应该尽可能地与编程语言分开，而由系统来支持。
我不认为组建版本的问题应该由编程语言来解决，这是一个系统范畴里的问题，在语言里应该通过提供相应的库来解决。C++有这样的机制。解决这样的问题不会使C++偏离轨道。但是给C++增加很多特殊的特性就会使C++偏离轨道，而且在保持可移植性和平台独立性方面也会是一个倒退。
24. 标准C++推出有段时间了，Java也大踏步地往前走而且取得了显著的进步，您现在怎么比较Java与C++？您觉得Java想要变成像C++一样“好”的语言还需要做些什么？您举的C++从Java身上学到了什么经验吗？有没有什么Java的特性您认为是可以被C++吸纳的？
我不比较语言。做好这项工作是十分困难的，而且很少具有专业水准。我认为C++的进步会是主要以它的用户在使用中遇到的问题以及其自身逻辑为基础。当然，其他语言中的某些思想也会被考虑，但不能被简单的移花接木过来。你必须审视那些
机制在技术上和思想上的背景，并且找到在C++中支持这些技术的最佳方案。
有时最好的选择是综合使用几种语言。毕竟没有任何一种语言是放之四海而皆优的。C++现在是，将来也继续会是在广泛应用领域中最好的语言之一。但是，我们不能被拉下水，不能把所有可能的特性都加到C++里面来向大众献媚。我认为Java和C++现在和将来都会是十分不同的语言，语法相似，但背后的对象模型明显不同。
对于我来说，一个很重要的区别是C++有一个ISO标准，而Java则是一个专有语言。
25. 在Java刚刚出现的那几年，有很多欺骗性的言论说它将会是终极语言，会取代C++。您觉得在过去两三年里Java对C++的追随者们有什么影响？
到现在关于Java的不实之辞也还随处可见。暂且不提Java在过去5年间的创纪录的发展，狂热的大众似乎认为Java将最终取代的不仅仅是C++，而且还有所有其他的编程语言。但在另一方面，C++的使用仍在继续增长。我不认为Java对于C++的影响已经使得人们转而把本来打算用来创造更好的C++工具库的资源调过去开发Java工具库。Java对于学习编程的人来说没有太多的新东西，所以对于C++的定义也没什么影响。在那个领域，Java还得努力追赶。例如，我认为为Sun迟早会往Java里加入类似模板的机制。
人们应该认识到C++和Java的目标是何等的不同。 以C++的设计理念来衡量Java，或是以Java的设计理念来衡量C++，得出的结论都不会很好。
在访谈即将结束时，或许我该再次表明态度：C++仍然是我喜爱的语言，在写代码时你会发现没有那种语言能像它那样在如此广泛的应用领域和平台上同时达成如此的高效与精致。
我过去是喜欢C语言的，真的。直到我开始用C开发并维护多线程的服务器
=================
原作者都用C编程20年了，20年后才遇到多线程？
也太操蛋了吧。
自己都矛盾，还说c语言呢。
建议大家读一下“exception c++”。也给大家一个题目：
int func1(int val, int val2)
{
printf("%d", val / val2);
return val / val2;
}
这个程序有几个出口？
建议大家读一下“exception c++”。也给大家一个题目：
int func1(int val, int val2)
{
printf("%d", val / val2);
return val / val2;
}
这个程序有几个出口？
{
printf("%d", val / val2);
return val / val2;
}
这个程序有几个出口？
这种问题对于其它语言同样存在，如：
sub abc()
c = sqrt(-1)
a = c
end sub
同样有几个出口？
喜欢看大家的争论,在争论中,可以学习到很多~
1> 顶楼主啊~
2> 现在开发语言的发展追求的是开发效率~或者说现在编程的商业味道越来越浓，也就越来越 也就越来越脱离编程中那类似于艺术的东西~所以越来越多的人放弃了c
3> 如果你是个谋生者，C确实有点苍老，Java,C#确实你是不错的选择，但如果你把自己当作一个程序员，当作一个编程的而不是一个赚钱的来说，C，绝对是你不能放弃的~
但不可否认的是,会用的人始终是少的
大多数时候,因为某些同志对C的操作水准有限,害得其他人寝食难安
现在C的应用走过了几十年,问题不是"你说吧,有什么程序我没编过"
而是
"你说吧,有什么C程序世界上没人编过"
太多重复建设,太多辛苦重来了,C不是一个高开发效率的语言
全文请看
http://blog.csdn.net/Analyst/archive/2007/01/08/1476994.aspx
请问反过来可以吗？
java 的虚拟机 .net框架又是拿什么写的呢？
没了c/c++,java和.net在哪儿？
儿子厉害了就说老子死了？
无稽之谈
以上发言的高手们，你们靠什么生活呢，生活的好么？敢问都用什么语言？平时都搞啥研究？
http://www.ibm.com/developerworks/cn/java/j-jtp09275.html
分配比想像的要快，而且会变得更快
Brian Goetz, 首席顾问, Quiotix
2005 年 10 月 20 日
Java™ 语言遭到许多性能方面的攻击。虽然有些攻击可能是名符其实的，但是看看公告板和新闻组上关于这一主题的贴子，可以发现，对于 Java 虚拟机（JVM）实际的工作方式存在许多误解。在本月的 Java 理论与实践 中，Brian Goetz 驳斥了反复重复的有关 JVM 分配慢的传言。请与作者和其他读者在配套的 讨论组 上分享您对这篇文章的想法。（也可以点击文章顶部或底部的 讨论 来访问讨论组。）
流行问题：哪种语言的原始分配性能更快，Java 语言还是 C/C++？答案可能令人惊讶 —— 现代 JVM 中的分配比执行得最好的 malloc 实现还要快得多。HotSpot 1.4.2 之后虚拟机中的 new Object() 常见代码路径最多 10 条机器指令（Sun 提供的数据；请参阅 参考资料），而用 C 语言实现的执行得最好的 malloc 实现，每个调用平均要求的指令在 60 到 100 条之间（Detlefs 等；请参阅 参考资料）。而且分配性能在整体性能中不是一个微不足道的部分，测评显示：对于许多实际的 C 和 C++ 程序（例如 Perl 和 Ghostscript），整体执行时间中的 20% 到 30% 都花在 malloc 和 free 上，远远多于健康的 Java 应用程序在分配和垃圾收集上的开销（Zorn；请参阅 参考资料）。
继续，弄得一团糟
没有必要搜索众多的 blog 或 Slashdot 贴子，去寻找像“垃圾收集永远不会像直接内存管理一样有效”这样能够说服人的陈述。而且，从某个方面来说，这些话说的是对的 —— 动态内存管理并不一样快 —— 而是快得多。malloc/free 技术一次处理一个内存块，而垃圾收集机制则采用大批量方式处理内存管理，从而形成更多的优化机会（以一些可以预见到的损失为代价）。
这条“听起来有理的意见” （以大批量清理垃圾要比一天到晚一点点儿清理垃圾更容易）得到了数据的证实。一项研究（Zorn; 请参阅 参考资料）测量了在许多常见 C++ 应用程序中，用保守的 Boehm-Demers-Weiser（BDW）替换 malloc 的效果，结果是：许多程序在采用垃圾收集而不是传统的分配器运行时，表现出了速度提升。（BDW 是个保守的、不移动的垃圾收集器，严重地限制了对分配和回收进行优化的能力，也限制了改善内存位置的能力；像 JVM 中使用的那些精确的浮动收集器可以做得更好。）
在 JVM 中的分配并不总是这么快，早期 JVM 的分配和垃圾收集性能实际上很差，这当然就是 JVM 分配慢这一说法的起源。在非常早的时候，我们看到过许多“分配慢”的意见 —— 因为就像早期 JVM 中的一切一样，它确实慢 —— 而性能顾问提供了许多避免分配的技巧，例如对象池。（公共服务声明：除了对最重量的对象之外，对象池现在对于所有对象都是严重的性能损失，而且要在不造成并发瓶颈的情况下使用对象池也很需要技巧。）但是，从 JDK 1.0 开始已经发生了许多变化；JDK 1.2 中引入的分代收集器（generational collector）支持简单得多的分配方式，可以极大地提高性能。
分代垃圾收集
分代垃圾收集器把堆分成多代；多数 JVM 使用两代，“年轻代”和“年老代”。对象在年轻代中分配；如果它们在一定数量的垃圾收集之后仍然存在，就被当作是”长寿的“，并晋升到年老代。
HotSpot 提供了使用三个年轻代收集器的选择（串行拷贝、并行拷贝和并行清理），它们都采用“拷贝”收集器的形式，有几个重要的公共特征。拷贝收集器把内存空间从中间分成两半，每次只使用一半。开始时，使用中的一半构成了可用内存的一个大块；分配器满足分配请求时，返回它没有使用的空间的前 N 个字节，并把指针（分隔“使用”部分）从“自由”部分移动过来，如清单 1 的伪代码所示。当使用的那一半用满时，垃圾收集器把所有活动对象（不是垃圾的那些对象）拷贝到另一半的底部（把堆压缩成连续的），然后从另一半开始分配。
清单 1. 在存在拷贝收集器的情况下，分配器的行为
void *malloc(int n) {
if (heapTop - heapStart < n)
doGarbageCollection();
void *wasStart = heapStart;
heapStart += n;
return wasStart;
}
从这个伪代码可以看出为什么拷贝收集器可以实现这么快的分配 —— 分配新对象只是检查在堆中是否还有足够的剩余空间，如果还有，就移动指针。不需要搜索自由列表、最佳匹配、第一匹配、lookaside 列表 ，只要从堆中取出前 N 个字节，就成功了。
如何回收？
但是分配仅仅是内存管理的一半，回收是另一半。对于多数对象来说，直接垃圾收集的成本为零。这是因为，拷贝收集器不需要访问或拷贝死对象，只处理活动对象。所以在分配之后很快就变成垃圾的对象，不会造成收集周期的工作量。
在典型的面向对象程序中，绝大多数对象（根据不同的研究，在 92% 到 98% 之间）“死于年轻”，这意味着它们在分配之后，通常在下一次垃圾收集之前，很快就变成垃圾。（这个属性叫作 分代假设，对于许多面向对象语言已经得到实际测试，证明为真。）所以，不仅分配要快，对于多数对象来说，回收也要自由。
线程本地分配
如果分配器完全像 清单 1 所示的那样实现，那么共享的 heapStart 字段会迅速变成显著的并发瓶颈，因为每个分配都要取得保护这个字段的锁。为了避免这个问题，多数 JVM 采用了 线程本地分配块，这时每个线程都从堆中分配一个更大的内存块，然后顺序地用这个线程本地块为小的分配请求提供服务。所以，线程花在获得共享堆锁的大量时间被大大减少，从而提高了并发性。（在传统的 malloc 实现的情况下要解决这个问题更困难，成本更高；把线程支持和垃圾收集都构建进平台促进了这类协作。）
回页首
堆栈分配
C++ 向程序员提供了在堆或堆栈中分配对象的选择。基于堆栈的分配更有效：分配更便宜，回收成本真正为零，而且语言提供了隔离对象生命周期的帮助，减少了忘记释放对象的风险。另一方面，在 C++ 中，在发布或共享基于堆栈的对象的引用时，必须非常小心，因为在堆栈帧整理时，基于堆栈的对象会被自动释放，从而造成孤悬的指针。
基于堆栈的分配的另一个优势是它对高速缓存更加友好。在现代的处理器上，缓存遗漏的成本非常显著，所以如果语言和运行时能够帮助程序实现更好的数据位置，就会提高性能。堆栈的顶部通常在高速缓存中是“热”的，而堆的顶部通常是“冷”的（因为从这部分内存使用之后可能过了很长时间）。所以，在堆上分配对象，比起在堆栈上分配对象，会带来更多缓存遗漏。
更糟的是，在堆上分配对象时，缓存遗漏还有一个特别讨厌的内存交互。在从堆中分配内存时，不管上次使用内存之后留下了什么内容，内存中的内容都被当作垃圾。如果在堆的顶部分配的内存块不在缓存中，执行会在内存内容装入缓存的过程中出现延迟。然后，还要用 0 或其他初始值覆盖掉刚刚费时费力装入缓存的那些值，从而造成大量内存活动的浪费。（有些处理器，例如 Azul 的 Vega，包含加速堆分配的硬件支持。）
escape 分析
Java 语句没有提供任何明确地在堆栈上分配对象的方式，但是这个事实并不影响 JVM 仍然可以在适当的地方使用堆栈分配。JVM 可以使用叫作 escape 分析 的技术，通过这项技术，JVM 可以发现某些对象在它们的整个生命周期中都限制在单一线程内，还会发现这个生命周期绑定到指定堆栈帧的生命周期上。这样的对象可以安全地在堆栈上而不是在堆上分配。更好的是，对于小型对象，JVM 可以把分配工作完全优化掉，只把对象的字段放入寄存器。
清单 2 显示了一个可以用 escape 分析把堆分配优化掉的示例。Component.getLocation() 方法对组件的位置做了一个保护性的拷贝，这样调用者就无法在不经意间改变组件的实际位置。先调用 getDistanceFrom() 得到另一个组件的位置，其中包括对象的分配，然后用 getLocation() 返回的 Point 的 x 和 y 字段计算两个组件之间的距离。
清单 2. 返回复合值的典型的保护性拷贝方式
public class Point {
private int x, y;
public Point(int x, int y) {
this.x = x; this.y = y;
}
public Point(Point p) { this(p.x, p.y); }
public int getX() { return x; }
public int getY() { return y; }
}
public class Component {
private Point location;
public Point getLocation() { return new Point(location); }
public double getDistanceFrom(Component other) {
Point otherLocation = other.getLocation();
int deltaX = otherLocation.getX() - location.getX();
int deltaY = otherLocation.getY() - location.getY();
return Math.sqrt(deltaX*deltaX + deltaY*deltaY);
}
}
getLocation() 方法不知道它的调用者要如何处理它返回的 Point；有可能得到一个指向 Point 的引用，比如把它放在集合中，所以 getLocation() 采用了保护性的编码方式。但是，在这个示例中，getDistanceFrom() 并不会这么做，它只会使用 Point 很短的时间，然后释放它，这看起来像是对完美对象的浪费。
聪明的 JVM 会看出将要进行的工作，并把保护性拷贝的分配优化掉。首先，对 getLocation() 的调用会变成内联的，对 getX() 和 getY() 的调用也同样处理，从而导致 getDistanceFrom() 的表现会像清单 3 一样有效。
清单 3. 伪代码描述了把内联优化应用到 getDistanceFrom() 的结果
public double getDistanceFrom(Component other) {
Point otherLocation = new Point(other.x, other.y);
int deltaX = otherLocation.x - location.x;
int deltaY = otherLocation.y - location.y;
return Math.sqrt(deltaX*deltaX + deltaY*deltaY);
}
在这一点上，escape 分析可以显示在第一行分配的对象永远不会脱离它的基本块，而 getDistanceFrom() 也永远不会修改 other 组件的状态。（escape 指的是对象引用没有保存到堆中，或者传递给可能保留一份拷贝的未知代码。）如果 Point 真的是线程本地的，而且也清楚它的生命周期限制在分配它的基本块内，那么它既可以进行堆栈分配，也可以完全优化掉，如清单 4 所示。
清单 4. 伪代码描述了从 getDistanceFrom() 优化掉分配后的结果
public double getDistanceFrom(Component other) {
int tempX = other.x, tempY = other.y;
int deltaX = tempX - location.x;
int deltaY = tempY - location.y;
return Math.sqrt(deltaX*deltaX + deltaY*deltaY);
}
结果就是得到了与所有字段都是 public 时能够得到的相同的性能，同时保持了封装和保护性拷贝（在其他安全编码技术之中）提供的安全性。
Mustang 中的 escape 分析
escape 分析是一项被议论了很久的优化，它最后终于出现了：Mustang（Java SE 6）的当前构建中可以做 escape 分析，并在适当的地方把堆分配转换成堆栈分析（或者不分配）。用 escape 分析清除一些分配，会带来更快的平均分配时间，简化的内存工作，更少的缓存遗漏。而且，优化掉一些分配，可以降低垃圾收集器的压力，从而让收集运行得更少。
即使在源代码中进行堆栈分配不太现实的地方，即使语言提供了分配的选项，escape 分析也能找到堆栈分配的机会，因为特定的分配是否会被优化掉，是根据特定代码路径中实际上如何使用对象返回方法的结果而决定的。getLocation() 返回的 Point 可能不是在所有情况下都适合进行堆栈分配，但是一旦 JVM 内联了 getLocation()，它就可以自由而且独立地优化每个调用，从而在两方面都提供了最好的结果：最优的性能，最少的时间花在进行低级的性能调整决策上。
回页首
结束语
JVM 擅长发现我们一直以为只有开发人员才能知道的事情，这令人震惊。让 JVM 根据具体情况在堆栈分配和堆分配之间进行选择，我们就能得到堆栈分配的性能好处，却不必让程序员在进行堆栈分配还是进行堆分配上费脑筋。
http://www.ibm.com/developerworks/cn/java/j-jtp09275.html
分配比想像的要快，而且会变得更快
Brian Goetz, 首席顾问, Quiotix
2005 年 10 月 20 日
Java™ 语言遭到许多性能方面的攻击。虽然有些攻击可能是名符其实的，但是看看公告板和新闻组上关于这一主题的贴子，可以发现，对于 Java 虚拟机（JVM）实际的工作方式存在许多误解。在本月的 Java 理论与实践 中，Brian Goetz 驳斥了反复重复的有关 JVM 分配慢的传言。请与作者和其他读者在配套的 讨论组 上分享您对这篇文章的想法。（也可以点击文章顶部或底部的 讨论 来访问讨论组。）
流行问题：哪种语言的原始分配性能更快，Java 语言还是 C/C++？答案可能令人惊讶 —— 现代 JVM 中的分配比执行得最好的 malloc 实现还要快得多。HotSpot 1.4.2 之后虚拟机中的 new Object() 常见代码路径最多 10 条机器指令（Sun 提供的数据；请参阅 参考资料），而用 C 语言实现的执行得最好的 malloc 实现，每个调用平均要求的指令在 60 到 100 条之间（Detlefs 等；请参阅 参考资料）。而且分配性能在整体性能中不是一个微不足道的部分，测评显示：对于许多实际的 C 和 C++ 程序（例如 Perl 和 Ghostscript），整体执行时间中的 20% 到 30% 都花在 malloc 和 free 上，远远多于健康的 Java 应用程序在分配和垃圾收集上的开销（Zorn；请参阅 参考资料）。
继续，弄得一团糟
没有必要搜索众多的 blog 或 Slashdot 贴子，去寻找像“垃圾收集永远不会像直接内存管理一样有效”这样能够说服人的陈述。而且，从某个方面来说，这些话说的是对的 —— 动态内存管理并不一样快 —— 而是快得多。malloc/free 技术一次处理一个内存块，而垃圾收集机制则采用大批量方式处理内存管理，从而形成更多的优化机会（以一些可以预见到的损失为代价）。
这条“听起来有理的意见” （以大批量清理垃圾要比一天到晚一点点儿清理垃圾更容易）得到了数据的证实。一项研究（Zorn; 请参阅 参考资料）测量了在许多常见 C++ 应用程序中，用保守的 Boehm-Demers-Weiser（BDW）替换 malloc 的效果，结果是：许多程序在采用垃圾收集而不是传统的分配器运行时，表现出了速度提升。（BDW 是个保守的、不移动的垃圾收集器，严重地限制了对分配和回收进行优化的能力，也限制了改善内存位置的能力；像 JVM 中使用的那些精确的浮动收集器可以做得更好。）
在 JVM 中的分配并不总是这么快，早期 JVM 的分配和垃圾收集性能实际上很差，这当然就是 JVM 分配慢这一说法的起源。在非常早的时候，我们看到过许多“分配慢”的意见 —— 因为就像早期 JVM 中的一切一样，它确实慢 —— 而性能顾问提供了许多避免分配的技巧，例如对象池。（公共服务声明：除了对最重量的对象之外，对象池现在对于所有对象都是严重的性能损失，而且要在不造成并发瓶颈的情况下使用对象池也很需要技巧。）但是，从 JDK 1.0 开始已经发生了许多变化；JDK 1.2 中引入的分代收集器（generational collector）支持简单得多的分配方式，可以极大地提高性能。
分代垃圾收集
分代垃圾收集器把堆分成多代；多数 JVM 使用两代，“年轻代”和“年老代”。对象在年轻代中分配；如果它们在一定数量的垃圾收集之后仍然存在，就被当作是”长寿的“，并晋升到年老代。
HotSpot 提供了使用三个年轻代收集器的选择（串行拷贝、并行拷贝和并行清理），它们都采用“拷贝”收集器的形式，有几个重要的公共特征。拷贝收集器把内存空间从中间分成两半，每次只使用一半。开始时，使用中的一半构成了可用内存的一个大块；分配器满足分配请求时，返回它没有使用的空间的前 N 个字节，并把指针（分隔“使用”部分）从“自由”部分移动过来，如清单 1 的伪代码所示。当使用的那一半用满时，垃圾收集器把所有活动对象（不是垃圾的那些对象）拷贝到另一半的底部（把堆压缩成连续的），然后从另一半开始分配。
清单 1. 在存在拷贝收集器的情况下，分配器的行为
void *malloc(int n) {
if (heapTop - heapStart < n)
doGarbageCollection();
void *wasStart = heapStart;
heapStart += n;
return wasStart;
}
从这个伪代码可以看出为什么拷贝收集器可以实现这么快的分配 —— 分配新对象只是检查在堆中是否还有足够的剩余空间，如果还有，就移动指针。不需要搜索自由列表、最佳匹配、第一匹配、lookaside 列表 ，只要从堆中取出前 N 个字节，就成功了。
如何回收？
但是分配仅仅是内存管理的一半，回收是另一半。对于多数对象来说，直接垃圾收集的成本为零。这是因为，拷贝收集器不需要访问或拷贝死对象，只处理活动对象。所以在分配之后很快就变成垃圾的对象，不会造成收集周期的工作量。
在典型的面向对象程序中，绝大多数对象（根据不同的研究，在 92% 到 98% 之间）“死于年轻”，这意味着它们在分配之后，通常在下一次垃圾收集之前，很快就变成垃圾。（这个属性叫作 分代假设，对于许多面向对象语言已经得到实际测试，证明为真。）所以，不仅分配要快，对于多数对象来说，回收也要自由。
线程本地分配
如果分配器完全像 清单 1 所示的那样实现，那么共享的 heapStart 字段会迅速变成显著的并发瓶颈，因为每个分配都要取得保护这个字段的锁。为了避免这个问题，多数 JVM 采用了 线程本地分配块，这时每个线程都从堆中分配一个更大的内存块，然后顺序地用这个线程本地块为小的分配请求提供服务。所以，线程花在获得共享堆锁的大量时间被大大减少，从而提高了并发性。（在传统的 malloc 实现的情况下要解决这个问题更困难，成本更高；把线程支持和垃圾收集都构建进平台促进了这类协作。）
回页首
堆栈分配
C++ 向程序员提供了在堆或堆栈中分配对象的选择。基于堆栈的分配更有效：分配更便宜，回收成本真正为零，而且语言提供了隔离对象生命周期的帮助，减少了忘记释放对象的风险。另一方面，在 C++ 中，在发布或共享基于堆栈的对象的引用时，必须非常小心，因为在堆栈帧整理时，基于堆栈的对象会被自动释放，从而造成孤悬的指针。
基于堆栈的分配的另一个优势是它对高速缓存更加友好。在现代的处理器上，缓存遗漏的成本非常显著，所以如果语言和运行时能够帮助程序实现更好的数据位置，就会提高性能。堆栈的顶部通常在高速缓存中是“热”的，而堆的顶部通常是“冷”的（因为从这部分内存使用之后可能过了很长时间）。所以，在堆上分配对象，比起在堆栈上分配对象，会带来更多缓存遗漏。
更糟的是，在堆上分配对象时，缓存遗漏还有一个特别讨厌的内存交互。在从堆中分配内存时，不管上次使用内存之后留下了什么内容，内存中的内容都被当作垃圾。如果在堆的顶部分配的内存块不在缓存中，执行会在内存内容装入缓存的过程中出现延迟。然后，还要用 0 或其他初始值覆盖掉刚刚费时费力装入缓存的那些值，从而造成大量内存活动的浪费。（有些处理器，例如 Azul 的 Vega，包含加速堆分配的硬件支持。）
escape 分析
Java 语句没有提供任何明确地在堆栈上分配对象的方式，但是这个事实并不影响 JVM 仍然可以在适当的地方使用堆栈分配。JVM 可以使用叫作 escape 分析 的技术，通过这项技术，JVM 可以发现某些对象在它们的整个生命周期中都限制在单一线程内，还会发现这个生命周期绑定到指定堆栈帧的生命周期上。这样的对象可以安全地在堆栈上而不是在堆上分配。更好的是，对于小型对象，JVM 可以把分配工作完全优化掉，只把对象的字段放入寄存器。
清单 2 显示了一个可以用 escape 分析把堆分配优化掉的示例。Component.getLocation() 方法对组件的位置做了一个保护性的拷贝，这样调用者就无法在不经意间改变组件的实际位置。先调用 getDistanceFrom() 得到另一个组件的位置，其中包括对象的分配，然后用 getLocation() 返回的 Point 的 x 和 y 字段计算两个组件之间的距离。
清单 2. 返回复合值的典型的保护性拷贝方式
public class Point {
private int x, y;
public Point(int x, int y) {
this.x = x; this.y = y;
}
public Point(Point p) { this(p.x, p.y); }
public int getX() { return x; }
public int getY() { return y; }
}
public class Component {
private Point location;
public Point getLocation() { return new Point(location); }
public double getDistanceFrom(Component other) {
Point otherLocation = other.getLocation();
int deltaX = otherLocation.getX() - location.getX();
int deltaY = otherLocation.getY() - location.getY();
return Math.sqrt(deltaX*deltaX + deltaY*deltaY);
}
}
getLocation() 方法不知道它的调用者要如何处理它返回的 Point；有可能得到一个指向 Point 的引用，比如把它放在集合中，所以 getLocation() 采用了保护性的编码方式。但是，在这个示例中，getDistanceFrom() 并不会这么做，它只会使用 Point 很短的时间，然后释放它，这看起来像是对完美对象的浪费。
聪明的 JVM 会看出将要进行的工作，并把保护性拷贝的分配优化掉。首先，对 getLocation() 的调用会变成内联的，对 getX() 和 getY() 的调用也同样处理，从而导致 getDistanceFrom() 的表现会像清单 3 一样有效。
清单 3. 伪代码描述了把内联优化应用到 getDistanceFrom() 的结果
public double getDistanceFrom(Component other) {
Point otherLocation = new Point(other.x, other.y);
int deltaX = otherLocation.x - location.x;
int deltaY = otherLocation.y - location.y;
return Math.sqrt(deltaX*deltaX + deltaY*deltaY);
}
在这一点上，escape 分析可以显示在第一行分配的对象永远不会脱离它的基本块，而 getDistanceFrom() 也永远不会修改 other 组件的状态。（escape 指的是对象引用没有保存到堆中，或者传递给可能保留一份拷贝的未知代码。）如果 Point 真的是线程本地的，而且也清楚它的生命周期限制在分配它的基本块内，那么它既可以进行堆栈分配，也可以完全优化掉，如清单 4 所示。
清单 4. 伪代码描述了从 getDistanceFrom() 优化掉分配后的结果
public double getDistanceFrom(Component other) {
int tempX = other.x, tempY = other.y;
int deltaX = tempX - location.x;
int deltaY = tempY - location.y;
return Math.sqrt(deltaX*deltaX + deltaY*deltaY);
}
结果就是得到了与所有字段都是 public 时能够得到的相同的性能，同时保持了封装和保护性拷贝（在其他安全编码技术之中）提供的安全性。
Mustang 中的 escape 分析
escape 分析是一项被议论了很久的优化，它最后终于出现了：Mustang（Java SE 6）的当前构建中可以做 escape 分析，并在适当的地方把堆分配转换成堆栈分析（或者不分配）。用 escape 分析清除一些分配，会带来更快的平均分配时间，简化的内存工作，更少的缓存遗漏。而且，优化掉一些分配，可以降低垃圾收集器的压力，从而让收集运行得更少。
即使在源代码中进行堆栈分配不太现实的地方，即使语言提供了分配的选项，escape 分析也能找到堆栈分配的机会，因为特定的分配是否会被优化掉，是根据特定代码路径中实际上如何使用对象返回方法的结果而决定的。getLocation() 返回的 Point 可能不是在所有情况下都适合进行堆栈分配，但是一旦 JVM 内联了 getLocation()，它就可以自由而且独立地优化每个调用，从而在两方面都提供了最好的结果：最优的性能，最少的时间花在进行低级的性能调整决策上。
回页首
结束语
JVM 擅长发现我们一直以为只有开发人员才能知道的事情，这令人震惊。让 JVM 根据具体情况在堆栈分配和堆分配之间进行选择，我们就能得到堆栈分配的性能好处，却不必让程序员在进行堆栈分配还是进行堆分配上费脑筋。
这样的原理在项目数不多时工作得很好，而如果项目过大，而在实例化时的构造函数里又没有制定一个初始的大小时，就会工作得很慢。。。
而实际应用过程中，项目数大部分情况下不会很多的。
.net的对象都存在一些优化算法在里面的，有兴趣的可以反编译来看看。这些优化对于一般的应用是很有帮助的，而如果有特殊需要的话建议自己构造一个Dictionary专门处理特殊的应用。
总之你不能因为这样的一个特性而说C#很慢，只能说。NET的类库不够丰富以应付所有的情况。
对于windows下的开发人员，如果面向的是企业应用，那么可以说接触C的机会和必要的确很少，如果面向是底层或者一些核心开发，C依然是唯一的选择
对于嵌入式的开发人员，除了C还是选择什么？pascal？basic？C#？
不要说C低级，那是因为你还没有学会，不要说C原始，那是因为你还不懂开发
再说C死了不迟....
-----------------------------------------------------------------------
# cyantree 发表于2007-01-08 18:50:55 IP: 222.71.166.*
对于windows下的开发人员，如果面向的是企业应用，那么可以说接触C的机会和必要的确很少，如果面向是底层或者一些核心开发，C依然是唯一的选择
对于嵌入式的开发人员，除了C还是选择什么？pascal？basic？C#？
不要说C低级，那是因为你还没有学会，不要说C原始，那是因为你还不懂开发
-----------------------------------------------------------------------
绝对同意
cyantree 发表于2007-01-08 18:50:55 IP: 222.71.166.*
对于linux下的开发人员而言，讨论C是否已死是一个笑话
对于windows下的开发人员，如果面向的是企业应用，那么可以说接触C的机会和必要的确很少，如果面向是底层或者一些核心开发，C依然是唯一的选择
对于嵌入式的开发人员，除了C还是选择什么？pascal？basic？C#？
不要说C低级，那是因为你还没有学会，不要说C原始，那是因为你还不懂开发
-----------------------------------------------------------------------
一针见血。
某些朋友从理论角度讨论Java的内存效率具有一定意义，但是
实际效果却当另论。平心而论，无论是Java还是C#，总体执行
效率就是要差一些，放到一个稍微大一点的程序里，这一点就变
得非常明显。
我学过多种语言，现在还是主要使用C++。并非因为它完美，而
是因为对于我所做的项目而言，它是最好的选择。
在构建很多程序的时候C/C++的确不如某些语言方便，但是品质
上却往往更胜一筹。回想几年前，BT大行其道的时候，大多BT软
件都是基于Python的，勉强一用，耗费内存很多，效率很差。
后来终于出现了SimpleBT（Bitcomet的前身），现在的情况大家
也都知道了。
对于发布给很少人用的软件来说，Java或者C#还是很不错的，方便
快捷，做UI绝对胜过C。我们公司也讨论过是否要使用C#来编写内部
工具，我的个人工具，只要是有UI的，就会用C#。不过作为一款商
业软件，选择什么就需要慎重考虑一下。即使是微软的产品，也并没
有那么依赖.net。VS的UI是基于.netframework的，编译器的核心却
依然是C++，谁有兴趣可以看看sscli，看看C#编译器的实现是啥？
有一个开源的.net实现叫mono，基础代码是标准C的。Sun前阵子开
放了JVM的源代码，大家也可以看看是啥实现。
俺们公司做游戏，对这方面也还是了解一点。据我所知，流行的游
戏似乎只有传奇和千年是Delphi的，其它的似乎也是C/C++。也有游
戏使用C核心+脚本语言，比如WOW，这似乎是目前的流行趋势了。
总结一点，把程序员比作一个厨师。C是一把最强的菜刀，C++是组合
刀具，Java等可以认为是绞肉机。什么合适就用什么，这是咱们最好
的选择。组合使用多种工具也是很好的做法。
比如MFC中CPlex的实现，比如STLPort（我没仔细看过）。
SSCLI里有一个NRHeap，比较适合于突发性的大量内存操作。
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
面对一段代码，没有“谁”能够比写这段代码的“人”更知道它如何才能运行的更好。
在目前和可以预见的将来，机器相对于人的优势依然是机械的运算而不是其它的什么。机器智能对我们这个世界来说还很弱小、很昂贵、很不稳定。
并且，机器智能做为一个不太简单的人工系统，象一切稍微复杂一点的人工系统一样，是注定了会有缺陷和漏洞的。在外部力量（通常只能是人）改变和修复它之前，它无法做到自我修复。
就象“是人对火和蒸汽的掌握，而不是火或者蒸汽本身改变了世界”那样。在一切变革中，起主导作用的只能是人。推动变革的是人的思考（正确的或错误的）和思考之上的实践（当然：正确的或错误的）。所以，从这个意义上来说。过分的解放不见得是件多好的事情。
这个话题挺没意思的。本来没有任何争论的必要。但是还是多说了两句。。。。。呵呵。
做板级的信号信息处理你用什么？
你所用的种种高级语言又是建立在何种语言做的平台基础之上？
http://blog.csdn.net/layerr/archive/2007/01/09/1477754.aspx
只不过现在很多人只是写写网站，对一些底层技术的东西所知甚少，倒是整天吹，整天抄代码。
内存分配效率跟系统实现有关，malloc是调用系统调用来实现的，快慢在于这个库函数封装是否高效。C#,Java等分配的快是怎么得出的呢？难道VM不调用系统调用吗？ 即使malloc不够高效，只能说这个实现不够高效。跟C语言有什么关系。
关于语言的议论，记得上一次就有一个ruby议论，真是好不热闹！
我喜欢我写的代码经编译后运行在真正的CPU上。我不需要虚拟机来横插一脚，谁知道他在对我的指令进行怎么样的修改。我喜欢看到我写的代码在CPU寄存器之间流动的感觉。
C语言万岁，C语言永不死。
JAVA才会死，世界上最丑陋的语言。
就可以了，并通过GC来缩并。而且由于GC的存在，内存策略
就比较简单，比如C#等语言无需给String加入引用计数，这
也可以在很多时候提高效率。
C/C++的malloc是低效的，最起码，VC带的malloc是低效的。
所以才会有各种优化手段。优化的C/C++程序可以通过很多方法
来利用内存，比如栈对象，内存池等。多数情况下，一个优化的
C/C++程序整体效率要高于C#，Java程序；未经优化的程序
有可能更低效。
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
我的搜索引擎继7月份第二次开放测试后,现在进行第三次开放测试,前两次分别用CGI+Html、Java做的客户端网站，这次学习了4个月 .NET，用.NET做了
一个版本，请大家多批评指正。同时开放网站源代码。(附件中)
无为搜索引擎开始测试了啊
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
代码下载地址 ：http://www.ofile.cn/se.rar
前两次用 CGI+html做了一个版本还做了一个 Java版本 (这次比较忙，所以没来的及更新，有需要的跟我说一声啊)
这次用 C# ASP.NET做一个 玩玩
做的不好,请大家做指教啊!
这次还实现了计算器功能啊
可以搜索一下 sin(1+2) 看看
另外 sh=1&sf=1&ua=1&sa=1&st=1&wh=1&ph=1 把这里面的 1改成 0看看 每个部分都是可以控制的：）
至于为什么要把客户端网站部分开源，请参考我第二次开放测试时即兴写的文章 : 最近我研究搜索引擎 七 (长长中国人的志气篇)
http://www.baidu.com/s?wd=%D7%EE%BD%FC%CE%D2%D1%D0%BE%BF%CB%D1%CB%F7%D2%FD%C7%E6%C6%DF&cl=3
承盟广大网友看的起 该文目前已经被全国 2000多网站转载
先说一下技术指标： 本次我收录了全国30多万个一、二级域名， 网页采集用了三周时间，目前已经采集了 12万网站，平均每个网站收录 30篇网页，
索引进行了 10天，
目前已经索引了 100多万网页 。 搜索核心部分采用这次采用 C 语言开发。 客户端提供三个版本一个CGI+HTML版本，一个 Java版本，一个 ASP.NET
版本。
代码下载地址 ：http://www.ofile.cn/se.rar
搜索网站客户端(.NET版本)整体解决方案(源代码)
(第三次开放测试啊) 网站运行后的效果请参见：
http://219.233.38.213/Search/WuWei.aspx
Everything exists for a reason, there will be ones benefiting from it, there will be ones having nothing to do with it. Just accept the fact and enjoy that funny story, man.
我觉得有点搞笑.在这样的贴子里,你其实不应该这样问:
Q:"C/C++"做出来什么?
A:这太多了.Java就是它的儿子.
如果人们只去追求某种思想,而没人有去学习"掌握在少数人手里"基于C/ASM在底层的设计与应用.
在当这"少数人"因意外或自然规律而不存在于这个世界上之后.
思考者们,请你们告诉我,你们的思想能做什么?空想而已!
C/C++的人牛X,那是因为在思考者们越来越多的一天,他们越是认识到自己所学的价值,他们觉得自己会有牛X的权力,将来更是这样..
除非,有哪位高人,直接用机器码重写Java的编译器以及Java的开发环境,有哪位高人,能让整个计算机系统中能够没有ASM/C/C++的存在,到那时候,我想,全体做C/C++的人都会对这位思考者五体投地,共道一句牛X!
我不贬低Java之类的"脚本语言",只有一句许想对那些因看不到C/C++价值所在而贬低C/C++或认为"C已死"的思考者们说一句老话:
儿不嫌母丑!
当然,有认为上面这句话不对的人,尽管砖头上来,我受了!