searl1986 space: 计算机与 Internet

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

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人。

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

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).

经典C++面试题

Thu, 10 Jul 2008 09:07:14 GMT

1.介绍一下STL，详细说明STL如何实现vector。
Answer:
STL (标准模版库，Standard Template Library.它由容器算法迭代器组成。
STL有以下的一些优点：
可以方便容易地实现搜索数据或对数据排序等一系列的算法；
调试程序时更加安全和方便；
即使是人们用STL在UNIX平台下写的代码你也可以很容易地理解（因为STL是跨平台的）。
vector实质上就是一个动态数组，会根据数据的增加,动态的增加数组空间。
2.如果用VC开发程序，常见这么几个错误，C2001,c2005,c2011,这些错误的原因是什么。
Answer:
　　在学习VC++的过程中，遇到的LNK2001错误的错误消息主要为：
　　unresolved external symbol “symbol”（不确定的外部“符号”）。
　　如果连接程序不能在所有的库和目标文件内找到所引用的函数、变量或标签，将产生此错误消息。
一般来说，发生错误的原因有两个：一是所引用的函数、变量不存在、拼写不正确或者使用错误；其次可能使用了不同版本的连接库。

编程中经常能遇到LNK2005错误——重复定义错误，其实LNK2005错误并不是一个很难解决的错误.
3.继承和委派有什么分别，在决定使用继承或者委派的时候需要考虑什么。
在OOD,OOP中，组合优于继承.
当然多态的基础是继承，没有继承多态无从谈起。
当对象的类型不影响类中函数的行为时，就要使用模板来生成这样一组类。
当对象的类型影响类中函数的行为时，就要使用继承来得到这样一组类.
4.指针和引用有什么分别；如果传引用比传指针安全，为什么？如果我使用常量指针难道不行吗？
(1) 引用在创建的同时必须初始化，即引用到一个有效的对象；而指针在定义的时候不必初始化，可以在定义后面的任何地方重新赋值．
(2) 不存在ＮＵＬＬ引用，引用必须与合法的存储单元关联;而指针则可以是NULL.
(3) 引用一旦被初始化为指向一个对象，它就不能被改变为另一个对象的引用；而指针在任何时候都可以改变为指向另一个对象．给引用赋值并不是改变它和原始对象的绑定关系．
(4) 引用的创建和销毁并不会调用类的拷贝构造函数
(5) 语言层面，引用的用法和对象一样；在二进制层面，引用一般都是通过指针来实现的，只不过编译器帮我们完成了转换.
不存在空引用，并且引用一旦被初始化为指向一个对象，它就不能被改变为另一个对象的引用，显得很安全。
const 指针仍然存在空指针，并且有可能产生野指针.
总的来说：引用既具有指针的效率，又具有变量使用的方便性和直观性．
5.参数传递有几种方式；实现多态参数传递采用什么方式，如果没有使用某种方式原因是什么；
传值，传指针或者引用
6.结合一个项目说明你怎样应用设计模式的理念。
设计模式更多考虑是扩展和重用，而这两方面很多情况下，往往会被忽略。
不过，我不建议滥用设计模式，以为它有可能使得简单问题复杂化.
7.介绍一下你对设计模式的理解。（这个过程中有很多很细节的问题随机问的）
设计模式概念是由建筑设计师Christopher Alexander提出:"每一个模式描述了一个在我们周围不断重复发生的问题,以及该问题的解决方案的核心.这样,你就能一次又一次地使用该方案而不必做重复劳动."上述定义是对设计模式的广义定义.将其应用到面向对象软件的领域内,就形成了对设计模式的狭义定义.
可以简单的认为:设计模式就是解决某个特定的面向对象软件问题的特定方法，并且已经上升到理论程度。
框架与设计模式的区别:
1,设计模式和框架针对的问题域不同.设计模式针对面向对象的问题域;框架针对特定业务的问题域
2,设计模式比框架更为抽象.设计模式在碰到具体问题后,才能产生代码;框架已经可以用代码表示
3,设计模式是比框架更小的体系结构元素.框架中可以包括多个设计模式
设计模式就像武术中基本的招式.将这些招式合理地纵组合起来,就形成套路(框架)，框架是一种半成品.
8.C++和C定义结构的分别是什么。
C language 的结构仅仅是数据的结合
C plus plus的struct 和 class 其实具备几乎一样的功能，只是默认的访问属性不一样而已。
9.构造函数可否是虚汗数，为什么？析构函数呢，可否是纯虚的呢？
构造函数不能为虚函数，要构造一个对象，必须清楚地知道要构造什么，否则无法构造一个对象。
析构函数可以为纯虚函数。
10，拷贝构造函数相关问题，深拷贝，浅拷贝，临时对象等。
深拷贝意味着拷贝了资源和指针，而浅拷贝只是拷贝了指针，没有拷贝资源
这样使得两个指针指向同一份资源，造成对同一份析构两次，程序崩溃。
临时对象的开销比局部对象小些。
11.结合1个你认为比较能体现OOP思想的项目，用UML来描述。(最好这个项目继承，多态，虚函数都有体现）这个问题大概会占面试时间的一半，并且会问很多问题，一不小心可能会被问住）。
。。。
12。基类的有1个虚函数，子类还需要申明为virtual吗？为什么。
不申明没有关系的。
不过，我总是喜欢显式申明，使得代码更加清晰。
13.C也可以通过精心封装某些函数功能实现重用，那C++的类有什么优点吗，难道仅仅是为实现重用。
并不仅仅是这样的。
OOD，OOP从根本上改变了程序设计模式和设计思想，具备重大和深远的意义。
类的三大最基本的特征：封装，继承，多态.
14.C++特点是什么，如何实现多态？画出基类和子类在内存中的相互关系。
多态的基础是继承，需要虚函数的支持，简单的多态是很简单的。
子类继承父类大部分的资源，不能继承的有构造函数，析构函数，拷贝构造函数，operator=函数，友元函数等等
15.为什么要引入抽象基类和纯虚函数？
主要目的是为了实现一种接口的效果。
16.介绍一下模板和容器。如何实现？（也许会让你当场举例实现）
模板可以说比较古老了，但是当前的泛型编程实质上就是模板编程。
它体现了一种通用和泛化的思想。
STL有7种主要容器：vector,list,deque,map,multimap,set,multiset.
17.你如何理解MVC。简单举例来说明其应用。
MVC模式是observer 模式的一个特例,典型的有MFC里面的文档视图架构。
18，多重继承如何消除向上继承的二义性。
使用虚拟继承即可.