恭喜，你选择开发工程师做为自已的职业
　　悲哀，你选择开发工程师做为自已的职业

　　本文所指的开发工程师，仅指程序开发人员和以数字电路开发为主的电子工程师。
　　当你选择计算机或者电子、自控等专业进入大学时，你本来还是有机会从事其它行业的，可你毕业时执迷不悟，仍然选择了开发做为你的职业，真是自做孽不可活。不过，欢迎你和我一样加入这个被其它人认为是风光无限的“白领”吧。
　　如果你不是特别的与人世隔绝，我想你一定看过金老先生的名著《笑傲江湖》吧，里面有一门十分奇特的武功叫做"辟邪剑法"，你看这个小说第一次看到这种功夫的练法时，我想你当时一定笑歪了牙“呵呵，真好玩！”，可是现在我很痛心的告诉你：你选择的开发工作就是你人生路上的"辟邪剑法"，而你现在已经练了，并且无法再回头。
　　相对同时刚出校门同学从事其它行业而言优厚的薪水，以及不断学习更新的专业知识不仅仅让你感到生活的充实，更满足了你那不让外人知的虚荣心。在刚出校门的几年中，你经常回头看看被你落在后面的同学们，在内心怜悯他们的同时，你也会对自已天天加班的努力工作感到

心里平衡：“有付出才会有回报”这句话在那几年中你说的最多，不管是对自已的朋友们还是自已的爱人。第二句最常说的话是对公司的领导：“不行我就走人！”，实际上你也真的走过几回。对了，在这几年中，因为你的经济条件不错，你开始买房、开始谈恋爱、结婚、开始有了自已的小孩。有时候你会对自已说再过两年就去买车。当然其中可能有许多大件是需要分期付款的，但你对前途充满了信心，你确信认为这种日子会永远的持续下去，即使不是变得更好的话。
　　日子总是在这种平淡中一天天的过去，就在那么不经意间，你突然发现自已已经快30岁了，或者已经30了，莫名的，你心里会漫延着一种说不清楚的不安情绪，你好像觉得前途并非像前几年那样变得越来越好，你也忽然发现你以前所瞧不起的同学里好像已经有不少开着车的了，也有几个人住着比你还大的房子，好像房款还是一次付清的，你突然明白你现在的生活比起你的同学来最多是中游偏上了。工作中最让你感到心里不舒服的是，你越来越不敢对你的领导说不了，即使比你来的晚的同事升职或提薪，你也只是在私下与朋友们一起喝酒时才敢发发牢骚，在头的面前你的声间越来越小、笑脸是越来越温柔。
　　你终于开始迷茫“再过几年我会是在干什么呢？”，这句话常常出现在你的心里。
　　计算机开发工作，是一种以年轻为资本的工作，说句通俗点的话是“吃青春饭的”，嗯，这句话好像在一种特别的行业也听到过。

其标志就是一：工作的时间性非常强，一个开发项目被定的时限通常是很紧张的，更有甚者，有些号称开发管理的书里面还非常卑鄙的号召将一个项目切成多个小片，每个小片都定一个叫“里程碑”的东东来严格跟踪开发进度，加班加点在其它行业是需要加班工资的，而在开发行业，加班工资好像还没见到几个公司发过，是啊，反正有时间限制着，你干不完我再找你算账.所以开发工作通常有着其它工作所没有的精神上的压力。

一旦一个人步入而立之年，因为家庭和孩子的负担，加上精力上面的衰退，加班工作时间变得越来越少，这点让很多老板们感到：这些人已经老了，不好用了。指示人事部门：“以后招开发人员限制在30岁以下！”，相对而言硬件开发会年龄方面限制会稍好一点点，但也是五十步笑百步。还有一个很重要的一点就是：计算机这个烂东东实在是进步的太快了，前两年买的顶级配置电脑，现在怎么看怎么像废品，这还是小事，更可气的是好像每天都需要学习新的知识，刚毕业时只会书本上的PASCAL，学会了用腐蚀的办法来做电路板，一上班就开始学习TURBOC和TANGER2.0，刚刚学会，还没来得及高兴，马上开始学Borland C＋＋和Protel3.0，好不容易学会了，却发现需要学习VC和Protel98了。单片机也是啊：Z80的指令背的很熟，工作中没来得及用就要学8031，好好学吧，本来想着这辈子就吃它了，又发现又出来什么PIC、DSP、CPLD、FPGA、ARM等等....这还不包括中间要学一大堆74系列、4000系列、XX系列...IC卡居然里面还有CPU卡..如果学习的知识里每个字都能变成一分钱，我想所有的开发工程师都是腰缠万贯的富翁。
　　一眼看去，这种日子好像见不到头，年轻时乐此不彼，但现在你一定对自已能坚持到什么时候感到怀疑了。我们都玩过像仙剑奇侠传这样的RPG游戏，刚开始时你只是一个一名不文的少年，随着你去打怪物、捡宝贝、学秘芨，最后终于有一天你会变成一个大英雄！那么你在实际生活中过得比那些小侠们还辛苦，为什么成不了一个生活中的大侠呢？呵呵，原因在这里：因为开发工作是邪门功夫，它虽然可以让你速成的变成小资，但它最大的特点是经验不积累！日新月异的知识更新，让你总是感到自已在退步，你就像在RPG中的主人公，开始时就给了你一把好剑和好盔甲，而且让你的级别很高，但让你的经验不累积，虽然刚开始打小怪物时你觉得自已很爽，但越到后来，你会发现你会死的很惨！比较一下你与其它非开发行业的同学你就可以知道了，例如和你学医的同学比起来。套用岳不群他老人家说华山剑宗和气宗的区别那段话：前十年你比你那些学医的同学收入和地位要好的多，但十年以后你和他基本上各方面都会持平，而二十年以后你的各方面远远不能与你学医的同学相提并论！嗯，你已经开始不笑辟邪剑法了吧。
　　“敢问路在何方？路在脚下...”，不过猴兄和八戒兄这么认为是可以的，你呢？
总结了许多开发朋友在30岁以后的生活之路，让我们一起看看开发人员“路在何方？”那么开发人员在30岁以后都干些什么呢？
其路一：继续做你这个很有“前途”的职业吧！
　　偶掰着脚指头仔细数了数，发现还真的有很多朋友在30岁以后还在从事开发工作，我这里说的从事，是指你还需要天天在电脑边上编程序和画电路板，与你手下是否有几个小兵无关，也与你是否头上顶着什么项目经理、主任工程师的帽子无关，只要你还需要亲自开发，你就属于这一类。其中有个年龄最大的朋友是63年的，从事医疗仪器的开发工作，35岁左右还在从事软硬件开发工作的仍有一大堆，分析这些仍然从事开发的朋友，基本上都有以下特点：
1　痴迷工作或者痴迷电脑，晚上八点到十二点的这段时间，基本上是在电脑桌或工作台前渡过的。
2　不喜欢与人交住，朋友很少，常联系的人不超过五个。
3　与朋友交往时谈工作多，但一般不主动谈钱。
4　体型偏胖或偏廋，不在正常区间。
5　无未来计划，对五年后自已生活怎么样、从事什么工作说不清楚。
6　俭省，从不乱花钱。
即使你是还不到30岁的开发人员，你也可以看看自己对以上几条是否符合，是否会在30岁后还从事开发职业，四条疑似，五条以上基本确诊你也是这类型的人。
　 这些朋友们通常报着过一天是一天的态度生活，到了这个年龄，也不敢再轻易的换工作了，年轻时的锐气慢慢的也消退了。唯一不变的希望是有一天从天上掉下来一大堆钱把自己砸伤。说实在话因为他们的性格所限，基本上可以确定他们以后不可能在职场上获得更好的发展，当个小头头，带几个人开发已经是他们发展的顶点。至于以后的人生之路，不仅他们自己迷茫，可能上帝也正在头痛。
   不过像这类朋友，偶很奇怪的发现：他们的小孩都是儿子！不知是偶然还是有什么其它说法。
简单建议：要改变命运，先改变性格：坚持半年晚上不从事工作、游戏及电视，用此时间与人交往，你的人生会有改变。

