searl1986 space

工作还是考研，跳槽还是坚守..如何面对选择？[转帖]

Mon, 28 Jul 2008 01:17:02 GMT

许多同学应该都还记得联考前夕的焦虑：差一分可能要掉好几个志愿，甚至于一生的命运从此改观！到了大四，这种焦虑可能更强烈而复杂：到底要先当兵，就业，还是先考研究所？　
我就经常碰到学生充满焦虑的问我这些问题。可是，这些焦虑实在是莫须有的！生命是一种长期而持续的累积过程，绝不会因为单一的事件而毁了一个人的一生，也不会因为单一的事件而救了一个人的一生。属于我们该得的，迟早会得到；属于我们不该得的，即使侥幸巧取也不可能长久保有。如果我们看清这个事实，许多所谓" 人生的重大抉择 " 就可以淡然处之，根本无需焦虑。而所谓"人生的困境"，也往往当下就变得无足挂齿。　

我自己就是一个活生生的例子。从一进大学就决定不再念研究所，所以，大学四年的时间多半在念人文科学的东西。毕业后工作了几年，才决定要念研究所。硕士毕业后，立下决心：从此不再为文凭而念书。谁知道，世事难料，当了五年讲师后，我又被时势所迫，整装出国念博士。出国时，一位大学同学笑我：全班最晚念博士的都要回国了，你现在才要出去？两年后我从剑桥回来，觉得人生际遇无常，莫此为甚：一个从大一就决定再也不钻营学位的人，竟然连硕士和博士都拿到了！属于我们该得的，哪样曾经少过？而人生中该得与不该得的究竟有多少，我们又何曾知晓？从此我对际遇一事不能不更加淡然。当讲师期间，有些态度较极端的学生会当面表现出他们的不屑；从剑桥回来时，却被学生当做不得了的事看待。这种表面上的大起大落，其实都是好事者之言，完全看不到事实的真相。　从表面上看来，两年就拿到剑桥博士，这好像很了不起。但是，在这" 两年"之前我已经花整整一年，将研究主题有关的论文全部看完，并找出研究方向；而之前更已花三年时间做控制方面的研究，并且在国际著名的学术期刊中发表论文。　而从硕士毕业到拿博士，期间七年的时间我从不停止过研究与自修。所以，这个博士其实是累积了七年的成果，或者，只算我花在控制学门的时间，也至少有五年），根本也没什么好惊讶的。　
常人不从长期而持续的累积过程来看待生命因积蓄而有的成果，老爱在表面上以断裂而孤立的事件夸大议论，因此每每在平淡无奇的事件上强做悲喜。可是对我来讲，当讲师期间被学生瞧不起，以及剑桥刚回来时被同学夸大本事，都只是表象。事实是：我只在乎每天二十四小时点点滴滴的累积。拿硕士或博士只是特定时刻里这些成果累积的外在展示而已，人生命中真实的累积从不曾因这些事件而终止或加添。

常有学生满怀忧虑的问我：" 老师，我很想先当完兵，工作一两年再考研究所。这样好吗？

"很好，这样子有机会先用实务来印证学理，你念研究所时会比别人了解自己要的是什么。

""可是，我怕当完兵又工作后，会失去斗志，因此考不上研究所。　
""那你就先考研究所好了。　
""可是，假如我先念研究所，我怕自己又会像念大学时一样茫然，因此念的不甘不愿的。

""那你还是先去工作好了！　
""可是。。。。。。。　
我完全可以体会到他们的焦虑，可是却无法压抑住对于这种话的感慨。其实，说穿了他所需要的就是两年研究所加两年工作，以便加深知识的深广度和获取实务经验。先工作或先升学，表面上大相迳庭，其实骨子里的差别根本可以忽略。在" 朝三暮四"这个成语故事里，主人原本喂养猴子的橡实是"早上四颗下午三颗"，后来改为"朝三暮四"，猴子就不高兴而坚持改回到"朝四暮三" 。其实，先工作或先升学，期间差异就有如"朝三暮四"与"朝四
暮三"，原不值得计较。但是，我们经常看不到这种生命过程中长远而持续的累积，老爱将一时际遇中的小差别夸大到攸关生死的地步。最讽刺的是：当我们面对两个可能的方案，而焦虑的不知何所抉择时，通常表示这两个方案可能一样好，或者一样坏，因而实际上选择哪个都一样，唯一的差别只是先后之序而已。而且，愈是让我们焦虑得厉害的，其实差别越小，愈不值得焦虑。反而真正有明显的好坏差别时，我们轻易的就知道该怎么做了。可是我们却经常看不到长远的将来，短视的盯著两案短期内的得失：想选甲案，就舍不得乙案的好处；想选乙案，又舍不得甲案的好处。如果看得够远，人生常则八，九十，短则五，六十年，先做哪一件事又有什么关系？甚至当完兵又工作后，再花一整年准备研究所，又有什么了不起？当然，有些人还是会忧虑说：" 我当完兵又工作后，会不会因为家累或记忆力衰退而比较难考上研究所？"　

我只能这样回答："一个人考不上研究所，只有两个可能：或者他不够聪明，或者他的确够聪明。不够聪明而考不上，那也没什么好抱怨的。假如你够聪明，还考不上研究所，那只能说你的决心不够强。假如你是决心不够强，就表示你生命中还有其他的可能性，其重要程度并不下于硕士学位，而你舍不得丢下他。既然如此，考不上研究所也无须感到遗憾。不是吗？"　人生的路这么多，为什么要老斤斤计较著一个可能性？我高中最要好的朋友，一生背运：高中考两次，高一念两次，大学又考两次，甚至连机车驾照都考两次。毕业后，他告诉自己：我没有人脉，也没有学历，只能靠加倍的诚恳和努力。现在，他自己拥有一家公司，年收入数千万。一个人在升学过程中不顺利，而在事业上顺利，这是常见的事。有才华的人，不会因为被名校拒绝而连带失去他的才华，只不过要另外找适合他表现的场所而已。反过来，一个人在升学过程中太顺利，也难免因而放不下身段去创业，而只能乖乖领薪水过活。福祸如何，谁能全面知晓？

我们又有什么好得意？又有什么好忧虑？人生的得与失，有时候怎么也说不清楚，有时候却再简单不过了：我们得到平日累积的成果，而失去我们不曾努力累积的！所以重要的不是和别人比成就，而是努力去做自己想做的。功不唐捐，最后该得到的不会少你一分，不该得到的也不会多你一分。　
好像是前年的时候，我在往艺术中心的路上遇到一位高中同学。他在南加大当电机系的副教授，被清华电机聘回来开短期课程。从高中时代他就很用功，以第一志愿上台大电机后，四年都拿书卷奖，相信他在专业上的研究也已卓然有成。回想高中入学时，我们两个人的智力测验成绩分居全学年第一，第二名。可是从高一我就不曾放弃自己喜欢的文学，音乐，书法，艺术和哲学，而他却始终不曾分心，因此两个人在学术上的差距只会愈来愈远
。反过来说，这十几二十年我在人文领域所获得的满足，恐怕已远非他所能理解的了。我太太问过我，如果我肯全心专注于一个研究领域，是不是至少会赶上这位同学的成就？我不这样想，两个不同性情的人，注定要走两条不同的路。不该得的东西，我们注定是得不到的，随随便便拿两个人来比，只看到他所得到的，却看不到他所失去的，这有什么意义？　

有次清华电台访问我："老师你如何面对你人生中的困境？"我当场愣在那里，怎么样都想不出我这一生什么时候有过困境！后来仔细回想，才发现：我不是没有过困境，而是被常人当作" 困境"的境遇，我都当作一时的际遇，不曾在意过而已。刚服完兵役时，长子已出生却还找不到工作。我曾焦虑过，却又觉得迟早会有工作，报酬也不至于低的离谱，不曾太放在心上。念硕士期间，家计全靠太太的薪水，省吃俭用，对我而言又算不上困境。一
来，精神上我过的很充实，二来我知道这一切是为了让自己有机会转行去教书( 做自己想做的事)。三十一岁才要出国，而同学正要回系上任教，我很紧张(不知道剑桥要求的有多严)，却不曾丧气。因为，我知道自己过去一直很努力，也有很满意的心得和成果，只不过别人看不到而已。我没有过困境，因为我从不在乎外在的得失，也不武断的和别人比高下，而只在乎自己内在真实的累积。我没有过困境，因为我确实了解到：生命是一种长期而持续的累积过程，绝不会因为单一的事件而有剧烈的起伏。同时我也相信：属于我们该得的，迟早会得到；属于我们不该得的，即使一分也不可能加增。假如你可以持有相同的信念，那么人生于你也会是宽广而长远，没有什么了不得的" 困境"，也没有什么好焦虑的了。　

-----------------一个台湾清华大学老师

09年微软5大工作重心

Fri, 25 Jul 2008 09:20:44 GMT

北京时间7月24日消息，据国外媒体报道，微软周三宣布，在线服务与视窗业务将分拆成两大独立部门，而平台与服务部门总裁凯文·约翰逊(Kevin Johnson)也将离职。对于此次重组和人士变动，微软CEO史蒂夫·鲍尔默(Steve Ballmer)在致员工的备忘录中给予了详细说明。此外，鲍尔默还对微软2009财年的工作重心进行了部署。以下为鲍尔默的备忘录全文：

　　发信人：史蒂夫·鲍尔默

　　发送时间：2008年7月23日16时30分，星期三

　　收件人：微软全体雇员

　　主题： 09财年公司战略调整

　　2008财年已经结束，我想谈谈下一财年的工作重心，与大家分享一下我对公司核心战略的一些看法，其中包括Windows，与苹果和谷歌的竞争，软件加服务战略，以及雅虎问题等等。此外，我还要谈谈此次部门重组和人士变动。

　　首先，我要感谢大家在过去12个月中的努力工作。2008财年是具有里程碑意义的一年，营收增加93亿美元至600亿美元，运营利润增长21%达到225亿美元。

　　这是大家共同努力的结果。在过去一年多的时间里，公司发生了很多变化，但基础实力、挑战和战略目标等并未发生太大变化。因此，今年的工作重心与去年基本一致。在2009财年，我们要继续：

　　1. 寻求适当的机会投资

　　2. 继续发展Windows和Office业务，吸引开发者

　　3. 完善产品用户体验

　　4. 推进软件加服务战略

　　5. 继续发展优秀员工

　　通过贯彻以上五大方针，公司营收、利润和市场份额将继续提升。在2009财年，我们还要重点解决以下几个核心问题：

·Windows：

　　确保Windows成功是我们的头等要事。通过发布SP1，以及与PC厂商和软件开发商的共同努力， Windows Vista的设备和应用兼容性问题已经解决。在未来几周内，我们将启动一项推广计划，旨在打消客户对Windows Vista的顾虑。今年晚些时候，我们还将采取全面措施让客户重新认识Windows的价值。

　　我们还将吸引更多开发人员开发更丰富的Windows应用。IE和Silverlight是很优秀的程序创建工具，但我们还要让开发人员精通.NET技巧，以开发更高级的Windows应用。为确保Windows应用更具活力，我们同时需要运行在所有设备上的应用和客户端引用。

　·苹果：

　　在PC和Mac对决中，我们以30：1胜出。但毫无疑问，苹果仍是一家蓬勃发展的企业。原因何在呢？因为他们善于提供相对狭隘但完整的用户体验，而我们则致力于提供端到端的用户体验。而如今，我们已经调整了与硬件厂商的合作方式，以确保提供完整的用户体验。

·商业与企业

　　我们的企业和服务器业务创下了前所未有的辉煌业绩，如今即将成为最大的企业软件供应商。因此，我们还要继续推进Exchange、 PerformancePoint、Hyper-V和SQL Server业务，进一步完善企业搜索技术、统一通信解决方案和协同技术。在Web服务器和高性能计算等领域，我们还要与Linux一较高下。

·软件加服务：

　　有人认为，软件加服务仅限于搜索，其实不然。它真正改变了软件开发与部署模式，将来还涉及到向PC、电话、电视和其他设备提供应用。此外，它还将通过广告、注册和在线交易等改变当前的业务模式。软件加服务对于我们在桌面和服务器领域向所有客户提供新价值至关重要。在今年的专业开发者大会 (PDF)上，我们将公布更多的云计算平台战略和下一版Live及在线技术。

·谷歌：

　　我们将继续与谷歌在两方面展开竞争：企业市场，我们领先；搜索市场，谷歌领先。在搜索市场，我们在很多时间内就达到了一定技术水平，将来还会继续投资该市场，并成为领跑者。原因何在呢？因为搜索是打开网络广告市场契机的钥匙。在未来几年内，我们将通过以下三种途径来削弱谷歌的优势：首先，通过自身创新和战略并购提升研发能力；其次，在核心领域的创新能力将超越谷歌，这点在地图和新闻服务已有所体现；另外，我们要重振搜索业务，改善用户体验，搜索结果页面不再是简单的白色页面加十条蓝色链接。当然，与谷歌竞争是一项长期任务。

　·雅虎：

　　说完谷歌，再来谈谈雅虎。我想强调的是，收购雅虎只是一个策略，而不是公司战略。我们想提升搜索市场份额，吸引更多广告主，雅虎可以帮助我们以更快速度实现该目标。但是，无论有没有雅虎，我们最终都要实现该目标。我们有优秀的人才，先进的技术，明智的投资，这些都将确保我们打造业内领先的业务。

　　前面说过，我还要谈谈今天的部门重组。我们已宣布把在线服务与Windows将分拆成两大独立部门，而平台与服务部门总裁凯文·约翰逊(Kevin Johnson)也将离职。为确保平稳过渡，约翰逊还将在公司工作一段时间。

　　约翰逊1992年加盟微软，对于公司所取得的大部分重要成就，凯文都是核心功臣。作为公司平台与服务部门总裁，凯文建立了一支令人难以置信的优秀团队，为将来Windows和在线服务业务的成功奠定了基础。在过去的16年中，他担任过公司全球销售、市场和服务的领导者，在这些领域作出很大的努力。他领导公司改变外勤业务，重视新兴市场，对于微软的成功，凯文发挥了重要作用。

　　分拆后，Windows和Windows live部门将由高级副总裁史蒂文·斯诺夫斯基(Steven Sinofsky)、乔恩·德瓦恩(Jon DeVaan)和比尔·维特(Bill Veghte)负责，至于在线业务则需要一名新主管，微软将同时在公司内部和外部寻求适当人选。

　　此外，高级副总裁萨提娅·纳德拉(Satya Nadella)将继续负责搜索、MSN和广告平台业务，而高级副总裁布莱恩·迈克安德鲁斯(Brian McAndrews)将负责广告主和发行商解决方案部门。

　　展望未来，我认为公司前景无限光明。我们是世界上最优秀的软件开发商，这毋庸置疑。但这并不意味着我们将停滞不前，相反，没有人比我们更出色，没有人比我们更勤奋，没有人比我们更顽强。我们的投资范围比任何人都广泛，投资态度比任何人都认真，我们所面临的改变世界的机会也是前所未有的。

　　我期望与各位共同努力，认真贯彻2009财年五大业务重心。

　　史蒂夫

如何学好C Plus Plus ，用好类库很重要

Fri, 25 Jul 2008 04:41:39 GMT

如果你有一定的C基础可能学起来比较容易些,但是学习C++ 的过程中又要尽量避免去使用一些C中的思想;平时还要多看一些高手写的代码,遇到问题多多思考,怎样才能把问题抽象化,以使自己头脑中有类的概念;最后别忘了经常上机自己调调程序,这是谁也代替不了的.

C++ 类库介绍
再次体现了C++ 保持核心语言的效率同时大力发展应用库的发展趋势!!在C++ 中，库的地位是非常高的。C++ 之父 Bjarne Stroustrup先生多次表示了设计库来扩充功能要好过设计更多的语法的言论。现实中，C++的库门类繁多，解决的问题也是极其广泛，库从轻量级到重量级的都有。不少都是让人眼界大开，亦或是望而生叹的思维杰作。由于库的数量非常庞大，而且限于笔者水平，其中很多并不了解。所以文中所提的一些库都是比较著名的大型库。

标准库

标准库中提供了C++程序的基本设施。虽然C++ 标准库随着C++标准折腾了许多年，直到标准的出台才正式定型，但是在标准库的实现上却很令人欣慰得看到多种实现，并且已被实践证明为有工业级别强度的佳作。

1、 Dinkumware C++ Library 软件开发网 www.mscto.com

参考站点：http://www.dinkumware.Com

软件开发网 www.mscto.Com

P.J. Plauger编写的高品质的标准库。P.J. Plauger博士是Dr. Dobb's程序设计杰出奖的获得者。其编写的库长期被Microsoft采用，并且最近Borland也取得了其OEM的license，在其C/C++ 的产品中采用Dinkumware的库。

2、 RogueWave Standard C++ Library

参考站点：http://www.roguewave.Com/

软件开发网 www.mscto.Com

这个库在Borland C++ Builder的早期版本中曾经被采用，后来被其他的库给替换了。笔者不推荐使用。

3、SGI STL

参考站点：http://www.roguewave.Com/
SGI公司的C++ 标准模版库。

4、STLport

参考站点：http://www.stlport.org/
SGI STL库的跨平台可移植版本。

准标准库——Boost

Boost 库是一个经过千锤百炼、可移植、提供源代码的C++ 库，作为标准库的后备，是C++ 标准化进程的发动机之一。 Boost库由C++ 标准委员会库工作组成员发起，在C++ 社区中影响甚大，其成员已近2000人。 Boost库为我们带来了最新、最酷、最实用的技术，是不折不扣的"准"标准库。

Boost中比较有名气的有这么几个库：
Regex 正则表达式库

Spirit LL parser framework，用C++ 代码直接表达EBNF

Graph 　图组件和算法

Lambda 　在调用的地方定义短小匿名的函数对象，很实用的functional功能

Concept Check 　检查泛型编程中的Concept 软件开发网 www.mscto.Com

Mpl 　用模板实现的元编程框架软件开发网 www.mscto.Com

Thread 　可移植的C++ 多线程库软件开发网 www.mscto.Com

Python 　把C++ 类和函数映射到Python之中

Pool 　内存池管理

smart_ptr 5个智能指针，学习智能指针必读，一份不错的参考是来自CUJ的文章：Smart Pointers in Boost,哦，这篇文章可以查到，CUJ是提供在线浏览的。中文版见笔者在《Dr. Dobb's Journal软件研发杂志》第7辑上的译文。

Boost 总体来说是实用价值很高，质量很高的库。并且由于其对跨平台的强调，对标准C++ 的强调，是编写平台无关，现代C++ 的开发者必备的工具。但是Boost 中也有很多是实验性质的东西，在实际的开发中实用需要谨慎。并且很多Boost中的库功能堪称对语言功能的扩展，其构造用尽精巧的手法，不要贸然的花费时间研读。Boost另外一面，比如Graph这样的库则是具有工业强度，结构良好，非常值得研读的精品代码，并且也可以放心的在产品代码中多多利用。

参考站点：http://www.boost.org（国内镜像：http://www.c-view.org/tech/lib/boost/index.htm）

GUI

在众多C++ 的库中，GUI部分的库算是比较繁荣，也比较引人注目的。在实际开发中，GUI库的选择也是非常重要的一件事情，下面我们综述一下可选择的GUI库，各自的特点以及相关工具的支持。

1、 MFC

大名鼎鼎的微软基础类库（Microsoft Foundation Class）。大凡学过VC++ 的人都应该知道这个库。虽然从技术角度讲，MFC是不大漂亮的，但是它构建于Windows API 之上，能够使程序员的工作更容易,编程效率高，减少了大量在建立 Windows 程序时必须编写的代码，同时它还提供了所有一般 C++ 编程的优点，例如继承和封装。MFC 编写的程序在各个版本的Windows操作系统上是可移植的，例如，在 Windows 3.1下编写的代码可以很容易地移植到 Windows NT 或 Windows 95 上。但是在最近发展以及官方支持上日渐势微。

2、 QT

参考网站：http://www.trollteCh.Com
Qt 是TrollteCh公司的一个多平台的C++ 图形用户界面应用程序框架。它提供给应用程序开发者建立艺术级的图形用户界面所需的所用功能。Qt是完全面向对象的很容易扩展，并且允许真正地组件编程。自从1996年早些时候，Qt进入商业领域，它已经成为全世界范围内数千种成功的应用程序的基础。Qt也是流行的Linux桌面环境KDE 的基础，同时它还支持Windows、Macintosh、Unix/X11等多种平台。软件开发网 www.mscto.Com

3、WxWindows

参考网站：http://www.wxwindows.org/ 软件开发网 www.mscto.Com

跨平台的GUI库。因为其类层次极像MFC，所以有文章介绍从MFC到WxWindows的代码移植以实现跨平台的功能。通过多年的开发也是一个日趋完善的 GUI库，支持同样不弱于前面两个库。并且是完全开放源代码的。新近的C++ Builder X的GUI设计器就是基于这个库的。

4、Fox

开放源代码的GUI库。作者从自己亲身的开发经验中得出了一个理想的GUI库应该是什么样子的感受出发，从而开始了对这个库的开发。有兴趣的可以尝试一下。

参考网站：http://www.fox-toolkit.org/

5、 WTL

基于ATL的一个库。因为使用了大量ATL的轻量级手法，模板等技术，在代码尺寸，以及速度优化方面做得非常到位。主要面向的使用群体是开发COM轻量级供网络下载的可视化控件的开发者。

6、 GTK

参考网站：http://gtkmm.sourceforge.net/

GTK是一个大名鼎鼎的C++的开源GUI库。在Linux世界中有Gnome这样的杀手应用。而GTK就是这个库的C++ 封装版本。

网络通信库

ACE

参考网站：http://www.cs.wustl.edu/~schmidt/ACE.html
ACE网络编程开发论坛：http://www.acejoy.Com

C++ 库的代表，超重量级的网络通信开发框架。ACE自适配通信环境（Adaptive Communication Environment）是可以自由使用、开放源代码的面向对象框架，在其中实现了许多用于并发通信软件的核心模式。ACE提供了一组丰富的可复用C++ 包装外观（Wrapper Facade）和框架组件，可跨越多种平台完成通用的通信软件任务，其中包括：事件多路分离和事件处理器分派、信号处理、服务初始化、进程间通信、共享内存管理、消息路由、分布式服务动态（重）配置、并发执行和同步，等等。