其路二：转行从事技术支持、行政或生产等工作还有一些朋友，从事了几年的开发工作，因为自已并非特别的爱好，或者领导上面的强制工作安排，他们转到了技术支持、服务或行政等工作，至少当时从表面上看起来，他们的薪水较开发要少一些，但真正的统计这些人，发现他们之中有半数的人获得了更好的发展，升职为服务部经理或行政经理等职，最历害的一个朋友已升职为总经理助理，进入高层。
　　这类朋友当时转行通常并非自已志愿，属被逼无奈或者其它原因，但显然，拥有专业知识技术的他们显然在非技术部门中鹤立鸡群，遇到什么事情他们均可从专业的角度提出建言，久而久之，他们获得更多的升职和加薪机会也就不足为奇。
　　因为不从事开发，所以经验开始积累，这类的职业通常会给你一个很安定的感觉，你到30多岁后会发现这类职业反而比开发工作更容易获得新的工作机会。

　　简单建议：你如果确定在开发部无法获得很好的发展机会，不妨转到其它几个部门试试，换个活法，钱少点就少点吧，机会多。
其路三：开发管理
　　如果你现在已经是总工或开发部经理，或者你眼看就有机会被提升为这类职务，那么恭喜你，你走的是从“弼马温”到“斗战胜佛”这条金光大路，你不仅拥有很高的专业技能，而且很显然，你也有着很强的人际交往能力，你这类人根本不需要对未来有着任何的担心，你在即使一无所有的时候也很容易白手起家。
　　你这种人算是练辟邪剑法练成了仙，嗯，我无话可说。
　　你是不是这类人也很容易区别，就像围棋二十岁不称国手终身无望一样，你应该在工作三、四年以后，也就是说二十七岁左右就会发现自已工作中指手划脚的时间比亲自开发的时间要多了，而且大多数这类人在这个年龄手下应该有“兵”了，相反的，如果你快30岁了还天天埋头于电脑前编程序和画板子，或者30多岁了你还没升到部门经理（虽然你总是觉得自已很有希望），基本上可以确定你不是这类人。好了，如果你确定你是这类人，那么你唯一的想法就是尽快爬上中层和高层，因为有时候人生偶然性太大，不占住坑的萝卜很有可能被人拔出来！

　　简单建议：天天去你的老板家里面拖地和擦桌子！

其路四：出国或考研
　　有两个搞开发后出国的朋友，其中一个甚至打工打到了一个小公司总工的位置，数据库和软件方面水平巨牛，但仍感觉心里不踏实，于是将自己工作多年的钱忍痛掏出来，出国费加上机票大概将自已辛苦所攒的银子花完，然后又借了一些钱，在02年身上揣着一万美元跑去了加拿大，在加拿大不停的重复找工作，换工作，然后再找工作的循环，找的工作基本上与计算机无关，不过工资总是在1500加元左右，呵呵，折成人民币与他在国内打工拿的基本上差不多，不过租个地下室就花了300加元，然后吃吃喝喝，再买个电脑上上网这类的，基本每月平均还要倒贴一点。前段时间给我的邮件里说，现在身上花的差不多只有5、6000美元了，准备开个小公司，看看能不能往国内倒腾点东东，做最后一搏。另外一个朋友去澳州，时间稍早一些，先是大概摘了一年多的葡萄，后来总算找了个技术工作，每天的工作是画机械图纸，收入还算不错

将近3000澳元，买了个旧车，也算是过上了资本主义生活。不过前年回来一趟，唯一的感叹就是：在国外拿2000美元的生活，绝对不如在国内拿5000人民币的生活舒服。
　　也有两个考研的朋友，不过其中一个严格的说不是做开发的出身，偏重于市场方面的工作性质，不过我的朋友里面考研的不多，只好凑两个人说说，一个考研后在北京找了个工作，每个月5、6000元钱，但还是做开发，生活仍然与没考研之前没有任何的改变，前途仍然没见到什么大亮的光，还是搞不清楚以后再干些什么，标准的过一天算一天了。另外一个考研后在大学里面找了个工作，工资虽然比他原来打工少了不少，但毕竟终身有靠，稳定了下来，也算修成了正果，这位哥们心情一放松下来，也开始有时间琢磨着业余时间自已做点什么，好像现在慢慢的也开始有了点眉目。
　　简单建议：这两条路，对开发人员来说都不算是很好，出国十年前是好事，现在难说，考研能成功转行的概率恐怕也不是很大，多半仍然去搞开发，只不过研究生可以多干几年罢了。

其路五：转行到市场
　　绞尽脑汁的想想，我所知道的人之中只有两个开发人员去了市场，这两个人都不能说是朋友，认识而已。他们都是主动要求去了市场，结果是这两个人均在市场都是干到一年左右，然后都自已开公司了。呵呵，很奇怪，极高的转行成功率！不过仔细想想，我对这两个人的思路佩服的五体投地。能下决心仍掉每月5、6000元的开发职位，从事一个自已并不熟悉的岗位，每月拿个2000多元＋提成，但提成那是说不清楚的事情，这个决定，只能让人感觉到他们对自已前途清晰的把握和老谋深算的心机。而且他们不去服务不去生产，挖空心思说服领导去市场（市场部门与开发部门通常是一个公司的核心部门，进入其实并不容易），可以说是有着长远的考虑的。有技术了，再与客户交成朋友，马上就会产生很大的机遇应该是正常的事情。
　　有实力，有心机，也有着很强的决心力，这种人恐怕早在大学毕业时或更早的时候就已经决定了自已的人生之路，他们的每一步路在若干年前早就计划周全，现在看起来：学会技术－＞进入市场－＞寻找商机－＞开公司，一条多么清楚的人生之路。但就像我们上小学中学时，所有人都知道上大学是我们最清楚的人生路一样，最后只有少数人才能真正达到目标（当然，现在扩招的历害是另外一回事，我是说我们那个时候，也就是：“很久很久以前，当我像你那么大的时候”）。

　　简单建议：你若是这类人，我的建议是：...嗯?....那个你.你，你别走啊，我还有个事想请你赞助一下啊.....

其路六：开公司自已干

　　呵呵，看到这一条，发现你的眼睛已经圆了，你肯定千百次的想过这个事情吧，咳咳，其实我从事开发的时候也是天天梦想着这种事情。总想着过两年找个机会就自已干，这个梦想一年又一年的折磨着你也给着你希望。看看吧，开发后来开公司的还真的不少，里面有成功的也有很多失败的，通常开公司都是几个人合伙开始的，有做技术的，有做市场的，几个人一拍即合、狼狈为奸，共同策划了这一个大活动。一般说来能让这几个人下决心走出这一步，产品肯定是先进的，甚至是国内独一无二的，市场也是很大的，负责市场的那个哥们通常会拍着胸保证可以卖出去，并悄悄地告诉你他在某主管领导是他小舅子的同学的二叔，肯定没问题。于是你们几个人找地点、注册执照、买了几个破桌子，再攒了两台电脑，每个人又凑了几万银子，公司开张了！
　　产品很快出来了，市场的哥们也不负重望，有几个客户表示要试用了，一切看起来都是如此的正常，“.......你坐在老板桌前，不停的有人来汇报工作或者找你签字...人进人出中...你又想起公司再穷也不能只有一把椅子的故事.....”你在梦中笑出声来。
    是如此的顺利，你们很快就有单子了，很快的单子让你们凑的那点钱不够了，你们很高兴的每个人又增加了投入，拿出钱时你眼泪汪汪的数着钱说：“这就是我那生蛋的母鸡啊”。你们的产品确实不错，市场也经营的很好，客户慢慢的多了起来，单子来的时候一笔接着一笔，你每天都处于兴奋之中，唯一美中不足的是好像客户回款总是会拖一些日子，不过客户给你保证说：过几天，过几天就付给你们，因为回款总是在计划外，所以你们为了资金的流畅运行又凑了一些钱，这个时候你有一些心事了，因为你的存款折上面的数字已经快趋向于零了。“没事，过两个月等回款了一切都OK了，谁干事业不吃点苦呢？”你这么安慰着自已又投入到工作中去，资金总是在回款和生产经营费用之间走着一个窄窄的小木桥，你的账上总是没有太多的钱，扩大了的公司规模和许多意外情况，使你又一次、二次、三次的与合作者们再次投入了自已的资金，当然，后来的钱你可能已经是借的了.....