StreamModule

参考网站：http://www.omnifarious.org/StrMod/

设计用于简化编写分布式程序的库。尝试着使得编写处理异步行为的程序更容易，而不是用同步的外壳包起异步的本质。

SimpleSocket

参考网站：http://home.hetnet.nl/~lcbokkers/simsock.htm

这个类库让编写基于socket的客户/服务器程序更加容易。

A Stream Socket API for C++

参考网站：http://www.pcs.cnu.edu/~dgame/sockets/socketsC /sockets.html

又一个对Socket的封装库。

XML

Xerces

参考网站：http://xml.apache.org/Xerces-c/

Xerces-C 是一个非常健壮的XML解析器，它提供了验证，以及SAX和DOM API。XML验证在文档类型定义(Document Type Definition，DTD)方面有很好的支持，并且在2001年12月增加了支持W3C XML Schema 的基本完整的开放标准。

XMLBooster

参考网站：http://www.xmlbooster.Com/

这个库通过产生特制的parser的办法极大的提高了XML解析的速度，并且能够产生相应的GUI程序来修改这个parser。在DOM和SAX两大主XML解析办法之外提供了另外一个可行的解决方案。

Pull Parser

参考网站：http://www.extreme.indiana.edu/xgws/xsoap/xpp/

这个库采用pull方法的parser。在每个SAX的parser底层都有一个pull的parser，这个xpp把这层暴露出来直接给大家使用。在要充分考虑速度的时候值得尝试。

软件开发网 www.mscto.Com

Xalan

参考网站：http://xml.apache.org/xalan-C/

Xalan是一个用于把XML文档转换为HTML，纯文本或者其他XML类型文档的XSLT处理器。

软件开发网 www.mscto.Com

C++Markup

参考网站：http://www.firstobject.Com/xml.htm
　这是一种使用EDOM的XML解析器。在很多思路上面非常灵活实用。值得大家在DOM和SAX之外寻求一点灵感。

libxml

http://libxmlplusplus.sourceforge.net/

libxml 是对著名的libxml XML解析器的C++ 封装版本

科学计算

软件开发网 www.mscto.Com

Blitz

参考网站：http://www.oonumerics.org/blitz/

Blitz 是一个高效率的数值计算函数库，它的设计目的是希望建立一套既具像C++ 一样方便，同时又比Fortran速度更快的数值计算环境。通常，用C++ 所写出的数值程序，比 Fortran慢20%左右，因此Blitz 正是要改掉这个缺点。方法是利用C++ 的template技术，程序执行甚至可以比Fortran更快。 Blitz 目前仍在发展中，对于常见的SVD，FFTs，QMRES等常见的线性代数方法并不提供，不过使用者可以很容易地利用Blitz 所提供的函数来构建。

POOMA

参考网站：http://www.codesourcery.Com/pooma/pooma

POOMA是一个免费的高性能的C++ 库，用于处理并行式科学计算。POOMA的面向对象设计方便了快速的程序开发，对并行机器进行了优化以达到最高的效率，方便在工业和研究环境中使用。

MTL

参考网站：http://www.osl.iu.edu/research/mtl/

Matrix Template Library(MTL)是一个高性能的泛型组件库，提供了各种格式矩阵的大量线性代数方面的功能。在某些应用使用高性能编译器的情况下，比如Intel的编译器，从产生的汇编代码可以看出其与手写几乎没有两样的效能。

CGAL
　参考网站：www.cgal.org

Computational Geometry Algorithms Library的目的是把在计算几何方面的大部分重要的解决方案和方法以C++ 库的形式提供给工业和学术界的用户。

游戏开发

Audio/Video 3D C++ Programming Library

参考网站：http://www.galacticasoftware.Com/products/av/

AV3D是一个跨平台，高性能的C++ 库。主要的特性是提供3D图形，声效支持（SB,以及S3M），控制接口（键盘，鼠标和遥感），XMS。

KlayGE

参考网站：http://home.g365.net/enginedev/ 软件开发网 www.mscto.Com

国内游戏开发高手自己用C++ 开发的游戏引擎。KlayGE是一个开放源代码、跨平台的游戏引擎，并使用Python作脚本语言。KlayGE在LGPL协议下发行。感谢龚敏敏先生为中国游戏开发事业所做出的贡献。

OGRE

参考网站：http://www.ogre3d.org

OGRE （面向对象的图形渲染引擎）是用C++ 开发的，使用灵活的面向对象3D引擎。它的目的是让开发者能更方便和直接地开发基于3D硬件设备的应用程序或游戏。引擎中的类库对更底层的系统库（如：Direct3D和OpenGL）的全部使用细节进行了抽象，并提供了基于现实世界对象的接口和其它类。

线程

C++ Threads

参考网站：http://threads.sourceforge.net/

这个库的目标是给程序员提供易于使用的类，这些类被继承以提供在Linux环境中很难看到的大量的线程方面的功能。

ZThreads

参考网站：http://zthread.sourceforge.net/

一个先进的面向对象，跨平台的C++ 线程和同步库。

软件开发网 www.mscto.Com

序列化
s11n
　参考网站：http://s11n.net/
　一个基于STL的C++ 库，用于序列化POD，STL容器以及用户定义的类型。
Simple XML Persistence Library
　参考网站：http://sxp.sourceforge.net/
　这是个把对象序列化为XML的轻量级的C++ 库。

字符串

C++ Str Library

参考网站：http://www.utilitycode.Com/str/

操作字符串和字符的库，支持Windows和支持gcc的多种平台。提供高度优化的代码，并且支持多线程环境和Unicode，同时还有正则表达式的支持。

Common Text Transformation Library

参考网站：http://cttl.sourceforge.net/

软件开发网 www.mscto.Com

这是一个解析和修改STL字符串的库。CTTL substring类可以用来比较，插入，替换以及用EBNF的语法进行解析。

GRETA

参考网站：http://research.microsoft.Com/projects/greta/

这是由微软研究院的研究人员开发的处理正则表达式的库。在小型匹配的情况下有非常优秀的表现。

综合

P::classes

参考网站：http://pclasses.Com/

一个高度可移植的C++ 应用程序框架。当前关注类型和线程安全的signal/slot机制，i/o系统包括基于插件的网络协议透明的i/o架构，基于插件的应用程序消息日志框架，访问sql数据库的类等等。

ACDK - Artefaktur Component Development Kit 软件开发网 www.mscto.Com

参考网站：http://acdk.sourceforge.net/

这是一个平台无关的C++ 组件框架，类似于Java或者.NET中的框架（反射机制，线程，Unicode，废料收集，I/O，网络，实用工具，XML，等等），以及对Java, Perl, Python, TCL, Lisp, COM 和 CORBA的集成。

dlib C++ library

参考网站：http://www.cis.ohio-state.edu/~kingd/dlib/

各种各样的类的一个综合。大整数，Socket，线程，GUI，容器类,以及浏览目录的API等等。

Chilkat C++ Libraries

参考网站：http://www.chilkatsoft.Com/Cpp_libraries.asp

这是提供zip，e-mail，编码，S/MIME，XML等方面的库。

C++ Portable Types Library (PTypes)

参考网站：http://www.melikyan.Com/ptypes/

这是STL的比较简单的替代品，以及可移植的多线程和网络库。

LFC

参考网站：http://lfC.sourceforge.net/

哦，这又是一个尝试提供一切的C++ 库

其他库

Loki

参考网站：http://www.moderncppdesign.Com/

软件开发网 www.mscto.Com

哦，你可能抱怨我早该和Boost一起介绍它，一个实验性质的库。作者在loki中把C++ 模板的功能发挥到了极致。并且尝试把类似设计模式这样思想层面的东西通过库来提供。同时还提供了智能指针这样比较实用的功能。

ATL

ATL(ACtive Template Library)是一组小巧、高效、灵活的类，这些类为创建可互操作的COM组件提供了基本的设施。

FC : The Functional C++ Library

这个库提供了一些函数式语言中才有的要素。属于用库来扩充语言的一个代表作。如果想要在OOP之外寻找另一分的乐趣，可以去看看函数式程序设计的世界。大师 Peter Norvig在 "Teach Yourself Programming in Ten Years"一文中就将函数式语言列为至少应当学习的6类编程语言之一。

FACT!

参考网站：http://www.kfa-juelich.de/zam/FACT/start/index.html

另外一个实现函数式语言特性的库

Crypto

提供处理密码，消息验证，单向hash，公匙加密系统等功能的免费库。

还有很多非常激动人心或者是极其实用的C++ 库，限于我们的水平以及文章的篇幅不能包括进来。在对于这些已经包含近来的库的介绍中，由于并不是每一个我们都使用过，所以难免有偏颇之处，请读者见谅。

资源网站软件开发网 www.mscto.Com

正如我们可以通过计算机历史上的重要人物了解计算机史的发展，C++ 相关人物的网站也可以使我们得到最有价值的参考与借鉴，下面的人物我们认为没有介绍的必要，只因下面的人物在C++ 领域的地位众所周知，我们只将相关的资源进行罗列以供读者学习，他们有的工作于贝尔实验室，有的工作于知名编译器厂商，有的在不断推进语言的标准化，有的为读者撰写了多部千古奇作......

Bjarne Stroustrup http://www.research.att.Com/~bs/

Stanley B. Lippman 软件开发网 www.mscto.Com

http: //blogs.msdn.Com/slippman/ 中文版 http: //www.zengyihome.net/slippman/index.htm
SCott Meyers http://www.aristeia.Com/

David Musser http://www.cs.rpi.edu/~musser/

Bruce Eckel http://www.bruceeckel.Com

Nicolai M. Josuttis http://www.josuttis.Com/

Herb Sutter http://www.gotw.ca/

Andrei Alexandrescu http://www.moderncppdesign.Com/

STL Description

Tue, 22 Jul 2008 07:16:26 GMT

STL can be categorized into the following groupings:

Container classes:
- Sequences:
  - vector: (this tutorial) Dynamic array of variables, struct or objects. Insert data at the end.
    (also see the YoLinux.com tutorial on using and STL list and boost ptr_list to manage pointers.)
  - deque: Array which supports insertion/removal of elements at beginning or end of array
  - list: (this tutorial) Linked list of variables, struct or objects. Insert/remove anywhere.
- Associative Containers:
  - set (duplicate data not allowed in set), multiset (duplication allowed): Collection of ordered data in a balanced binary tree structure. Fast search.
  - map (unique keys), multimap (duplicate keys allowed): Associative key-value pair held in balanced binary tree structure.
- Container adapters:
  - stack LIFO
  - queue FIFO
  - priority_queue returns element with highest priority.
- String:
  - string: Character strings and manipulation
  - rope: String storage and manipulation
- bitset: Contains a more intuitive method of storing and manipulating bits.
Operations/Utilities:
- iterator: (examples in this tutorial) STL class to represent position in an STL container. An iterator is declared to be associated with a single container class type.
- algorithm: Routines to find, count, sort, search, ... elements in container classes
- auto_ptr: Class to manage memory pointers and avoid memory leaks.