　　终于有一天，你的会计再一次告诉你，老板啊，账上又没现金了，吃过多次苦头的你终于下决心开始重视资金的运行了，你裁掉了一些不必要的人手，减少了开发的投入，要求市场人员签单的时候必须予付XX%的款，回扣也必须等收过款后再付，同时也开始对产品的生产成本开始进行控制。
　　时间一天一天的过去，因为竟争对手的产品也对你的产品进行了仿造，你的产品慢慢变得不再先进，市场人员开始埋怨公司的合同资金方面规定太严格，不好签单，生产成本的下降通常也导至产品毛病的增多，客户也开始埋怨你的服务人员不能及时进行服务。
　　终于有一天，你重新走进了人才交流中心，以前你是来招人的，现在你拿着自已的简历开始寻找一个工作
......
    公司的成功与否，与产品有关，与市场有关，但更重要的是与资金有关，产品与市场都可以通过资金来弥补，而却没有任何东西可以代替

资金，凡是倒下的公司，99%与资金链的断裂有关。在你决定要开公司以前，先估计一下你公司支持一年所需要的资金数额，包括人工费，生产，场地，广告宣传、市场费用、甚至电、水费等等等等，把你所想到的一切加在一起，得出的值就是..慢..如果你没有实际的开过公司的经验，你需要将此数字乘3，然后就是你开公司一年最少需要的费用，呵呵，公司的实际运营所需要的钱是你想像的3倍以上，你要是不信我也没办法。

    简单建议：开公司前最重要的是先确立你后续的资金来源！也就是说钱不够了怎么办？－－－因为你投入的钱肯定会不够的。

其路七:第二职业
    这类的朋友有不少,他们没有脱离开发工作,但是在业余时间又不停的接项目或者在卖产品,在单位里面他们显得并不出众,比起其它人来说他们属于最不愿意加班的一类.为此他们白天通常工作很勤奋.这类人也许不一定可以挣很多钱,但平均下来他们一年之中通常都可以比同事们多挣个几万元.有时候比上班拿得还多.但令人疑惑的是,这类人在生活中更加注重稳定,基本上没见到他们跳过蹧,即使私下里面已经开了个小公司,他们通常也不会辞职.
    你的旁边有没有这类人呢?分辨他们很容易:
--电话很多,而且更愿意来电话时离开办公室找个没人的旮旯通话.神秘兮兮给人一种"这家伙是不是有二奶啊?"的感觉的人，通常是这类人。这类人是女性最佳的选择对象：很顾家，不象那些富人容易花心，而比起一般人来说，他们收入相对要高得多。但总结了一下几位这类的开发朋友：也得出了一个令人沮丧的结论：这种人通常个子不高，体形类似桶状.....

   简单建议：这好像是开发人员最佳的出路了，但比较丰厚的收入通常让这类人不愿意去冒风险....到现在为止我所认识的这类人还没有一个真正算是成功的。
   好了，虽然偶的经历远远说不上丰富，也没有什么成功之处可以自满的，但或许因为比其它朋友痴长了几岁，见过的人可能会稍多一些，所

以斗胆写出了以上的一些文字，让您掉牙了。
   下面是偶走过开发这条路上总结出来的一点心得，你可以不看，但看了就千万别把嘴咧的太大：
   一、不管是给别人打工还是自已干，都要全心全意的工作，因为你所做的任何一点工作都会让自已的人生多一点筹码，这一点最最重要!这样的例子我至少可以举出两起，优秀的开发人员被其它新公司挖走，并给一定的股份，成为新公司的股东的例子。当时与这样的开发人员一个部门同时工作或更早工作的有许多人，他们平时经常偷点懒，能少干点工作就少干点，有时候还笑话那个平时努力工作的人傻，几年过去了，究竟谁比谁傻？
   二、多与市场人员交朋友，你接触他们时可能总会觉得他们知识比你少，甚至素质比你低，可能比你还有点黄。但实际上他们比你更懂这个社会！参加到他们这个圈子中去，和他们一起赌赌钱、一起聊聊天、一起洗洗桑拿、一起.....你会通过他们接触到另外一个世界。
   三、机会远比钱重要，挣不挣钱在年轻时并不是特别重要！不论是在实际生活中还是在网上或其它地方，如果有机会参与到除本职工作外的一些项目或产品的开发中（包括你的朋友拉你去做点小生意之类的非开发性质的工作），那怕是帮忙的性质，也要积极介入，至少你会交到很多的朋友，这样你的人生会多出很多的机会。

 

例子是一个mfc的对话框，用vc调试器查看了一个程序从生成初始化到接受消息的流程。从产生到结束的基本流程是这样的：
KERNEL32->WinMainCRTStartup()->_tWinMain(开始)->AfxWinMain(开始)->AfxGetThread()->AfxWinInit()->InitApplication()->InitInstance()->DoModal()->RunModalLoop()->ExitInstance()->AfxWinMain(结束)->_tWinMain(结束)

1、KERNEL32
kernel32.dll是Windows9x/Me中非常重要的32位动态链接库文件，属于内核级文件。它控制着系统的内存管理、数据的输入输出操作和中断处理，当Windows启动时，kernel32.dll就驻留在内存中特定的写保护区域，使别的程序无法占用这个内存区域。

2、WinMainCRTStartup()函数
  程序默认的基地址（EXE文件默认为0x400000，DLL默认为x10000000），操作系统装载一个程序时总是试着先从这个基地址开始。一般Win32的程序，EXE的入口为WinMain，DLL的入口为DllEntryPoint。默认情况下，通过一个C的运行时库函数来实现：控制台程序采用mainCRTStartup (或wmainCRTStartup)去调用程序的main (或wmain)函数；Windows程序采用WinMainCRTStartup (或 wWinMainCRTStartup)调用程序的WinMain (或 wWinMain，必须采用__stdcall调用约定)；DLL采用_DllMainCRTStartup调用DllMain函数（必须采用__stdcall调用约定）。
它负责：
  * 检索指向新进程的完整命令行指针；
  * 检索指向新进程的环境变量的指针；
  * 对c/c++运行时的全局变量进行初始化；
  * 对c运行期的内存单元分配函数(比如malloc，calloc)和其他低层I/O例程使用的内存栈     进行初始化。
  * 为C++的全局和静态类调用构造函数。
  当这些初始化工作完成后，该启动函数就调用wWinMain函数进入应用程序的执行。
当wWinMain函数执行完毕返回时，wWinMainCRTStartup启动函数就调用c运行期的exit()函
数，将返回值(nMainRetVal)传递给它。
  之后exit()便开始收尾工作：
  * 调用由_onexit()函数调用和注册的任何函数。
  * 为C++的全局和静态类调用析构函数；
  * 调用操作系统的ExitProcess函数，将nMainRetVal传递给它，这使得操作系统能够撤销     进程并设置它的exit  代码。
最小体积的win32程序：(不要编译缺省库)
#pragma comment (linker, "/SUBSYSTEM:WINDOWS")
#pragma comment (linker, "/NODEFAULTLIB")
int WinMainCRTStartup()
{
 return 0;
}

3、WinMain()函数
_tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
 LPTSTR lpCmdLine, int nCmdShow)
{
 // call shared/exported WinMain
 return AfxWinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
}

4、AfxWinMain()函数
int AFXAPI AfxWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
 LPTSTR lpCmdLine, int nCmdShow)
{
 ASSERT(hPrevInstance == NULL);

 int nReturnCode = -1;
 CWinThread* pThread = AfxGetThread();
 CWinApp* pApp = AfxGetApp();

 // AFX internal initialization
 if (!AfxWinInit(hInstance, hPrevInstance, lpCmdLine, nCmdShow))
  goto InitFailure;

 // App global initializations (rare)
 if (pApp != NULL && !pApp->InitApplication())
  goto InitFailure;

 // Perform specific initializations
 if (!pThread->InitInstance())
 {
  if (pThread->m_pMainWnd != NULL)
  {
   TRACE0("Warning: Destroying non-NULL m_pMainWnd\n");
   pThread->m_pMainWnd->DestroyWindow();
  }
  nReturnCode = pThread->ExitInstance();
  goto InitFailure;
 }
 nReturnCode = pThread->Run();

InitFailure:
#ifdef _DEBUG
 // Check for missing AfxLockTempMap calls
 if (AfxGetModuleThreadState()->m_nTempMapLock != 0)
 {
  TRACE1("Warning: Temp map lock count non-zero (%ld).\n",
   AfxGetModuleThreadState()->m_nTempMapLock);
 }
 AfxLockTempMaps();
 AfxUnlockTempMaps(-1);
#endif

 AfxWinTerm();
 return nReturnCode;
}