http://www.sgi.com/tech/stl/index.html

http://www.cppreference.com/cppstl.html

Infix & preorder & postfix Expression

Fri, 18 Jul 2008 05:51:43 GMT

将中缀表达式转成后缀表达式（逆波兰式）:

1、自左至右扫描表达式，如果不是算符就输出到后缀表达式；
2、是算符，与栈顶运算符比较优先级，
3、当前运算符优先级大，进栈；
4、否则退出栈顶元素，输出到后缀表达式，直到当前运算符优先级小于等于栈顶元素的优先级
5、将当前运算符进栈
6、循环操作，直到表达式为空

将中缀表达式转成前缀表达式的思路：
1）求输入串的逆序。
2）检查输入的下一元素。
3）假如是操作数，把它添加到输出串中。
4）假如是闭括号，将它压栈。
5）假如是运算符，则
       i) 假如栈空，此运算符入栈。
       ii) 假如栈顶是闭括号，此运算符入栈。
       iii) 假如它的优先级高于或等于栈顶运算符，此运算符入栈。
       iv) 否则，栈顶运算符出栈并添加到输出串中，重复步骤5。
6）假如是开括号，栈中运算符逐个出栈并输出，直到遇到闭括号。闭括号出栈并丢弃。
7）假如输入还未完毕，跳转到步骤2。
8）假如输入完毕，栈中剩余的所有操作符出栈并加到输出串中。
9）求输出串的逆序。

上海户外店

Tue, 15 Jul 2008 05:00:11 GMT

百货商店适合：休闲游

　　点评：如果您只是最初级的休闲游，百货商店应该满足你了。几乎所有的百货商店都有运动专柜，买个背包或者运动鞋之类的休闲用品应该够了。不过也有些商店户外品牌比较多，（比如户外店里很少看到的Nikko， The North Face，新品牌Mangrove, 和户外店也有卖的探路者，Lafuma乐飞叶, Northland诺诗兰, Jackwolfskin狼爪,Ozark 奥索卡，Clombia哥伦比亚等）虽然谈不上所有的都很专业，但是选择范围相对还是比较广了。并且还能参加商场经常搞的打折或者抵价活动还是很划算的。这点是户外小店比不上的。

　　推荐商店：

　　梅陇镇伊势丹5楼运动城（户外品牌在百货商场相对算多并且专业）南京西路1038号

　　市百一店东楼7楼（运动品牌很全）上海市南京东路800号

　　徐家汇港汇广场地下名店运动城

户外装备专业小店适合：休闲游深度游户外探险户外露营登山极限运动

　　点评：这类小店往往都在很闹市的地方，比较集中在长乐路，巨鹿路一带，交通方便，便于你在逛小店的时候采购装备。除了品种多，服务专业，这些户外店的背后往往都有个驴子们的精神家园――户外俱乐部。经常组织很多不同级别的户外活动。至于店里面的品牌，价格选择范围比较大，竟管把你的要求和心理价位告诉店员好了，你会得到一场生动的户外起门课。在这里精选一些户外小店。

　　长乐路附近：地铁一号线陕西南路站然后步行

　　野火（长乐路296号，瑞金路口向东20米左右）这家店是我的最爱，东西很多，服务很贴心，口碑很好。在专业小店里一直有着龙头老大的地位。

　　野骆驼（长乐路340号，瑞金路口向西15米左右）这家也是开了有些年头的，口碑也不错。

　　巨鹿路附近：地铁一号线陕西南路站然后步行

　　布波户外（黄色醒目的店铺在一搂，他们三楼定期会有特卖会）

　　天空户外

　　其它：

　　山行者上海市四川北路多伦路153号

　　探险家园　上海市虹口足球场2层11号

　　热风闹市中随地可见　（热风里面有些户外服装，但基本只算凑热闹，不推荐购买）

专业户外卖场　适合：休闲游深度游户外探险户外露营登山极限运动

　　点评：由于多种原因，上海的户外市场不像其他城市，店铺大而全。上海户外店的构成主力军几乎都是小店，在激烈的竞争下，一不留神就销声匿迹再也看不见了，看着辛酸。当然上面介绍的几家都是目前还看起来比较坚挺的。而近几年在上海发展不错的北京三夫上海分店们生意很是红火。还有法国老牌迪卡侬，也成为了更为普及的户外运动品牌。

　　三夫户外：在万体馆的店很大，东西极多，很多朋友都喜欢去那里买东西，服务专业，东西几乎应有尽有。是很多人购买户外用品的首选。名声在外，让人不得不心甘情愿掏钱买单。并且经常有打折活动。

　　万体店：天钥桥路859号2楼交通：一号线三号线四号

　　邯郸店：杨浦区邯郸路391号

　　浦东金桥店：浦东新区金桥碧云路622号(金桥家乐福对面)

　　迪卡侬：来自法国的迪卡侬是沪上老外和很多喜欢运动的市民的首选，不仅是户外用品，这里的运动用品齐并且不贵。市场宣传做得深获民心。

　　花木店:上海市浦东新区银霄路393号

　　长宁店:上海长宁区仙霞西路88号剑河路口

　　金桥店:上海蓝天路600号（碧云体育休闲中心）

　　莘庄店:上海市莘庄工业区申北路2号

　　普陀店:上海市普陀区梅川路1258号(真光路口，百安居旁)

解密微软中国研发集团背后鲜为人知的故事

Mon, 14 Jul 2008 09:17:10 GMT

10年前，比尔·盖茨把研究院落址北京，他实际上是在把微软和中国绑在一起。只是无人预见到这一点。
10年来，微软一直在对中国做着投入，但它被过多的争议和杂音所掩盖。
现在，微软和中国软件产业已经达成共识：微软的发展离不开中国；微软的成功，也必须依附于中国软件产业的成功。从这个角度来看，微软中国研发集团从创立到做大做强，及至目前成为微软在海外最具实力的技术和产品研发基地，这是中国和微软的共同所需。
然而，在此期间，我们不能忘记，李开复、张亚勤、张宏江、沈向洋和洪小文等当年和现在的领军人物，是他们带领着微软在中国的研发事业，在10年中从研究到开发，再到带动中国软件行业的飞速发展。
中国“智”造，惠及全球。回顾10年，他们是如何运用中国智慧？又是如何解决困难并取得辉煌的？
还需要指出的是，比尔·盖茨已于6月27日正式退出微软公司日常管理。在此，本刊特别刊登下文，借以表达我们对这位为全球软件产业作出杰出贡献，推动中国软件产业飞速发展的软件天才的崇高敬意。
1997年12月12日，一贯宁静的清华大学教室，热闹非凡。比尔·盖茨看着台下数千名大学生，思绪万千：此间英才，应归我用。
在回美国的飞机上，盖茨作了最终决定，从印度、日本、中国等国家中，选择在中国设立微软研究院，投资8000万美元。此前，他一直在反复权衡研究院落址三国的利与弊。
10年匆匆过去。回头来看，在飞机上作出的这笔投资换回的巨大回报让习惯于成功的盖茨惊讶：小小的微软中国研究院做大成了微软中国研发集团(以下简称“集团”)，下辖由各领域顶尖人才汇聚而成的微软亚洲研究院、微软亚洲工程院和微软亚洲硬件中心等8家研发机构，员工队伍也由3人迅速膨胀到了1700人，研究经费从0到2亿美元。
论规模和实力，集团成为微软在美国之外规模最大、实力最强的研发团体。Vista Office 2007、Windows Mobile 6.0、Windows Server 2008、Visual Studio 2008、SQL Server 2008等众多为全球用户使用的产品和Microsoft surface等技术背后，都闪烁着来自中国研发团队的智慧。
中国“智”造开始真正惠及全球。
第一章让比尔·盖茨惊叹
德蒙德，微软公司总部二楼的董事长办公室里。
阳光透过玻璃窗照在时任微软中国研究院院长、首席科学家张亚勤博士的脸上，这位以理性和智慧著称的天才正意气风发，向老板盖茨汇报研究院一年来的成绩。

80余篇论文、40项美国专利、60项新技术……一串串不俗的数字让同为天才的盖茨也惊呆了，他已经忘记这个汇报原定时间只有一个小时。虽然老板的助手在一旁屡次催促，张亚勤的汇报仍延迟了四十分钟。最后，这位微软公司的创始人给出的评价是：“你们做了令人难以置信和惊异的工作。”

中国创业

盖茨在中国建研究院的大胆抉择与已在美国的一帮华人精英的想法不谋而合。

张亚勤，山西太原人，12岁进入中国科技大学少年班，毕业后直接去了美国。1998年，年轻的张亚勤已经在美国东部的Sarnoff公司担任多媒体实验室的主任，带领一个团队负责数码影像、多媒体网络、多媒体信息系统等领域的研发工作。此时张亚勤的生活稳定，事业有成，但他总觉得缺点什么。

1998年10月的一天，张亚勤接到了李开复博士邀请他回国的电话。李开复说：“中国从来没有世界级的研究院，我们回去创业，创造历史。”突然间，张亚勤意识到他缺少什么了。那就是：中国，创业！

爱好围棋、喜欢布局的张亚勤没有问研究院具体有多少资金、将要做什么项目，没有考虑回国后的生活待遇、孩子上学等现实问题。几分钟沉默后，他断然作出决定：加入微软，回国创业。

随后，张亚勤很快就想到一个人。而此人当时正在惠普实验室忙于多媒体检索。

他就是张宏江博士，湖北武汉人，成长于河南，文革后中国的首批大学生，先后在丹麦、新加坡、美国取得非凡成就。1994年，他提出的“目录式搜索”解决了视频搜索的难题，成为该领域的“世界第一人”。

在海外华人圈中，“回国”是一份大家都难以割舍的情结，其中，研究人员最大的顾虑是回国后有没有很好的研究平台，能不能发挥自己的才能？张宏江向《IT时代周刊》回忆说，如果精打细算来考虑生活条件和工资待遇，那结论肯定是不回来。甚至，连他生活在国内的父母都不赞成他回来。但在两个月后，在硅谷的一次会议上与张亚勤见面后，对方仅用四个字就打动了张宏江。张亚勤说的是：中国，创业！

被这四个字打动的不止张宏江。在著名的贝尔实验室，毕业于纽约理工大学的朱文武博士已经在那里做了三年的研究员，在视频通信领域颇有建树，前途无量。1999年6月，他接到张亚勤的电话，在听到同样的四个字后，他义无返顾地辞了工作。1999年 10月，朱文武回到北京。

沈向洋博士、李劲博士、张益肇博士和周明博士等十几位在各自领域已成名人的年轻学者，在李开复和张亚勤的带动下，带着尖端技术回到国内，他们要在祖国实现当科学家的梦想。

扎根中关村

1998年末，中国硅谷——中关村处在热火朝天的大建设时期，到处都是工地，空气中漂浮着灰尘，机器轰鸣声不绝于耳。

微软中国研究院正式选址在距离北京各高校都比较近的中关村希格玛大厦五层。租来的楼层尚未装修完毕，张亚勤时常和同事跑到还是粗砂水泥地板、灰白墙面的空旷办公室里，兴奋又认真地比划着未来：“这里是大家讨论的地方，这里可以作为我们的实验室，这里是办公室，那边留给实习生……”