5、AfxGetThread()函数
CWinThread* AFXAPI AfxGetThread()
{
 // check for current thread in module thread state
 AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
 CWinThread* pThread = pState->m_pCurrentWinThread;

 // if no CWinThread for the module, then use the global app
 if (pThread == NULL)
  pThread = AfxGetApp();

 return pThread;
}

6、AfxWinInit()函数
BOOL AFXAPI AfxWinInit(HINSTANCE hInstance, HINSTANCE hPrevInstance,
 LPTSTR lpCmdLine, int nCmdShow)
{
 ASSERT(hPrevInstance == NULL);

 // handle critical errors and avoid Windows message boxes
 SetErrorMode(SetErrorMode(0) |
  SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);

 // set resource handles
 AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
 pModuleState->m_hCurrentInstanceHandle = hInstance;
 pModuleState->m_hCurrentResourceHandle = hInstance;

 // fill in the initial state for the application
 CWinApp* pApp = AfxGetApp();
 if (pApp != NULL)
 {
  // Windows specific initialization (not done if no CWinApp)
  pApp->m_hInstance = hInstance;
  pApp->m_hPrevInstance = hPrevInstance;
  pApp->m_lpCmdLine = lpCmdLine;
  pApp->m_nCmdShow = nCmdShow;
  pApp->SetCurrentHandles();
 }

 // initialize thread specific data (for main thread)
 if (!afxContextIsDLL)
  AfxInitThread();

 return TRUE;
}

7、InitApplication() 函数
BOOL CMy1App::InitApplication()
{
 // TODO: Add your specialized code here and/or call the base class
 AfxMessageBox("InitApplication");
 return CWinApp::InitApplication();
}
BOOL CWinApp::InitApplication()
{
 if (CDocManager::pStaticDocManager != NULL)
 {
  if (m_pDocManager == NULL)
   m_pDocManager = CDocManager::pStaticDocManager;
  CDocManager::pStaticDocManager = NULL;
 }

 if (m_pDocManager != NULL)
  m_pDocManager->AddDocTemplate(NULL);
 else
  CDocManager::bStaticInit = FALSE;

 return TRUE;
}

8、InitInstance()函数
AfxWinMain函数里面的if (!pThread->InitInstance())会调用程序CMy1App的InitInstance函数：
BOOL CMy1App::InitInstance()
{
 AfxEnableControlContainer();
AfxMessageBox("InitInstance");
 // Standard initialization
 // If you are not using these features and wish to reduce the size
 //  of your final executable, you should remove from the following
 //  the specific initialization routines you do not need.

#ifdef _AFXDLL
 Enable3dControls();   // Call this when using MFC in a shared DLL
#else
 Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif

 CMy1Dlg dlg;//调用CMy1Dlg的构造函数
 m_pMainWnd = &dlg;
 int nResponse = dlg.DoModal();
 if (nResponse == IDOK)
 {
  // TODO: Place code here to handle when the dialog is
  //  dismissed with OK
 }
 else if (nResponse == IDCANCEL)
 {
  // TODO: Place code here to handle when the dialog is
  //  dismissed with Cancel
 }

 // Since the dialog has been closed, return FALSE so that we exit the
 //  application, rather than start the application's message pump.
 return FALSE;
}

9、AfxWinMain()函数里面的主要的循环体，在这里：
        if (!pThread->InitInstance())//主要是模式对话框调用，对话框关闭以后InitInstance函数才会结束
 {
  if (pThread->m_pMainWnd != NULL)
  {
   TRACE0("Warning: Destroying non-NULL m_pMainWnd\n");
   pThread->m_pMainWnd->DestroyWindow();
  }
  nReturnCode = pThread->ExitInstance();
  goto InitFailure;
 }
 nReturnCode = pThread->Run();//非模式对话框和一般程序调用这个循环

InitInstance函数调用了dlg.DoModal()函数，以下是DoModal()函数：
int CDialog::DoModal()
{
 // can be constructed with a resource template or InitModalIndirect
 ASSERT(m_lpszTemplateName != NULL || m_hDialogTemplate != NULL ||
  m_lpDialogTemplate != NULL);

 // load resource as necessary
 LPCDLGTEMPLATE lpDialogTemplate = m_lpDialogTemplate;
 HGLOBAL hDialogTemplate = m_hDialogTemplate;
 HINSTANCE hInst = AfxGetResourceHandle();
 if (m_lpszTemplateName != NULL)
 {
  hInst = AfxFindResourceHandle(m_lpszTemplateName, RT_DIALOG);
  HRSRC hResource = ::FindResource(hInst, m_lpszTemplateName, RT_DIALOG);
  hDialogTemplate = LoadResource(hInst, hResource);
 }
 if (hDialogTemplate != NULL)
  lpDialogTemplate = (LPCDLGTEMPLATE)LockResource(hDialogTemplate);

 // return -1 in case of failure to load the dialog template resource
 if (lpDialogTemplate == NULL)
  return -1;

 // disable parent (before creating dialog)
 HWND hWndParent = PreModal();
 AfxUnhookWindowCreate();
 BOOL bEnableParent = FALSE;
 if (hWndParent != NULL && ::IsWindowEnabled(hWndParent))
 {
  ::EnableWindow(hWndParent, FALSE);
  bEnableParent = TRUE;
 }

 TRY
 {
  // create modeless dialog
  AfxHookWindowCreate(this);
  if (CreateDlgIndirect(lpDialogTemplate,
      CWnd::FromHandle(hWndParent), hInst))//创建对话框的窗口
  {
   if (m_nFlags & WF_CONTINUEMODAL)
   {
    // enter modal loop
    DWORD dwFlags = MLF_SHOWONIDLE;
    if (GetStyle() & DS_NOIDLEMSG)
     dwFlags |= MLF_NOIDLEMSG;
    VERIFY(RunModalLoop(dwFlags) == m_nModalResult);//这里是真正的循环RunModalLoop
   }

   // hide the window before enabling the parent, etc.
   if (m_hWnd != NULL)
    SetWindowPos(NULL, 0, 0, 0, 0, SWP_HIDEWINDOW|
     SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
  }
 }
 CATCH_ALL(e)
 {
  DELETE_EXCEPTION(e);
  m_nModalResult = -1;
 }
 END_CATCH_ALL

 if (bEnableParent)
  ::EnableWindow(hWndParent, TRUE);
 if (hWndParent != NULL && ::GetActiveWindow() == m_hWnd)
  ::SetActiveWindow(hWndParent);

 // destroy modal window
 DestroyWindow();
 PostModal();

 // unlock/free resources as necessary
 if (m_lpszTemplateName != NULL || m_hDialogTemplate != NULL)
  UnlockResource(hDialogTemplate);
 if (m_lpszTemplateName != NULL)
  FreeResource(hDialogTemplate);

 return m_nModalResult;
}

模式对话框调用的循环函数RunModalLoop()函数如下：
int CWnd::RunModalLoop(DWORD dwFlags)
{
 ASSERT(::IsWindow(m_hWnd)); // window must be created
 ASSERT(!(m_nFlags & WF_MODALLOOP)); // window must not already be in modal state

 // for tracking the idle time state
 BOOL bIdle = TRUE;
 LONG lIdleCount = 0;
 BOOL bShowIdle = (dwFlags & MLF_SHOWONIDLE) && !(GetStyle() & WS_VISIBLE);
 HWND hWndParent = ::GetParent(m_hWnd);
 m_nFlags |= (WF_MODALLOOP|WF_CONTINUEMODAL);
 MSG* pMsg = &AfxGetThread()->m_msgCur;

 // acquire and dispatch messages until the modal state is done
 for (;;)
 {
  ASSERT(ContinueModal());

  // phase1: check to see if we can do idle work
  while (bIdle &&
   !::PeekMessage(pMsg, NULL, NULL, NULL, PM_NOREMOVE))
  {
   ASSERT(ContinueModal());

   // show the dialog when the message queue goes idle
   if (bShowIdle)
   {
    ShowWindow(SW_SHOWNORMAL);
    UpdateWindow();
    bShowIdle = FALSE;
   }

   // call OnIdle while in bIdle state
   if (!(dwFlags & MLF_NOIDLEMSG) && hWndParent != NULL && lIdleCount == 0)
   {
    // send WM_ENTERIDLE to the parent
    ::SendMessage(hWndParent, WM_ENTERIDLE, MSGF_DIALOGBOX, (LPARAM)m_hWnd);
   }
   if ((dwFlags & MLF_NOKICKIDLE) ||
    !SendMessage(WM_KICKIDLE, MSGF_DIALOGBOX, lIdleCount++))
   {
    // stop idle processing next time
    bIdle = FALSE;
   }
  }

  // phase2: pump messages while available
  do
  {
   ASSERT(ContinueModal());

   // pump message, but quit on WM_QUIT
   if (!AfxGetThread()->PumpMessage())//主要在这里循环
   {
    AfxPostQuitMessage(0);
    return -1;
   }

   // show the window when certain special messages rec'd
   if (bShowIdle &&
    (pMsg->message == 0x118 || pMsg->message == WM_SYSKEYDOWN))
   {
    ShowWindow(SW_SHOWNORMAL);
    UpdateWindow();
    bShowIdle = FALSE;
   }

   if (!ContinueModal())
    goto ExitModal;

   // reset "no idle" state after pumping "normal" message
   if (AfxGetThread()->IsIdleMessage(pMsg))
   {
    bIdle = TRUE;
    lIdleCount = 0;
   }

  } while (::PeekMessage(pMsg, NULL, NULL, NULL, PM_NOREMOVE));
 }

ExitModal:
 m_nFlags &= ~(WF_MODALLOOP|WF_CONTINUEMODAL);
 return m_nModalResult;
}

一般程序调用的循环函数Run函数如下：
int CWinThread::Run()
{
 ASSERT_VALID(this);

 // for tracking the idle time state
 BOOL bIdle = TRUE;
 LONG lIdleCount = 0;

 // acquire and dispatch messages until a WM_QUIT message is received.
 for (;;)
 {
  // phase1: check to see if we can do idle work
  while (bIdle &&
   !::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE))
  {
   // call OnIdle while in bIdle state
   if (!OnIdle(lIdleCount++))
    bIdle = FALSE; // assume "no idle" state
  }

  // phase2: pump messages while available
  do
  {
   // pump message, but quit on WM_QUIT
   if (!PumpMessage())
    return ExitInstance();

   // reset "no idle" state after pumping "normal" message
   if (IsIdleMessage(&m_msgCur))
   {
    bIdle = TRUE;
    lIdleCount = 0;
   }

  } while (::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE));
 }

 ASSERT(FALSE);  // not reachable
}