带着激情和梦想，首批回国的微软华人精英开始了他们的创业。

由于都是老本行，研究院的工作渐渐步入正轨。1999年末，张宏江成立了第二个项目小组，研究多媒体数据管理和搜索，进一步完善了研究院在多媒体领域的研究。

研究院中的“本土”研究员和实习生也快速成长，到2000年6月底，他们已经在全球最优秀的学术刊物和会议上发表了80余篇论文；在网络协议领域，申请注册了40项美国专利；做出了60项新技术；并已有8项成熟技术转化到微软产品部门中。

奇迹还在延续。世界多媒体大会是该领域最权威的会议，每年只会从全球500篇优秀论文中选出最优秀的45篇进行演讲。在1998年前，几乎没有来自中国本土的学者出现在大会上。但在2003年，研究院的论文占到大会的一半。“这个数字让人恐怖。”张宏江有点得意地说。

研究院在国际上的名声越来越大。日本、新加坡等国家也都希望拥有类似机构，但这并不现实。

2001年夏天，张亚勤给盖茨写了一份E-mail提到这个问题，希望能够把中国研究院升级为亚洲研究院，以便把研究院的影响范围再扩大一些，也更方便与各国高校建立起学术交流合作。2001年11月1日，在得到盖茨和鲍尔默的极力支持后，微软中国研究院升级为微软亚洲研究院，这标志着中国人的IT智慧将走出国门，辐射亚洲和全球。

第二章创立微软亚洲工程院

2003年，微软总部的一间小会议室里，张亚勤又和老板坐到了一起。此时的他满面通红，像个二十来岁的小伙子一样激动，他正在和CEO史蒂夫·鲍尔默阐述自己的新设想——设立微软亚洲工程院。

早在回国创业时，张亚勤、张宏江等人就有一个远大的目标：依靠中国人才，建立一个世界一流的研发团队。但苦于缺乏人才和经验，一开始他们只能建立有研究无开发的研究院。即便如此，在研究院成立时，这些创始人还是定下了一个硬规定，将创新技术转化为产品开发应当重点考虑。

2003年下半年，张亚勤和张宏江等人达成一致：是做产品开发的时候了。大家说干就干。

几天之后，张亚勤将全部观点系统化，通过电子邮件发给负责全球研究院工作的高级副总裁里克· 雷斯特。张亚勤着重谈论了自己从1999年开始在国内多所大学作演讲时的感受：“没有一次少于千人，每次都会收到许多有意思有水平的问题。”他还特别强调，如果只开设研究院，微软只能得到中国人丰富智慧中极其微小的一部分。

此外，张亚勤还为这个新孵化的机构设立了四个目标：加速研究技术到产品的转化，开发面向全球用户的产品；开发满足中国市场用户需求的全新技术和产品；孵化在中国创造的技术再推广到其他新兴市场；成为在中国培养大型软件工程开发工程师的“黄埔军校”。

看到张亚勤的描述，雷斯特震动了，错过中国优秀的人力资源将是微软的损失，更是自己工作的过失。兹事体大，他直接将报告转给了盖茨和鲍尔默。于是有了前述鲍尔默约见张亚勤的一幕。

微软公司的CEO对这位中国下属表现得完全相信。最后，老板这样对下属说的：“我完全同意在中国成立工程院的想法。只要有能力，你招多少人我都批。”

鲍尔默的话不多，但意义重大，这是微软历史上是第一次对海外分公司充分予以人事权。这让张亚勤感到热血在上涌。

2003年11月，在微软亚洲研究院成立5周年之际，微软在中国的研发进入第二阶段。作为里程碑的标志，微软亚洲工程院在北京中关村成立。

　挖美国总部的墙脚

但是，微软亚洲工程院的开局并不好。

2004年1月，在张亚勤的办公室里，气氛沉闷。办公室的人一脸凝重地看着张宏江：“今后就靠你了。”身材高大的张宏江没说什么，用手拍了拍胸口，算是对老同事兼老朋友的承诺。

此前不久，张亚勤获得升迁调令，回雷德蒙德当微软全球副总裁。

一力承担起工程院院长责任后，张宏江发现这里最缺乏的就是人。没有人，一切免谈。

工程院朝气蓬勃，雷厉风行。他们开始了大规模的人才招聘。当时，已有十多个新项目和产品开发列入日程，短时间内便需将人员备齐。但工程院还没有人事部门，新员工必须依靠张宏江等人慧眼识才，他们在5个月里，跑11个城市，收取了1万多份简历，然后从中挑选百来人。

这可苦了长年跟技术打交道的学者们。“不说别的，从1万份简历中挑选出合适人选，就要十几个人没日没夜的忙好几天，何况还有好几轮面试！”张宏江回忆说，“当时整个工程院的人员都是满负荷运行，白天面试，晚上总结讨论并下通知，许多员工连续三个月没有休假，也没有睡个饱觉。”“这主要是创业激情在支撑着我们！”张宏江这样总结。

不过，当时的中国软件业虽然发展迅速，但尚未积累出太多有丰富大型软件项目开发经验的中高级人才，国内大多数开发人员只能把单个程序写好，却不懂怎样调用程序。

对于工程院来讲，底层的开发人员和统领全局的项目管理人员，一个都不能少。要让工程院名副其实，统领全局的骨干力量必不可少。上哪找这样的人？张宏江将眼光投向了雷德蒙德，他要去总部“挖墙脚”。他知道那里有3000多名杰出的华人研究员。太有诱惑力。

2004年初，美国微软总部来了一群怪人。在每次内部讲座中，别人讲技术发展或者IT行业形势，这群人却是张口即夸中国有多好，改革开放以来中国取得了哪些成就，在中国工作前景多光明等等。这让许多员工感到奇怪，什么时候请中国政府的人参加讲座了。

当然，这些人并不代表中国政府，他们都是工程院的员工，他们这样做是吸引更多华人和与中国有关系的同事加盟。

“墙脚”很快被挖了来。

参加过近十个微软产品开发的萧圣璇、郭蓓菁回来了；有着近二十年软件架构开发经验的架构师 Sin Lew回来了；在微软总部被当作未来高管培养的芮勇也回来了。先是中国人，再是“老外”Robert Parker也来了。他是Powerpoint的领军人物之一，参加过Office7个版本的研发。像这样被吸引的人很多，如集团战略合作部资深总监申元庆、集团人力资源部总监毛丹妮，工程院创意总监Dave Vronay。根据张宏江统计，5年间工程院前后吸引了100多名员工从美国来到中国。

有了这些海外来的骨干，工程院的发展一日千里。

娶了中国媳妇的Dave Vronay来自南加州，习惯了北京生活的他现在早上喜欢吃油条，被同事们戏称为KTV“麦霸”。他还清楚地记得，他刚加入工程院时招了一批绘画方面的员工，这些人来时都十分骄傲，认为设计软件界面是小菜一碟，他们瞧不起这个老外稍微画个图就四处征询他人意见的做法。Dave并未说什么，他只希望用事实来帮助这帮小年轻们转变观念。

不久，工程院接到专为五星级酒店开发桌面电脑操作系统的项目，由Dave团队设计操作界面。一些新员工未作调查，一味从奢华上做文章，想当然地用水晶、大理石等华丽、昂贵的元素设计了一个十分豪华的界面。结果却是，宾馆方面需要低调和干净的界面。在Dave的言传身教下，新员工意识到软件界面设计也需要遵循市场需要。

类似的情形在各个项目组轮番上演，渐渐地，工程院的员工素质跟上了国际水平。

从求来项目到项目来求

在“找人”的同时，张宏江还必须“找项目”。

“这个项目能不能让我们做，我们一定会做好的。”张宏江多次缠着张亚勤要项目。此时张亚勤在微软总部负责的移动设备及嵌入式系统产品开发部门，子项目众多，也急需其他产品开发部门配合。但是，他也不敢过度相信刚把人员配齐的工程院，他不能给张宏江“开绿灯”，而总是说：“你去找下面的项目经理吧。”于是，张宏江去找项目经理，对方的回答是：中国团队还没有经验，项目不敢交给你们。

这是2004年上半年张宏江经常遇到的尴尬一幕。并不服输的他为此在半年多时间内不停飞赴美国总部，向众多产品部门推销自己，这让很多人都听到过他富有激情的游说：“我们有中国最顶尖学校的最优秀的人才，这些人才是从一万个人中挑选出来的几十个。”遗憾的是，产品经理们还是选择了观望。

几个月后，张亚勤管理的一个产品开发部门在一个手机摄像头软件项目上出现问题，进度被耽搁，微软许多有实力的项目组都不敢接这一“烫手山芋”。就在该项目的经理准备采用别的公司的技术之时，张亚勤想到了工程院。

张亚勤将实情告诉了张宏江，张宏江没有犹豫，拍着胸脯说“行”，接下了工程院第一个核心项目。

当时负责这个项目的经理张益肇回忆道，手机摄像头软件半年后就要发布，张宏江切断了所有退路，工作人员争分夺秒地进入紧张开发状态。白天自己开发，晚上等到美国同事上班后，他们或继续工作，或在家里用电话跟美国同事沟通。“十一”假期、农历春节都没有休息。最终，工程院团队交出了一份满意的答卷，证明了“中国团队的技术实力和开发决心并不差”的事实。

工程院在微软总部一战成名。此后，找上门来的项目慢慢增多，许多产品部门希望与他们合作，进而提出做新项目的要求。张宏江终于不用去美国“推销”了，他只需端坐在北京，从众多合作意向中挑选适合工程院长期发展战略的项目。

有了项目的“供养”，工程院的人数成长迅速，到2008年初已经达到了400人。据介绍，等集团总部大楼建好，员工的数量将增至700人。

在研究院、工程院接连成功的鼓舞下，微软增加了在中国投资的信心。后来的服务器产品部门采取了更加直接的办法。

2005年2月，出身于上海的谢恩伟(现任微软中国研发集团服务器及开发工具事业部(中国) 总经理)带着四五百万美元的种子基金，三名经理级别的员工和两个项目回国，直接在上海投资建立服务器产品开发部门。经过三年的发展，微软服务器很多核心功能在中国上海完成了开发。

今年3月12日，微软的新一代服务器操作系统、开发工具和数据库服务器产品发布会在北京体育馆召开，暖场的音乐居然是二胡和京剧。微软希望借这种氛围传递出明确的信号：产品背后有浓重的中国元素。

高速公路上换轮胎

中国研发集团在磨炼中逐步走向成熟，一些不曾预料到的问题开始显现出来。

2005年10月，一位被张宏江看好的员工提出辞职。张觉得十分奇怪，微软的待遇不错，前景光明，为什么要辞职？在交流中，张了解到，该员工认为微软是挺不错的，但是将近做了3年，名片上印的还是开发工程师，至今还是个普通的开发人员，而他的同学在其他公司已经是产品经理等“头头”了，他觉得自己在微软“前途”渺茫。

这让张宏江大吃一惊。他趁机和人力资源部做了个调查，结果让人心情沉重。

工程院里不少员工都认为发展路线就是成为团队领导，然后成为部门领导甚至院领导，否则就是职业生涯的失败。几乎没有多少人认识到从普通的开发人员做到资深架构师也是一种职业发展途径。