==========
我认为是更加完整的应该是_DllMainCRTStartup-> WinMainCRTStartup(void)->()->_tWinMain(开始)->AfxWinMain(开始)->AfxGetThread()->AfxWinInit()->InitApplication()->InitInstance()->DoModal()->RunModalLoop()->ExitInstance()->AfxWinMain(结束)->_tWinMain(结束)

参考http://www.cppblog.com/citywanderer/articles/8716.html
        内核最高权限，自古就是兵家必争之地，魔高一尺道高一丈的争夺于此亦已变成颇为稀松平常之事。可以说和这些争夺比起来，SSDT的相关技术简直不值一提。但最初发作的病毒体总是从ring3开始的——换句话说，任你未来会成长为何等的武林高手，我都可以在你学走路的时候杀掉你——知晓了SSDT的这点优势，所有的病毒咂吧咂吧也就都没味儿了。所以说，杀毒莫如防毒。

网上看的这段话，感觉特有气势，摘录在此！

IOCP（I/O Completion Port，I/O完成端口）是性能最好的一种I/O模型。它是应用程序使用线程池处理异步I/O请求的一种机制。在处理多个并发的异步I/O请求时，以往的模型都是在接收请求是创建一个线程来应答请求。这样就有很多的线程并行地运行在系统中。而这些线程都是可运行的，Windows内核花费大量的时间在进行线程的上下文切换，并没有多少时间花在线程运行上。再加上创建新线程的开销比较大，所以造成了效率的低下。

而IOCP模型是事先开好了N个线程，存储在线程池中，让他们hold。然后将所有用户的请求都投递到一个完成端口上，然后N个工作线程逐一地从完成端口中取得用户消息并加以处理。这样就避免了为每个用户开一个线程。既减少了线程资源，又提高了线程的利用率。

完成端口模型是怎样实现的呢？我们先创建一个完成端口（::CreateIoCompletioPort()）。然后再创建一个或多个工作线程，并指定他们到这个完成端口上去读取数据。我们再将远程连接的套接字句柄关联到这个完成端口（还是用::CreateIoCompletionPort()）。一切就OK了。

工作线程都干些什么呢？首先是调用::GetQueuedCompletionStatus()函数在关联到这个完成端口上的所有套接字上等待I/O的完成。再判断完成了什么类型的I/O。一般来说，有三种类型的I/O，OP_ACCEPT，OP_READ和OP_WIRTE。我们到数据缓冲区内读取数据后，再投递一个或是多个同类型的I/O即可（::AcceptEx()、::WSARecv()、::WSASend()）。对读取到的数据，我们可以按照自己的需要来进行相应的处理。

为此，我们需要一个以OVERLAPPED（重叠I/O）结构为第一个字段的per-I/O数据自定义结构。

typedef struct _PER_IO_DATA
{
         OVERLAPPED ol;      // 重叠I/O结构
         char buf[BUFFER_SIZE];  // 数据缓冲区
         int nOperationType;         //I/O操作类型
#define OP_READ 1
#define OP_WRITE 2
#define OP_ACCEPT 3
} PER_IO_DATA, *PPER_IO_DATA;

将一个PER_IO_DATA结构强制转化成一个OVERLAPPED结构传给::GetQueuedCompletionStatus()函数，返回的这个PER_IO_DATA结构的的nOperationType就是I/O操作的类型。当然，这些类型都是在投递I/O请求时自己设置的。

这样一个IOCP服务器的框架就出来了。当然，要做一个好的IOCP服务器，还有考虑很多问题，如内存资源管理、接受连接的方法、恶意的客户连接、包的重排序等等。以上是个人对于IOCP模型的一些理解与看法，还有待完善。另外各Winsock API的用法参见MSDN。

 

补充IOCP模型的实现：

//创建一个完成端口
FCompletPort := CreateIoCompletionPort( INVALID_HANDLE_VALUE, 0,0,0 );

//接受远程连接，并把这个连接的socket句柄绑定到刚才创建的IOCP上
AConnect := accept( FListenSock, addr, len);
CreateIoCompletionPort( AConnect, FCompletPort, nil, 0 );

//创建CPU数*2 + 2个线程
for i:=1 to si.dwNumberOfProcessors*2+2 do
begin
  AThread := TRecvSendThread.Create( false );
  AThread.CompletPort := FCompletPort;//告诉这个线程，你要去这个IOCP去访问数据
end;

OK，就这么简单，我们要做的就是建立一个IOCP，把远程连接的socket句柄绑定到刚才创建的IOCP上，最后创建n个线程，并告诉这n个线程到这个IOCP上去访问数据就可以了。

再看一下TRecvSendThread线程都干些什么：

procedure TRecvSendThread.Execute;
var
  ......
begin
  while (not self.Terminated) do
  begin
    //查询IOCP状态（数据读写操作是否完成）
    GetQueuedCompletionStatus( CompletPort, BytesTransd, CompletKey, POVERLAPPED(pPerIoDat), TIME_OUT );

    if BytesTransd <> 0  then
       ....;//数据读写操作完成

    //再投递一个读数据请求
    WSARecv( CompletKey, @(pPerIoDat^.BufData), 1, BytesRecv, Flags, @(pPerIoDat^.Overlap), nil );
  end;
end;