然而，无论是做基础研究，还是做产品开发，无论是有3年、5年经验的年轻技术员，还是几十年经验的资深技术人员，都是一个项目组中不可或缺的部分。但如果员工人人思“官”，对于一个研发机构来说，前途可想而知。这个问题必须解决。

张宏江认为首先要使大家对技术开发产生浓厚的兴趣，而不是视开发经验为“官位”的垫脚石。他想到了两条对策。

首先，让榜样现身说法。张宏江利用各种机会请总部资历丰富的开发人员和软件架构师来工程院做讲座，把技术开发的乐趣讲出来。同时引入了微软特有的 Mentor (导师)“传帮带”企业文化。

所谓Mentor，是指每个新员工都可以找一个老员工做领路人，两人定期交流，传承对技术开发的兴趣，以让新员工尽快进入状态。如张亚勤的Mentor就曾是盖茨。

另一个方法是举办专为激发开发人员技术创新的大赛。比赛期间，任何员工都可以通过专业人士的帮助把一个创新的想法变成可以展示的技术提案。经过投票、评审，有市场前景且可能实现的方案，工程院就会采纳并加以实施。

这两种办法的效果如何，很难有精确的办法统计。但是，毛丹妮和她的人力资源团队为研发集团带来的全方位的人事培养体系有效改变了一些根深蒂固的“官本位”思想。

2006年初，在雷德蒙德专门负责招聘的微软副总裁级别的毛丹妮，应张亚勤等人之邀来到中国。当知道面临的困难后，她所做的第一件事就是员工调查。她发现，大部分员工加入微软的首要理由是觉得这里有很好的职业发展前景。针对这一点，毛丹妮带领同事立刻开展工作，让大家感觉到公司将他们的期待放在第一位。接下来，工程院开展了各种各样的培训，数量之多无法统计。但这些培训都有一条基本原则：对每一位员工都要有促进。

第二步，毛丹妮带领人力资源部对所有员工做了职业发展计划。让员工选择未来的发展道路，然后再告诉员工，如果选择这一发展道路的话必须付出哪些努力，在哪些方面做提升。这让大家对职业发展有了更清晰的认识——原来自己不适合做“官”。

员工的心思渐渐稳定下来。从2006年至今，微软在中国的研发部门人员从500人增加到了1700人，离职率远远低于业内平均水平。对此，毛丹妮形象地比喻说：“我们成功地在高速行驶中更换了轮胎。”

随着规模的扩大、实力的增强，2006年1月18日，张亚勤再次回国，将微软亚洲研究院、微软亚洲工程院以及一些产品研发部门整合成微软中国研发集团。自此，中国成了微软海外最大的研发基地。

第三章中国“智”造

2007年4月19日，清华大学，盖茨身穿庄重的博士服，郑重承诺：“微软公司愿意帮助中国公司的成长，帮助所有的中国公民享受到计算机科学进步所带来的成果。”他所说的远远不是微软已经捐资设立了五所希望小学和五所网上希望小学等教育机构。在微软中国研发集团的带动下，微软在中国的影响越来越大。

在张亚勤的意识里，只有为中国市场设计产品，带动了中国IT行业的发展，微软在中国的研发才算成功。

中国发明

手机做主机，电视做屏幕，接上鼠标和键盘，就具有了PC功能，可以去互联网上冲浪，也可以看电影、听音乐。这个具有手机外形，功能远超手机的产品叫Fone+，是地道的“中国发明”，也是第一个以发展中国家为主要市场的微软产品。

中国有2亿互联网用户，6亿手机用户，如果可以针对他们开发产品，向发展中国家的市场推广，将对微软有重大意义。Fone+因此应运而生。在中国农村市场，愿意付费买PC的人并不一定多，但买附带简单PC功能的手机，他们可能会很乐意。

来中国两年，工程院产品策划经理刘伟瀚对中国市场的结构特点颇有心得，他从一个不受市场欢迎的技术中得到了新的启发，根据中国手机用户的使用习惯设计在手机上实现与“群”沟通的功能。这项技术已经与三星展开合作，并应用在今年5月21日推出的三星i728 Windows Mobile智能手机中。

目前，工程院的孵化组已经从十个项目中成功“孵”出了两个产品，而医疗和教育领域的孵化工作成为工程院进军新兴市场的“重点”，分别由微软的两位“精兵强将”郭蓓菁和芮勇担任工程总监。

清华大学研究生毕业后就出国的芮勇，对孵化与教育相关的产品具有很大的激情。他的主要任务就是把微软技术与中国教育相结合，孵化出这一市场空白的产品。

负责医疗领域的工程总监郭蓓菁外表看不像软件工程师，更像一个艺术家。她穿着鲜艳，是以灰色为主色调的研发机构中的一道风景。同事们佩服的是她十分干练。

郭蓓菁领导着一支三十多人的团队，他们经常出入中国的大小各类医院，寻找技术和医疗需求的集合点。对于计划中的针对农村市场的远程医疗产品，或个人医疗健康管理的产品，她开玩笑地说，“希望能早点把产品孵化出来，从工程院‘毕业’。”

微软给的不仅是钱

“这样绝对不行！”

2006年5月，集团战略合作部资深总监申元庆直接将下属递交的计划书扔到垃圾桶里。这是一份关于召开外包CEO峰会的计划书，计划花8万元在一个五星级饭店，用半天时间举办。但是，申元庆认为，匆匆的半天会议不能起什么作用，微软需要与中国的外包企业作深入研讨。

申元庆大笔一挥，会议经费增加到10万美元，时间定为2天1夜，他还特别将会议地点选到手机信号不好的长城脚下的公社酒店，以便与会者少受外界干扰。大会的第一天大雾弥漫，就这样，神州数码的CEO郭为、浪潮的CEO孙丕恕等17家国内著名外包公司的头头悉数到场，会议成果和效率远超策划预期。

不过，在交往中，申元庆注意到中国外包企业存在明显弱点。比如，中国外包企业对自己的实力以及微软的项目都不够了解，为了拿到微软的外包项目，他们会不加分析地就说“好”。但如果同样的谈判发生在印度，印度公司会非常清楚地告诉微软，项目会怎么进展，在哪个阶段可能遇到怎样的困难或者需要的帮助。

于是，申元庆改变了角色，他不厌其烦地教导国内软件业的谈判代表该怎么做，该如何对项目核心了解得更深刻，如何分工，如何操作等细节。对此，许多外包企业代表都笑称他是“身在曹营心在汉”。

作为微软在国内的首家战略合作伙伴，中软国际就从中获益颇丰。中软国际高级副总裁孙秀芳在回忆自己与微软的合作经历时，告诉《IT时代周刊》：“我们跟微软的合作，得到的不仅仅是钱。”

现在，中软国际与微软的合作项目中，派驻开发和自己内部开发大约是3：7。而且，中软国际的工作人员可以与微软员工一起参加培训，把培训对方的录像带录下来反复使用。公司内部还建起了经过微软认证的软件开发办公区，有微软的安全保障措施。

此外，为了更好地与中国软件外包企业打成一片，从2007年开始，微软中国研发集团开始举办 “中国商务交流日”，让国内公司的管理者到微软总部“推销自己”。“作为发包的‘甲方’，微软组织我们去美国总部推介自己实属少有。”孙秀芳为微软的诚意所感动。

通过一系列的举措，微软带动了中国软件生态圈的发展。近期，张亚勤在大连参加软交会时给出最新数据，2007年，微软给中国软件公司的外包金额高达1亿美元。另据IDC的数据，微软在中国赚1美元，合作伙伴赚16美元，整个IT行业的1/3的收入及1/3的就业岗位是由微软及其生态圈创造的。

不仅外包企业，连中关村都能从微软身上受益。中关村科技园区管理委员会副主任夏颖奇就谈起一件逸事：有一位在IT行业举足轻重的跨国公司老总来中关村参观，当他听说微软在这里设立了研发中心时，脸立刻沉下来，直接质问随从：“微软都选择了这里，为什么我们没来？”随后不久，这家公司就进驻了中关村。“微软提升了中关村的价值。”夏颖奇说。

优秀是卓越的敌人

2008年5月6日，在隆重的仪式中，微软中国研发集团在北京中关村举行了集团总部大楼的奠基仪式。这个即将落成的大楼在海龙大厦的电子大卖场附近，搬材料器械的小工四处乱闯，一切都看上去是乱糟糟的。为什么要将未来微软5000人的“家”安置在这里？张亚勤说：“我们仍在创业，这里充满了活力，有创业的氛围。”

十年建立起微软海外最大的研发基地，拥有1700名中国最好的人才，年研发经费超过2亿美元，参与微软最核心的项目，多次被盖茨、鲍尔默等领导赞扬……但是张亚勤并未满足。

优秀是卓越的敌人，这是张亚勤经常挂在嘴上提醒自己和员工的。虽然现在微软中国研发集团各方面都很优秀，但是离世界一流研发团队的目标还有很长的路要走。

盖茨和鲍尔默衡量微软中国研发集团成绩有三个指标：第一是不是雇到了一流的人才；第二是不是有很强的创新能力，真的是成为微软创新的源泉；第三是到底对产业生态系统、中国作出了多少贡献。根据这个，微软中国研发集团的职能被张亚勤用RIDE来概括，R是研究(Research)，I是孵化(Incubation)，D是发展(Development)，E是产业合作(Ecosystem)。

毛丹妮透露，她来到中国的时候，微软中国研发总共只有500人，张亚勤就明确地告诉她，她的任务就是3年内招3000人。这意味着，在接下来的一年内，毛丹尼还要招1300人。

“我们还在创业。”面对窗外冉冉升起的太阳，张亚勤十分严肃。

抗氧化食物