读写线程只是简单地检查IOCP是否完成了我们投递的读写操作，如果完成了则再投递一个新的读写请求。
应该注意到，我们创建的所有TRecvSendThread都在访问同一个IOCP（因为我们只创建了一个IOCP），并且我们没有使用临界区！难道不会产生冲突吗？不用考虑同步问题吗？
呵呵，这正是IOCP的奥妙所在。IOCP不是一个普通的对象，不需要考虑线程安全问题。它会自动调配访问它的线程：如果某个socket上有一个线程A正在访问，那么线程B的访问请求会被分配到另外一个socket。这一切都是由系统自动调配的，我们无需过问。

一个python 编程讲座 http://www.swc.scipy.org/lec/figurelist.html

先来看个例子：

def foo(*args, **kwargs):
print 'args = ', args
print 'kwargs = ', kwargs
print '---------------------------------------'
if __name__ == '__main__':
foo(1,2,3,4)
foo(a=1,b=2,c=3)
foo(1,2,3,4, a=1,b=2,c=3)
foo('a', 1, None, a=1, b='2', c=3)

输出结果如下：

args =  (1, 2, 3, 4)
kwargs =  {}
---------------------------------------
args =  ()
kwargs =  {'a': 1, 'c': 3, 'b': 2}
---------------------------------------
args =  (1, 2, 3, 4)
kwargs =  {'a': 1, 'c': 3, 'b': 2}
---------------------------------------
args =  ('a', 1, None)
kwargs =  {'a': 1, 'c': 3, 'b': '2'}
---------------------------------------