Fri, 11 Jul 2008 09:29:35 GMT

   近年来，“抗氧化”饮食概念逐渐成为我们生活中的关键词。营养学家常常推荐我们多吃番茄、绿茶、葡萄等食物，以摄入其中具有抗氧化功能的营养素，抵抗自由基对我们身体的危害，达到延缓衰老、抵抗疾病、增强体质等目的。什么叫做自由基、抗氧化，哪些营养素具有“抗氧化”性?
    自由基与抗氧化
    所谓自由基，是指外层带有一个未成对电子的原子、分子或基团。它具有较强的氧化性，会攻击细胞及组织，引起连锁性的氧化反应。医学研究证明，许多疾病如心血管疾病、肿瘤、癌症、皮肤黑斑沉积、白内障、老年痴呆等以及免疫功能、衰老等生物过程都与自由基有着密切的关系。可以说，自由基是人体疾病、衰老，甚至死亡过程的制造者、加速器。
    大家都知道，铁在空气中会生锈，这是因为铁离子被空气中的氧气氧化所致，我们的身体也是一样，如果被过多的自由基氧化、组织、细胞的生理功能就会逐渐衰弱，健康受到损害。
    空气污染、电脑辐射、过度运动、饮食不当，阳光辐射等，都是造成体内自由基生成增多的原因。而多食抗氧化食品，或补充具有抗氧化性的营养素，就能够减轻自由基的氧化作用，提高身体抗氧化能力，维持身体健康，延缓衰老进程。
    明星食品谱
    1.番茄红素
    番茄红素是目前为止发现的抗氧化功能最强的营养素，抗氧化活性是维生素E的100倍。每天摄入10毫克番茄红素，对于清除体内自由基、消除疲劳、提高身体免疫力有明显的促进作用。
    许多研究实验都从不同角度证明了它对人体的益处，如可以预防和抑制肿瘤、癌症，保护心血管，提高男性生殖能力，抗辐射、保护皮肤等。
    番茄红素主要存在于番茄、西瓜、蜜柚等食物中，在新鲜成熟的番茄中含量最高，可达31～37毫克／公斤，番茄皮中番茄红素含量更高。一般来说，番茄颜色越红，番茄红素含量越高，而在未成熟或半成熟的番茄中的含量相对较低。
    由此看来，我们应该多吃些番茄。但是食用方法不当也不能很好地获得番茄中的营养。番茄红素属于脂溶性类胡萝卜素的一种，它的吸收和转运必须溶于油或脂肪中才能利用，所以，食用烹炒的番茄或者番茄酱会有利于番茄红素的吸收。番茄红素的热稳定性较高，加热可使番茄细胞裂解，比生食更易被人体吸收利用。
    为了更好地摄入番茄红素，市场上出现了专门补充番茄红素的营养食品。在选择这些营养食品时，建议你不仅要考虑其价格，还要考虑其番茄红素的含量和质量。一般来讲，番茄红素的含量是决定产品质量、效果的主要因素。目前，市面上比较多见的是胶囊装番茄红素。也就是说，一粒番茄红素胶囊中番茄红素的含量越高，则产品的功效越佳，当然，价格也会相应高一些。此外，番茄红素的来源也很重要，高品质的番茄红素采用提纯方法从日照充足的番茄中获得，能够保证产品的强抗氧化性。
    2.葡萄籽提取物
    葡萄籽中的提取物原花青素是一种高效抗氧化剂之一。研究表明，其抗氧化能力为维生素C的20倍、维生素E的50倍。
    葡萄籽提取物的抗氧化性主要表现在清除血脂、改善心脑功能，强壮血管壁、增强微循环，抵抗紫外线侵害，增加免疫功能，缓解过敏症状等方面，能有效保护人体细胞、组织免于自由基的氧化损伤。
    红色，紫色以及蓝色的水果，如蓝莓、草莓中，以及红茶和绿茶中，都含有一定的原花青素，但是含量远不及葡萄籽中的含量高，建议大家“吃葡萄不吐葡萄籽”。用葡萄酿成的红酒因经过发酵，其抗氧化能力得以大大提高，所以适量饮用些红酒，脸上的皱纹会出现得晚一些，皮肤衰老迹象也会少得多。
    3.抗氧化维生素
    具有抗氧化作用的维生素有维生素E、胡萝卜素和维生素C，都可以非常活跃地收集和
    清除自由基。其中，前两者用于保护身体中的脂类，而维生素C更善于清除来自被污染的空气，烟雾中的自由基。
    在常见食物中，维生素E含量名列前茅的是葵花子，松子和花生，而富含维生素C的食物有青椒、菜花、猕猴桃、草莓、荔枝、鲜枣等；胡萝卜素在深色蔬菜和水果中的含量也很多，如西兰花、胡萝卜、菠菜、哈密瓜、芒果、橘子等。
    4.天然色素
    类黄酮类化合物是一类广泛分布于植物中的红蓝色水溶性色素，具有清除氧自由基及抑制脂质过氧化的能力，它在苹果中的含量较高。研究表明，每天吃2～3个苹果，可使男性心脏病死亡率下降一半。此外，洋葱、香菜、胡萝卜、紫茄子、南瓜、草莓、绿茶等食物中也含有较多的类黄酮。
    黑色食品中的黑色素和绿色蔬菜中的叶绿素，对自由基也有清除作用，建议也要多多食用。
    5.调料的妙用
    部分调味品也具有一定的抗氧化性，经常食用，对抗氧化系统也有帮助。具有抗氧化功能的调料主要有酿制调料，如醋、面酱等；还有部分香味，辛辣调料，如芝麻油、茴香、生姜、红辣椒、葱白、大蒜、咖喱、芥末等，烹调食品的时候，适当地添加上述调料，不仅能够使菜肴的色香味更佳，还能够增加抗氧化营养的摄入，有利于身体的健康

C/C++头文件一览

Fri, 11 Jul 2008 08:02:53 GMT

C、传统 C++
#include <assert.h>　　　　//设定插入点
#include <ctype.h>　　　　 //字符处理
#include <errno.h>　　　　 //定义错误码
#include <float.h>　　　　 //浮点数处理
#include <fstream.h>　　　 //文件输入／输出
#include <iomanip.h>　　　 //参数化输入／输出
#include <iostream.h>　　　//数据流输入／输出
#include <limits.h>　　　　//定义各种数据类型最值常量
#include <locale.h>　　　　//定义本地化函数
#include <math.h>　　　　　//定义数学函数
#include <stdio.h>　　　　 //定义输入／输出函数
#include <stdlib.h>　　　　//定义杂项函数及内存分配函数
#include <string.h>　　　　//字符串处理
#include <strstrea.h>　　　//基于数组的输入／输出
#include <time.h>　　　　　//定义关于时间的函数
#include <wchar.h>　　　　 //宽字符处理及输入／输出
#include <wctype.h>　　　　//宽字符分类
//////////////////////////////////////////////////////////////////////////
标准 C++　（同上的不再注释）
#include <algorithm>　　　 //STL 通用算法
#include <bitset>　　　　　//STL 位集容器
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex>　　　　 //复数类
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>　　　　　 //STL 双端队列容器
#include <exception>　　　 //异常处理类
#include <fstream>
#include <functional>　　　//STL 定义运算函数（代替运算符）
#include <limits>
#include <list>　　　　　　//STL 线性列表容器
#include <map>　　　　　　 //STL 映射容器
#include <iomanip>
#include <ios>　　　　　　 //基本输入／输出支持
#include <iosfwd>　　　　　//输入／输出系统使用的前置声明
#include <iostream>
#include <istream>　　　　 //基本输入流
#include <ostream>　　　　 //基本输出流
#include <queue>　　　　　 //STL 队列容器
#include <set>　　　　　　 //STL 集合容器
#include <sstream>　　　　 //基于字符串的流
#include <stack>　　　　　 //STL 堆栈容器　　　　
#include <stdexcept>　　　 //标准异常类
#include <streambuf>　　　 //底层输入／输出支持
#include <string>　　　　　//字符串类
#include <utility>　　　　 //STL 通用模板类
#include <vector>　　　　　//STL 动态数组容器
#include <cwchar>
#include <cwctype>
using namespace std;
//////////////////////////////////////////////////////////////////////////
C99 增加
#include <complex.h>　　 //复数处理
#include <fenv.h>　　　　//浮点环境
#include <inttypes.h>　　//整数格式转换
#include <stdbool.h>　　 //布尔环境
#include <stdint.h>　　　//整型环境
#include <tgmath.h>　　　//通用类型数学宏

排列组合

Fri, 11 Jul 2008 02:59:16 GMT

组合算法
本程序的思路是开一个数组，其下标表示1到m个数，数组元素的值为1表示其下标
代表的数被选中，为0则没选中。
首先初始化，将数组前n个元素置1，表示第一个组合为前n个数。
然后从左到右扫描数组元素值的“10”组合，找到第一个“10”组合后将其变为
“01”组合，同时将其左边的所有“1”全部移动到数组的最左端。
当第一个“1”移动到数组的m-n的位置，即n个“1”全部移动到最右端时，就得
到了最后一个组合。
例如求5中选3的组合：
1   1   1   0   0   //1,2,3
1   1   0   1   0   //1,2,4
1   0   1   1   0   //1,3,4
0   1   1   1   0   //2,3,4
1   1   0   0   1   //1,2,5
1   0   1   0   1   //1,3,5
0   1   1   0   1   //2,3,5
1   0   0   1   1   //1,4,5
0   1   0   1   1   //2,4,5
0   0   1   1   1   //3,4,5

全排列算法
从1到N，输出全排列，共N！条。
分析：用N进制的方法吧。设一个N个单元的数组，对第一个单元做加一操作，满N进
一。每加一次一就判断一下各位数组单元有无重复，有则再转回去做加一操作，没
有则说明得到了一个排列方案。

/***********************************************/
void shift(char str[],int m) /*定义循环左移函数*/
{
int i,j;
char temp=str[0];
for (i=0;i<m;i++) str[i]=str[i+1];
str[i]=temp;
}
void permutation(char str[],int m,int n) /*定义全排列函数*/
{
int k;
void shift(char str[],int m);
if (m<n)        /* 定义递归调用出口 */
{
   for (k=0;k<=m;k++)
    {
     permutation(str,m+1,n); /*递归调用*/
     shift(str,m); /*调用左移函数*/
    }
}
else printf("%s\t",str);
}
#include "stdio.h"
main()
{char str[]="ABCD"; /*全排列字符,可以任意多个(相应的下面排列函数中参数"4"改成全排列字符的个数)*/
clrscr();
permutation(str,0,4); /*这里参数0(下标)表示从第一个元素开始,4表示元素个数(不是下标)*/
getch();
}
/*********************************************/

下面我来解释一下,我花了近1天的时间,找到这样一个规律如下:
                           ┏ ABCD
                           ┣ BCDA
                 ┏ ABCD ━┫
                 ┃        ┣ CDAB
       ┏ ABCD ━╋ BCAD   ┗ DABC
       ┃        ┃         .
       ┃        ┗ CABD    .
ABCD ━┫                   .
       ┃        ┏ BACD    .
       ┃        ┃         .
       ┗ BACD ━╋ ACBD   ┏ CBAD
                 ┃        ┣ BADC
                 ┗ CBAD ━┫
                           ┣ ADCB
                           ┗ DCBA
简化图如下所示 ==>
                     ┏ ABCD
                     ┣ BCDA
            ┏ ABC ━┫
            ┃       ┣ CDAB
    ┏ AB ━╋ BCA   ┗ DABC
    ┃      ┃        .
    ┃      ┗ CAB    .
A ━┫                .
    ┃      ┏ BAC    .
    ┃      ┃        .
    ┗ BA ━╋ ACB   ┏ CBAD
            ┃       ┣ BADC
            ┗ CBA ━┫
                     ┣ ADCB
                     ┗ DCBA

Knuth-Morris-Pratt string matching

Thu, 10 Jul 2008 09:26:28 GMT

The problem: given a (short) pattern and a (long) text, both strings, determine whether the pattern appears somewhere in the text. Last time we saw how to do this with finite automata. This time we'll go through the Knuth-Morris-Pratt (KMP) algorithm, which can be thought of as an efficient way to build these automata. I also have some working C++ source code which might help you understand the algorithm better.

First let's look at a naive solution.
suppose the text is in an array: char T[n]
and the pattern is in another array: char P[m].

One simple method is just to try each possible position the pattern could appear in the text.

Naive string matching:

    for (i=0; T[i] != '\0'; i++)
    {
    for (j=0; T[i+j] != '\0' && P[j] != '\0' && T[i+j]==P[j]; j++) ;
    if (P[j] == '\0') found a match
    }

There are two nested loops; the inner one takes O(m) iterations and the outer one takes O(n) iterations so the total time is the product, O(mn). This is slow; we'd like to speed it up.

In practice this works pretty well -- not usually as bad as this O(mn) worst case analysis. This is because the inner loop usually finds a mismatch quickly and move on to the next position without going through all m steps. But this method still can take O(mn) for some inputs. In one bad example, all characters in T[] are "a"s, and P[] is all "a"'s except for one "b" at the end. Then it takes m comparisons each time to discover that you don't have a match, so mn overall.

Here's a more typical example. Each row represents an iteration of the outer loop, with each character in the row representing the result of a comparison (X if the comparison was unequal). Suppose we're looking for pattern "nano" in text "banananobano".

         0  1  2  3  4  5  6  7  8  9 10 11
      T: b  a  n  a  n  a  n  o  b  a  n  o

    i=0: X
    i=1:    X
    i=2:       n  a  n  X
    i=3:          X
    i=4:             n  a  n  o
    i=5:                X
    i=6:                   n  X
    i=7:                         X
    i=8:                            X
    i=9:                               n  X
    i=10:                                 X

Some of these comparisons are wasted work! For instance, after iteration i=2, we know from the comparisons we've done that T[3]="a", so there is no point comparing it to "n" in iteration i=3. And we also know that T[4]="n", so there is no point making the same comparison in iteration i=4.

Skipping outer iterations

The Knuth-Morris-Pratt idea is, in this sort of situation, after you've invested a lot of work making comparisons in the inner loop of the code, you know a lot about what's in the text. Specifically, if you've found a partial match of j characters starting at position i, you know what's in positions T[i]...T[i+j-1].

You can use this knowledge to save work in two ways. First, you can skip some iterations for which no match is possible. Try overlapping the partial match you've found with the new match you want to find:

    i=2: n  a  n
    i=3:    n  a  n  o

Here the two placements of the pattern conflict with each other -- we know from the i=2 iteration that T[3] and T[4] are "a" and "n", so they can't be the "n" and "a" that the i=3 iteration is looking for. We can keep skipping positions until we find one that doesn't conflict:

    i=2: n  a  n
    i=4:       n  a  n  o

Here the two "n"'s coincide. Define the overlap of two strings x and y to be the longest word that's a suffix of x and a prefix of y. Here the overlap of "nan" and "nano" is just "n". (We don't allow the overlap to be all of x or y, so it's not "nan"). In general the value of i we want to skip to is the one corresponding to the largest overlap with the current partial match:

String matching with skipped iterations:

    i=0;
    while (i<n)
    {
    for (j=0; T[i+j] != '\0' && P[j] != '\0' && T[i+j]==P[j]; j++) ;
    if (P[j] == '\0') found a match;
    i = i + max(1, j-overlap(P[0..j-1],P[0..m]));
    }

Skipping inner iterations

The other optimization that can be done is to skip some iterations in the inner loop. Let's look at the same example, in which we skipped from i=2 to i=4:

    i=2: n  a  n
    i=4:       n  a  n  o

In this example, the "n" that overlaps has already been tested by the i=2 iteration. There's no need to test it again in the i=4 iteration. In general, if we have a nontrivial overlap with the last partial match, we can avoid testing a number of characters equal to the length of the overlap.

This change produces (a version of) the KMP algorithm:

KMP, version 1:

    i=0;
    o=0;
    while (i<n)
    {
    for (j=o; T[i+j] != '\0' && P[j] != '\0' && T[i+j]==P[j]; j++) ;
    if (P[j] == '\0') found a match;
    o = overlap(P[0..j-1],P[0..m]);
    i = i + max(1, j-o);
    }

The only remaining detail is how to compute the overlap function. This is a function only of j, and not of the characters in T[], so we can compute it once in a preprocessing stage before we get to this part of the algorithm. First let's see how fast this algorithm is.

KMP time analysis

We still have an outer loop and an inner loop, so it looks like the time might still be O(mn). But we can count it a different way to see that it's actually always less than that. The idea is that every time through the inner loop, we do one comparison T[i+j]==P[j]. We can count the total time of the algorithm by counting how many comparisons we perform.

We split the comparisons into two groups: those that return true, and those that return false. If a comparison returns true, we've determined the value of T[i+j]. Then in future iterations, as long as there is a nontrivial overlap involving T[i+j], we'll skip past that overlap and not make a comparison with that position again. So each position of T[] is only involved in one true comparison, and there can be n such comparisons total. On the other hand, there is at most one false comparison per iteration of the outer loop, so there can also only be n of those. As a result we see that this part of the KMP algorithm makes at most 2n comparisons and takes time O(n).

KMP and finite automata

If we look just at what happens to j during the algorithm above, it's sort of like a finite automaton. At each step j is set either to j+1 (in the inner loop, after a match) or to the overlap o (after a mismatch). At each step the value of o is just a function of j and doesn't depend on other information like the characters in T[]. So we can draw something like an automaton, with arrows connecting values of j and labeled with matches and mismatches.

The difference between this and the automata we are used to is that it has only two arrows out of each circle, instead of one per character. But we can still simulate it just like any other automaton, by placing a marker on the start state (j=0) and moving it around the arrows. Whenever we get a matching character in T[] we move on to the next character of the text. But whenever we get a mismatch we look at the same character in the next step, except for the case of a mismatch in the state j=0.

So in this example (the same as the one above) the automaton goes through the sequence of states:

    j=0
            mismatch T[0] != "n"
    j=0
            mismatch T[1] != "n"
    j=0
            match T[2] == "n"
    j=1
            match T[3] == "a"
    j=2
            match T[4] == "n"
    j=3
            mismatch T[5] != "o"
    j=1
            match T[5] == "a"
    j=2
            match T[6] == "n"
    j=3
            match T[7] == "o"
    j=4
            found match
    j=0
            mismatch T[8] != "n"
    j=0
            mismatch T[9] != "n"
    j=0
            match T[10] == "n"
    j=1
            mismatch T[11] != "a"
    j=0
            mismatch T[11] != "n"

This is essentially the same sequence of comparisons done by the KMP pseudocode above. So this automaton provides an equivalent definition of the KMP algorithm.

As one student pointed out in lecture, the one transition in this automaton that may not be clear is the one from j=4 to j=0. In general, there should be a transition from j=m to some smaller value of j, which should happen on any character (there are no more matches to test before making this transition). If we want to find all occurrences of the pattern, we should be able to find an occurrence even if it overlaps another one. So for instance if the pattern were "nana", we should find both occurrences of it in the text "nanana". So the transition from j=m should go to the next longest position that can match, which is simply j=overlap(pattern,pattern). In this case overlap("nano","nano") is empty (all suffixes of "nano" use the letter "o", and no prefix does) so we go to j=0.

Alternate version of KMP

The automaton above can be translated back into pseudo-code, looking a little different from the pseudo-code we saw before but performing the same comparisons.

KMP, version 2:

    j = 0;
    for (i = 0; i < n; i++)
    for (;;) {      // loop until break
        if (T[i] == P[j]) { // matches?
        j++;        // yes, move on to next state
        if (j == m) {   // maybe that was the last state
            found a match;
            j = overlap[j];
        }
        break;
        } else if (j == 0) break;   // no match in state j=0, give up
        else j = overlap[j];    // try shorter partial match
    }

The code inside each iteration of the outer loop is essentially the same as the function match from the C++ implementation I've made available. One advantage of this version of the code is that it tests characters one by one, rather than performing random access in the T[] array, so (as in the implementation) it can be made to work for stream-based input rather than having to read the whole text into memory first.

The overlap[j] array stores the values of overlap(pattern[0..j-1],pattern), which we still need to show how to compute.

Since this algorithm performs the same comparisons as the other version of KMP, it takes the same amount of time, O(n). One way of proving this bound directly is to note, first, that there is one true comparison (in which T[i]==P[j]) per iteration of the outer loop, since we break out of the inner loop when this happens. So there are n of these total. Each of these comparisons results in increasing j by one. Each iteration of the inner loop in which we don't break out of the loop results in executing the statement j=overlap[j], which decreases j. Since j can only decrease as many times as it's increased, the total number of times this happens is also O(n).

Computing the overlap function

Recall that we defined the overlap of two strings x and y to be the longest word that's a suffix of x and a prefix of y. The missing component of the KMP algorithm is a computation of this overlap function: we need to know overlap(P[0..j-1],P) for each value of j>0. Once we've computed these values we can store them in an array and look them up when we need them.

To compute these overlap functions, we need to know for strings x and y not just the longest word that's a suffix of x and a prefix of y, but all such words. The key fact to notice here is that if w is a suffix of x and a prefix of y, and it's not the longest such word, then it's also a suffix of overlap(x,y). (This follows simply from the fact that it's a suffix of x that is shorter than overlap(x,y) itself.) So we can list all words that are suffixes of x and prefixes of y by the following loop:

    while (x != empty) {
    x = overlap(x,y);
    output x;
    }

Now let's make another definition: say that shorten(x) is the prefix of x with one fewer character. The next simple observation to make is that shorten(overlap(x,y)) is still a prefix of y, but is also a suffix of shorten(x).

So we can find overlap(x,y) by adding one more character to some word that's a suffix of shorten(x) and a prefix of y. We can just find all such words using the loop above, and return the first one for which adding one more character produces a valid overlap:

Overlap computation:

    z = overlap(shorten(x),y)
    while (last char of x != y[length(z)])
    {
    if (z = empty) return overlap(x,y) = empty
    else z = overlap(z,y)
    }
    return overlap(x,y) = z

So this gives us a recursive algorithm for computing the overlap function in general. If we apply this algorithm for x=some prefix of the pattern, and y=the pattern itself, we see that all recursive calls have similar arguments. So if we store each value as we compute it, we can look it up instead of computing it again. (This simple idea of storing results instead of recomputing them is known as dynamic programming; we discussed it somewhat in the first lecture and will see it in more detail next time.)

So replacing x by P[0..j-1] and y by P[0..m-1] in the pseudocode above and replacing recursive calls by lookups of previously computed values gives us a routine for the problem we're trying to solve, of computing these particular overlap values. The following pseudocode is taken (with some names changed) from the initialization code of the C++ implementation I've made available. The value in overlap[0] is just a flag to make the rest of the loop simpler. The code inside the for loop is the part that computes each overlap value.

KMP overlap computation:

    overlap[0] = -1;
    for (int i = 0; pattern[i] != '\0'; i++) {
    overlap[i + 1] = overlap[i] + 1;
    while (overlap[i + 1] > 0 &&
           pattern[i] != pattern[overlap[i + 1] - 1])
        overlap[i + 1] = overlap[overlap[i + 1] - 1] + 1;
    }
    return overlap;

Let's finish by analyzing the time taken by this part of the KMP algorithm. The outer loop executes m times. Each iteration of the inner loop decreases the value of the formula overlap[i+1], and this formula's value only increases by one when we move from one iteration of the outer loop to the next. Since the number of decreases is at most the number of increases, the inner loop also has at most m iterations, and the total time for the algorithm is O(m).

The entire KMP algorithm consists of this overlap computation followed by the main part of the algorithm in which we scan the text (using the overlap values to speed up the scan). The first part takes O(m) and the second part takes O(n) time, so the total time is O(m+n).