可以看到，这两个是python中的可变参数。*args表示任何多个无名参数，它是一个tuple；**kwargs表示关键字参数，它是一个dict。并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前，像foo(a=1, b='2', c=3, a', 1, None, )这样调用的话，会提示语法错误“SyntaxError: non-keyword arg after keyword arg”。

        这个笔记主要是关于python语言本身的一些概念。
        在Python中有4种类型的数——整数、长整数、浮点数和复数。如:2是一个整数的例子。 3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。 (-5+4j)和(2.3-4.6j)是复数的例子。
       你可以用单引号指示字符串，就如同'Quote me on this'这样。所有的空白，即空格和制表符都照原样保留。在双引号中的字符串与单引号中的字符串的使用完全相同。使用三引号（'''或"""）可以指示一个多行的字符串。可以在三引号中自由的使用单引号和双引号。转义符是\，可以用\'来指示单引号—注意这个反斜杠。
       变量的名字就是标识符。在命名标识符的时候，你要遵循这些规则：
● 标识符的第一个字符必须是字母表中的字母（大写或小写）或者一个下划线（‘ _’）。
● 标识符名称的其他部分可以由字母（大写或小写）、下划线（‘ _ ’）或数字（0-9）组成。
● 标识符名称是对大小写敏感的。例如，myname和myName不是一个标识符。注意前者中
的小写n和后者中的大写N。
● 有效 标识符名称的例子有i、__my_name、name_23和a1b2_c3。
● 无效 标识符名称的例子有2things、this is spaced out和my-name。
         使用变量时只需要给它们赋一个值。不需要声明或定义数据类型。
         物理行是你在编写程序时所看见的。逻辑行是Python 看见的单个语句。Python假定每个物理行对应一个逻辑行。如果你想要在一个物理行中使用多于一个逻辑行，那么你需要使用分号（;）来特别地标明这种用法。分号表示一个逻辑行/语句的结束。
        Python程序中行首的空白称为缩进,是非常重要的，它用来决定逻辑行的缩进层次，从而用来决定语句的分组。类似于C++中的花括号。同一层次的语句必须有相同的缩进，每一组这样的语句称为一个块（Block）。
       

表2.1 运算符与它们的用法

运算符	名称	说明	例子
+	加	两个对象相加	3 + 5得到8。'a' + 'b'得到'ab'。
-	减	得到负数或是一个数减去另一个数	-5.2得到一个负数。50 - 24得到26。
*	乘	两个数相乘或是返回一个被重复若干次的字符串	2 * 3得到6。'la' * 3得到'lalala'。
**	幂	返回x的y次幂	3 ** 4得到81（即3 * 3 * 3 * 3）
/	除	x除以y	4/3得到1（整数的除法得到整数结果）。4.0/3或4/3.0得到1.3333333333333333
//	取整除	返回商的整数部分	4 // 3.0得到1.0
%	取模	返回除法的余数	8%3得到2。-25.5%2.25得到1.5
<<	左移	把一个数的比特向左移一定数目（每个数在内存中都表示为比特或二进制数字，即0和1）	2 << 2得到8。——2按比特表示为10
>>	右移	把一个数的比特向右移一定数目	11 >> 1得到5。——11按比特表示为1011，向右移动1比特后得到101，即十进制的5。
&	按位与	数的按位与	5 & 3得到1。
|	按位或	数的按位或	5 | 3得到7。
^	按位异或	数的按位异或	5 ^ 3得到6
~	按位翻转	x的按位翻转是-(x+1)	~5得到6。
<	小于	返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	5 < 3返回0（即False）而3 < 5返回1（即True）。比较可以被任意连接：3 < 5 < 7返回True。
>	大于	返回x是否大于y	5 > 3返回True。如果两个操作数都是数字，它们首先被转换为一个共同的类型。否则，它总是返回False。
<=	小于等于	返回x是否小于等于y	x = 3; y = 6; x <= y返回True。
>=	大于等于	返回x是否大于等于y	x = 4; y = 3; x >= y返回True。
==	等于	比较对象是否相等	x = 2; y = 2; x == y返回True。x = 'str'; y = 'stR'; x == y返回False。x = 'str'; y = 'str'; x == y返回True。
!=	不等于	比较两个对象是否不相等	x = 2; y = 3; x != y返回True。
not	布尔“非”	如果x为True，返回False。如果x为False，它返回True。	x = True; not y返回False。
and	布尔“与”	如果x为False，x and y返回False，否则它返回y的计算值。	x = False; y = True; x and y，由于x是False，返回False。在这里，Python不会计算y，因为它知道这个表达式的值肯定是False（因为x是False）。这个现象称为短路计算。
or	布尔“或”	如果x是True，它返回True，否则它返回y的计算值。	x = True; y = False; x or y返回True。短路计算在这里也适用。

表2.2 运算符优先级

运算符	描述
lambda	Lambda表达式
or	布尔“或”
and	布尔“与”
not x	布尔“非”
in，not in	成员测试
is，is not	同一性测试
<，<=，>，>=，!=，==	比较
|	按位或
^	按位异或
&	按位与
<<，>>	移位
+，-	加法与减法
*，/，%	乘法、除法与取余
+x，-x	正负号
~x	按位翻转
**	指数
x.attribute	属性参考
x[index]	下标
x[index:index]	寻址段
f(arguments...)	函数调用
(experession,...)	绑定或元组显示
[expression,...]	列表显示
{key:datum,...}	字典显示
'expression,...'	字符串转换

Format	Meaning
"c"	Single character (i.e., string of length 1)
"B"	Unsigned 8-bit integer
"h"	Short (16-bit) integer
"i"	32-bit integer
"f"	32-bit float
"d"	Double-precision (64-bit) float
"2"	String of fixed size (see below)
Table 18.2: Packing Format Specifiers

在Python中有三种控制流语句——if、for和while，
Python中if-elif-else语句类似于C++中的if-elseif-else；

Python中for i in range(0,5)等价于C/C++中的for (int i = 0; i < 5; i++)。程序中使用内建的range函数生成这个数的序列。range返回一个序列的数。这个序列从第一个数开始到第二个数为止。例如，range(1,5)给出序列[1, 2, 3, 4]。默认地，range的步长为1。如果我们为range提供第三个数，那么它将成为步长。例如，range(1,5,2)给出[1,3]。记住，range 向上 延伸到第二个数，即它不包含第二个数。

while语句是循环语句，while语句有一个可选的else从句。

break语句是用来 终止 循环语句的，即哪怕循环条件没有称为False或序列还没有被完全递归，也停止执行循环语句。

一个重要的注释是，如果你从for或while循环中终止 ，任何对应的循环else块将不执行。


本节介绍Python的内建函数和异常.许多内建函数的细节及特性可以在这里找到.

内建函数

本节介绍的函数在解释器中总是可用的,他们被包含在 __builtin__ 模块里.另外每个模块的 __builtins__ 属性经常指的是这个模块(除了当在restricted execution环境下运行时).

_(下划线)

默认情况下,变量 _ 用于在交互模式下表示最近一个表达式的运行结果.

参阅 sys.displayhook (118)

__import__(name [, globals [, locals [, fromlist]]])

import语句通过调用这个函数来导入模块. name是包含模块名字的字符串, globals是一个可选的定义全局名称空间的字典, locals是定义局部名称空间的字典, fromlist是from语句目标的列表.例如, import spam语句会调用__import__('spam', globals(), locals(), []) ,而from spam import foo 语句会调用 __import__('spam', globals(), locals(), ['foo']). 如果模块名在包名字之后(如foo.bar)而且fromlist为空时,就返回对应的模块对象.如果fromlist不为空,则只会返回最顶级的包.

这个函数是一个低等级的模块载入接口.它并不执行import语句的所有步骤(通常情况下局部名称空间并不会随模块中包含对象的名称引用的改变而改变.这个函数可以由用户来重新定义,这样为import语句加入新的行为.默认的执行并不会检查locals参数,而globals只用于决定包的内容(这些参数可以使 __import__()能够完整地访问全局和局部名称空间)

abs(x)
返回x的绝对值

apply(func [, args [, keywords]])
对可调用对象func执行函数调用. args是一个包含固定位置参数的元组, keywords是包含关键参数的字典. apply()函数也可以写做func(*args ,**keywords ).

buffer(sequence [, offset [, size]])
创建一个新的缓冲器对象.缓冲器通常是一个序列(如字符串)的字节导向序列.缓冲器和字符串在许多地方是相同的,但是它不支持字符串方法,而且也不能使用string模块的函数.

callable(object)
当object为可调用对象时返回True,否则返回False

chr(i)
将一个0到255的整数转换为一个字符.

cmp(x,y)
比较x和y. x< y返回负数; x== y返回零; x> y返回整数.它可以比较任意两个对象并返回结果,即使有时候对象的比较豪无意义(例如比较文件对象).在某些环境下,这样的比较会引发异常.

coerce(x,y)
将x和y值转换为同一个数值类型并作为一个元组返回.(第三章,类型和对象)

compile(string, filename, kind)
使用exec()或eval()将字符串编译为代码对象. filename is a string containing the name of the file in which the string was defined. kind为'exec'时代表一个表达式的序列, 'eval'代表一个表达式, 'single'代表一个运行语句.

complex(real [, imag])
创建一个复数

delattr(object, attr)
删除对象的一个属性, attr是一个字符串.与 del object.attr相同

dir([object])
返回包含属性名称的列表.它们来自对象的 __dict__, __methods__,以及 __members__ 属性.如果没有传递给它参数,则会返回当前的local symbol table

divmod(a,b)
返回一个包含商和余数的元组.对于整数,将返回(a / b , a % b ),对于浮点数,将返回(math.floor(a / b ), a % b )

eval(expr [, globals [, locals]])
计算一个表达式的值. expr是一个字符串或由compile()创建的一个代码对象. globals和locals为操作定义的全局和局部名称空间,当省略时,表达式将在调用时的名称空间计算.

execfile(filename [, globals [, locals]])
运行文件filename中的语句. globals和locals定义了文件运行的全局和局部名称空间,当省略时,文件将在调用时的名称空间运行.这个函数不能在一个函数主体里使用,因为它与内嵌范围不相容.

filter(function, list)
使用func()函数来过滤s中的元素.使func返回值为false的元素被丢弃,其它的存入filter函数返回的列表中.如果function是None,则list中值为False的元素就被删除.

float(x)
将x转换为浮点数

getattr(object, name [, default])
返回一个对象的属性. name是一个字符串. default是一个可选的值,代表当没有这个属性时返回的值. 与 object.name 结果相同

globals()
返回一个与全局名称空间对应的字典

hasattr(object, name)
返回object是否有name属性,布尔值

hash(object)
返回一个对象的整数哈希值(如果可能).两个相等对象的哈希值是相同的.模块没有定义一个哈希值.

hex(x)
将一个整数或长整数转换为一个十六进制的字符串

id(object)
返回一个对象的整数id

input([prompt])
相当于eval(raw_input(prompt ))

int(x [, base])
将一个数字或字符串转换为整数. 可选参数base代表从字符串转换时的基础/根据

intern(string)
Checks to see whether string is contained in an internal table of strings. If found, a copy of the internal string is returned. If not, string is added to the internal table and returned. This function is primarily used to get better performance in operations involving dictionary lookups. Interned strings are never garbage-collected. Not applicable to Unicode strings.

isinstance(object, classobj)
检查object是否是classobj的事例或子类.也可用于检查类型

issubclass(class1, class2)
检查class1是否是class2的子类(派生类)
注意: issubclass(A , A )返回True

len(s)
返回序列s中包含的条目数目

list(s)
返回一个包含序列s中条目的新列表

locals()
返回一个与调用时局部名称空间相对应的字典

long(x [, base])
将一个数字或字符串转换为长整数,可选参数base代表从字符串转换时的基础/根据

map(function, list, ...)
将序列list中的每个元素传递给function函数做参数,函数的返回值组成列表并返回.如果提供给多个列表,则函数应包含有多个参数,每个参数从不同的列表获得.如果函数为None,则默认为 identity function(?身份函数).如果None映射到多个列表,则返回一个包含元组的列表,元组的每个元素分别来自各个列表.如果有必要,短的列表将使用None来扩充到与最长列表长度相等. map可以使用list comprehensions 来代替.例如map(function , alist ),可以使用[function (x) for x in alist ]来代替
参阅 zip (105).

max(s [, args, ...])
单个参数时,返回序列s中的最大值.多个参数时,返回值最大的参数

min(s [, args, ...])
单个参数时,返回序列s中的最小值.多个参数时,返回值最小的参数

oct(x)
将一个整数或者长整数转换为八进制字符串

open(filename [, mode [, bufsize]])
打开文件filename并返回一个文件对象(第十章,运行环境). mode代表文件打开的模式. 'r' 表示读, 'w' 表示写, 'a' 表示在文件末尾添加内容. 还有一种更新模式,你只要在读写模式后增加一个'+'就可以使用这种模式,如'r+' 或 'w+'.当一个文件以更新模式打开,你就可以对这个文件进行读写操作.只要在任何读取操作之前刷新所有的输出缓冲就不会有问题.如果一个文件以 'w+' 模式打开,它的长度就度截为 0.当mode省略时,将会使用'w'模式.bufsize参数指定了缓冲行为, 0代表无缓冲,1代表行缓冲,其他正数代表一个大约的字节缓冲器大小,负数代表使用系统默认缓冲器大小(也是默认行为)

ord(c)
返回单个字符c的整数顺序值.普通字符返回[0,255]中的一个值,Unicode字符返回 [0,65535]中的一个值

pow(x, y [, z])
返回x ** y ,如果z存在返回(x ** y ) % z

range([start,] stop [, step])
返回一个从start到stop的整数序列, step代表步进,默认值为1. start默认值为0.负数的step可以创建一个递减的整数序列
参阅xrange (105)

raw_input([prompt])
从标准输入(sys.stdin)中读取一行,并把它作为字符串返回.如果提供了prompt,它将首先打印到标准输出(sys.stdout).当读取到一个EOF时,就会引发一个EOFError异常.如果readline模块被导入,那么这个函数会使用它来提供更高级的功能

reduce(func, seq [, initializer])
函数从一个序列收集信息,然后只返回一个值(例如求和,最大值,等).它首先以序列的前两个元素调用函数,再将返回值和第三个参数作为参数调用函数,依次执行下去,返回最终的值. func函数有且只有两个参数.在seq为空时,将使用初始值initializer.

reload(module)
重新导入一个已经导入的模块. module必须是一个已经存在的模块对象.一般情况下并不鼓励使用这个函数,除了在调试的时候.
当一个模块重导入时,定义它的全局名称空间的字典依然存在.Thus, definitions in the old module that aren’t part of the newly reloaded module are retained.模块可以利用这个来检查他们是否已经被导入.
重导入一个使用C编写的模块通常是不合法的
If any other modules have imported this module by using the from statement, they’ll continue to use the definitions in the previously imported module. This problem can be avoided by either reissuing the from statement after a module has been reloaded or using fully qualified names such as module.name .
如果有使用以前模块中类创建的实例,它们将继续使用以前的模块

repr(object)
返回一个对象的标准字符串表示.与向后的引号 `object` 相同.大多数情况下,返回的字符串可以使用eval()来再次创建这个对象.

round(x [, n])
Returns the result of rounding the floating-point number x to the closest multiple of 10 to the power minus n . If n is omitted, it defaults to 0. If two multiples are equally close, rounding is done away from 0 (例如, 0.5 is rounded to 1.0 and -0.5 is rounded to -1.0).

setattr(object, name, value)
设置一个对象的属性. name是一个字符串. 相当于object.name = value .

slice([start,] stop [, step])
返回一个代表指定数列中一个整数的切片对象.切片对象也可以有扩展切片操作语句来产生.(第三章,序列和映射方法)

str(object)
返回表示对象的可打印形式的字符串.与print语句产生的字符串相同.

tuple(s)
从序列s中创建一个元组.如果s已经是一个元组,则返回s

type(object)
返回object的类型,它是一个types模块中定义type类型
参阅isinstance (102)

unichr(i)
将一个0到65535的整数转换为一个Unicode字符

unicode(string [, encoding [, errors]])
将string转换为Unicode字符串. encoding指定了string的数据编码,它被省略时,将使用sys.getdefaultencoding(). errors指定编码错误处理方式.('strict', 'ignore', 或 'replace' .参阅第三章和第九章中有关Unicode内容)

vars([object])
返回object的 symbol table (通常在object的__dict__属性).如果没有给它提供参数,则返回对应当前局部名称空间的字典.

xrange([start,] stop [, step])
和range函数相似,但返回的是一个XRangeType对象.它生成一个迭代器,就是只有用那个数时才临时通过计算提供值,而不是全部储存它们.这样在处理大的数列时能节省大量的内存.

zip(s1 [, s2 [,..]])
用来将几个序列组合成一个包含元组的序列,序列中的每个元素t[i ] = (s1[i ], s2[i ], ..., sn[i ]).结果与最短序列的长度相等.

        Python是一门面向对象的解释型脚本语言，类似于Java。Python标准库很庞大，它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。
记住，只要安装了Python，所有这些功能都是可用的。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。
       目前，Python的稳定版本是2.5，相关的其他工具也对2.5这个版本支持的最好，所以为避免麻烦，最好用2.5。下载安装完毕后，需要先正确的设置PATH变量。对于Windows 2000、XP、2003，点击控制面板->系统->高级->环境变量。在“系统变量”表单中点击叫做PATH的变量，然后编辑这个变量，把;C:\Python25（是Python的安装路径，前面有个分号）加到它的结尾。 在开始->运行 输入 CMD打开dos，提示符下键入python。或者你可以选择使用IDLE程序。IDLE是集成开发环境的缩写。点击开始->程序->Python 2.5->IDLE
(Python GUI)。退出Python提示符，如果你使用的是Linux/BSD shell，那么按Ctrl-d退出提示符。如果是在Windows命令行中，则按Ctrl-z再按Enter。
        启动你选择的编辑器，输入下面这段程序，把它保存为helloworld.py。
然后启动DOS,转到helloworld.py所在的路径，然后键入命令python helloworld.py。如果你使用IDLE，请使用菜单Edit->Run Script或者使用键盘快捷方式Ctrl-F5。输出如下所示。
$ python helloworld.py
Hello World

==========
Notes:
1、任何在#符号右面的内容都是注释;
2、使用DOS命令行运行*.py脚本时，要先cd切换到脚本所在的文件夹路径，然后运行。
3、Python中没有主函数的说法，没有必要写主函数，一个脚本可以全部是语句。

              

在图形图象处理编程过程中,双缓冲是一种基本的技术。我们知道,如果窗体在响应WM_PAINT消息的时候要进行复杂的图形处理，那么窗体在重绘时由于过频的刷新而引起闪烁现象。解决这一问题的有效方法就是双缓冲技术。
　　因为窗体在刷新时，总要有一个擦除原来图象的过程OnEraseBkgnd，它利用背景色填充窗体绘图区，然后在调用新的绘图代码进行重绘，这样一擦一写造成了图象颜色的反差。当WM_PAINT的响应很频繁的时候，这种反差也就越发明显。于是我们就看到了闪烁现象。

我们会很自然的想到，避免背景色的填充是最直接的办法。但是那样的话，窗体上会变的一团糟。因为每次绘制图象的时候都没有将原来的图象清除，造成了图象的残留，于是窗体重绘时，画面往往会变的乱七八糟。所以单纯的禁止背景重绘是不够的。我们还要进行重新绘图，但要求速度很快，于是我们想到了使用BitBlt函数。它可以支持图形块的复制，速度很快。我们可以先在内存中作图，然后用此函数将做好的图复制到前台，同时禁止背景刷新，这样就消除了闪烁。以上也就是双缓冲绘图的基本的思路。

 

一、普通方法：

　　先按普通做图的方法进行编程。即在视类的OnDraw函数中添加绘图代码。在此我们绘制若干同心圆，代码如下：

 CBCDoc* pDoc = GetDocument();

 ASSERT_VALID(pDoc);

 CPoint ptCenter;

 CRect rect,ellipseRect;

 GetClientRect(&rect);

 ptCenter = rect.CenterPoint();

 for(int i=20;i>0;i--)

 {

      ellipseRect.SetRect(ptCenter,ptCenter);

      ellipseRect.InflateRect(i*10,i*10);

      pDC->Ellipse(ellipseRect);

 }

编译运行程序，尝试改变窗口大小，可以发现闪烁现象。

 

二、双缓冲方法：

　　在双缓冲方法中，首先要做的是屏蔽背景刷新。背景刷新其实是在响应WM_ERASEBKGND消息。我们在视类中添加对这个消息的响应，可以看到缺省的代码如下：

BOOL CMYView::OnEraseBkgnd(CDC* pDC)

{

     return CView::OnEraseBkgnd(pDC);

}

是调用父类的OnEraseBkgnd函数，我们屏蔽此调用，只须直接return TRUE;即可。

 

　　下面是内存缓冲作图的步骤。

 CPoint ptCenter;

 CRect rect,ellipseRect;

 GetClientRect(&rect);

 ptCenter = rect.CenterPoint();

 CDC dcMem;            //用于缓冲作图的内存DC

 CBitmap bmp;          //内存中承载临时图象的位图

 dcMem.CreateCompatibleDC(pDC);  //依附窗口DC创建兼容内存DC

 bmp.CreateCompatibleBitmap(pDC,rect.Width(),rect.Height());//创建兼容位图

 dcMem.SelectObject(&bmp);     //将位图选择进内存DC

//按原来背景填充客户区，不然会是黑色

 dcMem.FillSolidRect(rect,pDC->GetBkColor());

for(int i=20;i>0;i--)  //在内存DC上做同样的同心圆图象

 {

      ellipseRect.SetRect(ptCenter,ptCenter);

      ellipseRect.InflateRect(i*10,i*10);

      dcMem.Ellipse(ellipseRect);

 }

 pDC->BitBlt(0,0,rect.Width(),rect.Height(),

&dcMem,0,0,SRCCOPY);//将内存DC上的图象拷贝到前台

 dcMem.DeleteDC();  //删除DC

 bm.DeleteObject(); //删除位图

由于复杂的画图操作转入后台，我们看到的是速度很快的复制操作，自然也就消除了闪烁现象。

 

注意：bmp.CreateCompatibleBitmap(pDC,rect.Width(),rect.Height());

这里面CreateCompatibleBitmap第一个参数不能用dcMem，这样的话创建的是黑白位图。如果你要创建彩色位图，需要用pDC，它用来创建了内存DC. 详细请见下面的MSDN:

When a memory device context is created, it initially has a 1-by-1 monochrome bitmap selected into it. If this memory device context is used in CreateCompatibleBitmap, the bitmap that is created is a monochrome bitmap. To create a color bitmap, use the hDC that was used to create the memory device context, as shown in the following code:

    HDC memDC = CreateCompatibleDC ( hDC );

    HBITMAP memBM = CreateCompatibleBitmap ( hDC, nWidth, nHeight );

    SelectObject ( memDC, memBM );