老天你对不住我，从一个云端跌到另一个云端！有点不能接受。

   大学同寝的女孩a说刚刚和相恋三年的朋友分手了，现在有两个男孩在追他，其实很早以前我就预感到了，她在围城的里面，应该全然不知吧？我知道她的伤心，可也为它高兴，又有了全新的开始，就像生命轮回迎来了又一个春天，不知道这个春天于她是春雨绵绵还是春阳灿灿?

   a说她哭了几天现在已经好了，毕竟是天蝎座的，很容易淡忘的。qq里语言仿佛很欢快，我真的有点佩服她，那么坚强，不过连续不断蹦出来的“靠！”还是让我的心格外难受，她说好想我们，其实我也好想她们啊，也许在一起，可以给她臂膀，让她哭泣，像我们曾经在一起欢笑过一样。

   a说b年底要订婚了，大学的时候她常常跟我们说她想和男友偷偷去领证，可是他不肯。

   b是我们寝最小的小姑娘，长得小巧可爱，看起来像个初中的小学生。而如今她就要订婚了，不敢想她怎样成为一个少妇，一个母亲。

   老天我受不了了！什么世道，怎么这样啊？

   我还是一个离这些词很遥远的傻瓜！听着有种恍恍惚惚的感觉，不敢想像这些词加到自己身上是什么感觉，真希望时间能停止，让我们一直就这样过下去。

   发誓一辈子只谈恋爱，我有结婚恐惧症啊！救救我吧！

  那些单纯的过往，会在我的怀念里慢慢淡忘吗？

  我不停的寻找，阅读，玩味，惆怅那些校园里清涩的心情，喜欢那些唯美的带有樱花颜色，夸张绚丽的插图。总是觉得自己是一个有唯美主义倾向的人，而在现实中却是多么平凡又平凡的芸芸众生中的一个啊！

  我常常阅读郭敬明，他应该是一个喜欢安静，依恋寂寞，享受伤感的人吧？只是当那些美好的青春，都逝去，逝去的时候，那于他该是怎样的痛苦，他要怎样生活？我不敢想，就像我不敢去想自己将要面对的生活一样。

借他的文字来祭奠我逝去的青春。

  我的生活一如既往，很多的朋友，很明亮的生活，只是越来越深信一句话，越是明亮的地方，越是会产生最暗的阴影。
   生活突然进入一种忙碌的节奏，每个周末会往全国各个地方飞。我的耳朵突然开始习惯飞机起飞、降落时巨大的轰鸣声，习惯飞机上难吃的饭，习惯躺在九千米的高空做白日梦。
   以前我曾经许愿，我说以后我要走很多的路，看很多的风景，我要把曾经在地图上看过的地方真实地踩在脚底下。而如今，我真的是走了很多的地方了，以前没去过的现在都去了。我想我应该可以释然了。可是为什么心里还是有难过？

   　我在上海，悠闲地生活，学着编导方面的东西，期望着有天我可以拍出让人泪流满面的作品。空闲的时候我会去图书馆，在一排一排长长的书架里找那些厚厚的落满尘埃的专业书。看怎么调度场景，看怎么布置灯光。图书馆有很多巨大的玻璃窗，望出去，是不断起落的飞鸟。有时候我闭着眼睛就开始想像那些飞鸟落下的浅灰色的羽毛轻轻地覆盖在我的瞳仁上 ，于是我想起小A的浅灰色的瞳仁。想起那棵在我记忆里面一直飘零的樱花树。在明亮的阳光里，不停伤逝。
   有时候在宿舍下面的凉亭里吃西瓜，蹲在栏杆上，几个朋友在那里随便地说话，讲一些无关痛痒的话，做一些可有可无的表情，于是我想日子就这么过了。

   然后突然想起项斯微说过的话：我总是在我的十八岁缅怀我的十七岁，而在我十九岁的时候又会缅怀我的十八岁。

　想起鲁迅说过的：这样的生活何时才是个尽头啊。

  我总是喜欢站在草坪上举目向东看，一直向东，向东。 
  我想看看东京塔的雾气，散了没有。
  
  我总是喜欢站在楼顶上举目向西看，一直向西，向西，我想看看家乡的向日葵，开了没有。
  我已经忘记了乘火车的感觉，一直坐飞机坐到自己想吐。
  记得以前高中的时候，我和小A总是在火车上，裹着毯子安静地睡去。睡不着的晚上就靠着窗看外面山脉黑色模糊的轮廓，偶尔散落在山脚下的昏黄的灯火，或者飞逝而过的灰铁站牌。天亮的时候会抬头望天，想着那些移动的云朵是否会拼凑出一张记忆深处的面容，一瞬间可以让我丧失所有的语言。仓皇的。伤感的。田野里有飞鸟扑扇着翅膀冲上高高的苍穹。
   年少的梦想清澈得如同湖泊一样，曾经的纯真和对生活的坚持。握着咖啡杯都可以想像掌心开出一朵花，香味弥漫如同最美的藤蔓植物。学陶艺的时候整天和泥巴打交道，感觉泥土在指间百转千回。

   学插花的时候和同桌的女生畅想以后自己的恋人，她说她的白马王子会在厨房里摆满小小的仙人掌，煲汤的时候会捧一本画册安静地等待。我说我的白雪公主会在屋顶花园里种满金黄色的向日葵，穿着白色的棉布裙子为它们浇水。说完后我就笑了，因为我突然想起在刚刚过去的夏天，我就是穿着白色的棉布T恤米色的粗布裤子，在我家的屋顶上种满了向日葵。
    而如今，我只能在楼顶上仰望长满云朵的天空。我突然想起金城武，想起《心动》里面他总是躺在屋顶天台上，望着灰色的蓝色的白色的晴朗的阴霾的天空，然后拍照片，一盒子的照片，然后送给她，告诉她，这是我想你的时候的天空。
  
  我站在高高的屋顶上，风破空而来，我伸出手挡着眼前的沙尘，当风快要离开的时候，我总是会对它讲，你可不可以帮我看看，我家乡屋顶上的向日葵，开了没有，死了没有，有人为它们浇水没有？
  东邪西毒》。时间的灰烬。西毒讲，我想回去看看，家乡的桃花，开了没有。

  那些素面朝天的城市，那些洗尽铅华的容颜，在我的飞机起飞的时候，就全部沦陷了。

　　言情剧里总是有人煽情地说，亲爱的，再见了，再见了。我们总是笑着说虚伪。

   可是我终于发现，我们认真说过再见的人，再见的事，永远都不能再见了。

　　你选择往东，那么我就固执地往西走。从今以后，有着不同的境遇，各自辗转在不同的命运里，各自匍匐在不同的伤痕中。当飞机把我们的回忆带上九千米的高空，当火车轰隆隆地碾碎我们明媚的青春，我是那么难过地，难过地，哭了。

    原谅我凌乱的文字，原谅我破碎的时光。

   真的就这样我再也回不到过去了吗，那些过往的青春，单纯美好的日子都从我的世界里悄无声息的一瞬间溜走了吗？眼睛里不禁泛起了涟漪。

   这里是我现在的生活，**电子苏州有限公司。

   记得还是在几个月前，我对“公司”“白领”这样的字眼还有一种莫名的感觉，仿佛离我还是很遥远很神圣的的东西，脑子里有高高的写字楼和美丽的女性的影子在疯长，就像别人说苏州的时候，我的脑子里就会生出蒙蒙烟雨，小巷，丁香油纸伞一样的画面。现在我已经是“公司”的“白领”了，而且是在苏州，但这些词在我的心里失去了它本来的光华，说出来的时候就和说土豆，白菜一样没有任何感觉。

    我们的公司位于苏州火车站以北，在苏州市地图上，最北的边缘，仔细看才能看出我们公司所在的相城区，差一点这张大大的地图上就没有它的容身之处了，以我们的话说就是在一个差一点就鸟不拉屎的地方。公司占地几百平方米，方方正正像个棋盘，棋盘中央有三幢楼房，两幢两层的是厂房，一幢三层的还没有投入使用，还有一幢靠着最东边围墙的五层楼是所有员工的宿舍楼，楼周围两步见方的草坪显示着这里是并非是鸟不拉屎的地方，除此之外还有四通八达的水泥大道,孤单的篮球场，剩下的便是大片大片暂时还荒废的土地，在七月眩晕的阳光里和充足的水份滋润下疯长出满地的野草，有的足足高出我一头多。这让我想起了我的小学时代，在某个黄昏不小心被独自锁在校园里，仿佛也是也看到一样的棋盘，一样的围墙，一样安静的矮房。

    我工作的地方在一幢两层楼的一楼，一个大大白璧的办公室，一边墙上是大大的窗，灰白色的百折窗帘，因为用电脑的缘故一直都没有拉开过。三四十个人，填在蓝色的格子里，一桌，一椅，一点脑。很多时候这样的地方都让人觉得是在教室，或者某个机房，仿佛我们不曾离开校园。记得刚来还没有多久，每每当下班的音乐声响起来的时候，岩岩总会说：“放学了，走吧，吃饭去！”我就指着她开始一阵狂笑，“傻瓜，是下班！”。

   我们这里的人都来自祖国的大江南北。岩岩在西安读大学，家在河北，一张圆圆的娃娃脸，还不及肩的马尾，随着她的笑声在转身投足之间欢快的晃来晃去。她是个有白痴一样笑容的小女孩，因为上学早，要比我们同级上学的孩子小两三岁，她总为班里的同学叫她小朋友而眉毛蹙起来，认真地问：“太过分了，他们总叫我小朋友，我有那么小吗？”我通常不说话，一直看着她就想笑，笑弯了腰，她迷惑的看看我，一屁股坐在床上，拿起面包，饼干或者沙琪马之类的东西就开吃了，吃东西也没能塞住她的嘴，一些乱其八糟的形容词，莫名其妙的笑声不停的从她嘴里冒出来。她就是这样子，只要吃东西的时候就特别兴奋，好像注射了兴奋剂一样，边吃边说边比划，从来也不为快要超标的体重而发愁。

    这里的夜晚总是凉风习习，我喜欢在这样的夜晚，听一首歌，看月亮，伴着耳边的虫鸣，意识慢慢飘缈起来。最近总听那一首twins<<瓶中沙>>,

树梢的枝桠，开满凤凰花
问你知道吗，成长要代价
风雨在敲打，我放心不下
去年的嫩芽，又怎能无暇

亲爱的朋友，与你共渡的年华
让我的回忆很潇洒

瓶中沙装的话
我用笔写下
海风刮竹篱笆
我们埋下它
瓶中沙写的话
问你是否还牵挂
那张年轻熟悉的脸颊
留长的发
逃离过的家

四季在变化
秋冬又春夏
问你知道吗
年少在尴尬
说过的笑话
曾经吵的架
我们牢记它
友谊在长大

让青春喧哗
我们大声的表达
将未来的地图重画

瓶中沙装的话
我用笔写下
海风刮竹篱笆
我们埋下它
瓶中沙写的话
问你是否还牵挂
那张年轻熟悉的脸颊

瓶中沙装的话
我用笔写下
海风刮竹篱笆
我们埋下它
瓶中沙写的话
问你是否还牵挂
那张年轻熟悉的脸颊
留长的发
逃离过的家

记得多年后的下午茶
我们约好要一起喝下

  你收到我的信，然后放在某个角落。无聊的时候你或者想起了这个等待着你开启的信封，于是你随意地给信纸撕开了个口子。眼睛先是往瞧瞧，发现了这张精致的信纸。你想或许又是哪个花痴的女生给你写了些花痴的文字表扬你的忧伤。你打开了信纸，小心翼翼地翻起那些由我细心编织的折痕，终于你看到以上的文字，那些我写给你的开场白。
　　你经常说些自以为让人觉得颓废的关于忧伤的句子。你说他们终究不会热情地喜欢上个用文字记述忧伤的男生。或许你没有在阳光下面接受体育有关挥汗如雨的历练，貌似总是弱不禁风地叨念着自己的文字，但或许这样平淡的忧伤会让某些人感觉舒适。或许我就是某些人里面的某个，某个不单喜欢你文字的女生。
　　这里浮躁的空气里会常有你的影子,尽管你总会是那么的安静。安静的文字被安静的你收敛起了更多的浮华，我独自坐在某个角落里靠着窗口斜射入的光线读着你熹微安详的文字。华丽的辞藻仿佛是在竭力地安抚着关于青春的隐隐痛楚。习惯看着你用很少的笔迹描摹微笑的表情，习惯看着你笔尖滑动而弯曲的每个弧线，每个记述忧伤的点滴文字。你没有让忧伤泛滥成河，却足以掠走我的泪水，没有那么多的情节却足够让我们彼此忧郁地悲伤。或许是什么遮挡住了你的双眼，封闭了明媚的阳光，或者我又那么钟爱着关于痛楚的文字，那么多的华丽辞藻铺垫而成的华丽句子，那么多的关于你的笔迹。
　　我想了很久给你写这封简短的书信。我会担心我的文字不会有那么多的修辞而让你懒于阅读，我会担心你会不屑于我的幼稚情感而懒于提笔给我回信，我会担心你会在某个时候不再抒写我们彼此的忧伤而饱和满让你有些难过的锋芒。
　　我们微笑然后继续征途。黑夜那么多殷实的际遇，包裹忧伤，包裹着忧伤里面的我们。黑夜里的征途攀爬满黑色的荆棘，我们各自安抚着忧伤，各自渲染着凄凉，文字由最后的那个句号停止，天空里的黑色突兀地冒出了道白色的光芒，或许长夜里的故事已经快要结束，而天空即将像你的名字那样即将明朗。

  我是在某个午后开启这封来信，发现娟秀的字体和几个精致的卡通娃娃。整个下午恐怕都会沉浸着你给予我的快乐里面。我没有急于回信，只是反复地看着你漂亮的字体及我们共同拥有的忧伤。我似乎不知道从何提笔介入我们的这次对话，就好像某个习惯忧伤的人不知道如何快乐。我换了支蓝黑墨水的钢笔，希望那些稀有的蓝色能够调和我那些有些隐隐作痛的文字。

   我将就你给我寄来的信纸在背面写我给你的回信。我担心你会觉得我是用些陈词滥调敷衍你的情感，所以我坚持用笔亲自抒写那些点滴滴落却不曾泛滥的温情文字。我猜想着你的容貌，或许这不是那么重要，貌似就好像陌生人见面前的忐忑不安，我依然把光芒赋予在你的身上，那个说挚爱朗朗的漂亮女生。
　　黑色的夜晚总是与白昼貌似均衡的平分着每天。我却有些刻意地把自己划分入黑色阴霾顾及到的阴郁里，我们不能托词于习惯来解释我的习惯。这或许是受某某的影响，习惯某某说话时候的语气，习惯某某写字时候勾勒出的忧伤，习惯某某说话时候总习惯加上的那个貌似。你却与我不那么相同，至少我们从性别上讲应该柔刚相合。你不应该看着我的忧伤而忧伤，应该快乐地想着还有个比你忧伤的孩子，这并不是我常常所说的幸灾乐祸，这是种快乐的暗示，告诉我们需要各自幸福，因为彼此的幸福终究是需要各自去完成的。所以你的明媚需要包裹偶尔的忧伤。
　　我不知道说话的语调是否有些让人生恶了，教条似的有些让人反感的讲述性文字。我们都习惯听着老师的教诲明白人生，我们又总是抱怨教条似的烦琐文字给了老师处罚我们的诸多理由，可是我们终究是孩子，就好像人们总把我们比喻成花朵，而老师就像是园丁，他们裁剪我们，浇育我们，我们也总习惯了由他们的悉心照料而慢慢地茁壮成长。
　　我们的人生就是习惯些不习惯的事情，然后不习惯些习惯的事情。偶尔犯错或许不能让我们洗心革面，却能让我们知道错误及正确的所受到的不同境遇。每个孩子都需要表扬，不管是阴霾包裹明媚或是明媚包裹阴霾。我们不是冷血的动物，适时的转替角色或者属于心灵上的调节，我们的情感丰富却不廉价，我们不能刻意地出卖自己的情感甚至去卖弄所谓的忧伤，或者仅仅那样写些文字给陌生人看也是莫大的罪过，人终于还是追求真实的多些而虚度的假劣少些，所以你要相信，阳光终究会在风雨过后安抚泪水磅礴的大地及生在这里的我们。
　　很久没有用信纸写过这样的文字，似乎所有的书信都习惯了末尾给予个祝福。我誊写了你给我的来信的信封上的地址，然后习惯前人们的习惯工整地给你简短的来自某个午后祝福，祝你幸福。

   这或许不是个明媚的午后，空气里面的雨水已经足够酝酿某场恢弘的瓢泼舞曲。我并没有因为雨水的滋扰而感觉乌云倾覆，或许正是因为你给我的文字让我觉得了温暖，觉得明媚还是包裹着阴霾好些。
　　你告诉我说，我们终究是不那么相似的。我不同意你说让我幸灾乐祸地看待你的忧伤，或许我们终究是注定成为那些以忧伤为火种取暖的孩子。尽管我们不曾饥寒，我们不曾有过真正的悲苦命运，可是我们却延续着文字里面与生活毫无瓜葛的悲伤，那些幸福的悲伤及我们描绘悲伤时候所用的阴郁句子，华丽辞藻及漂亮的让人们捉摸不透的漂亮的修辞。或许某些人是由表及里的阴郁，或许我们是忧伤参半着快乐。

   我迷途在了青春编织的十字路口。 没有人告诉我将何去何从，我是否亦会如他们那样奔走天涯或者我与他们是不同的，我应该安分的让青春安然的死去。
　　没有人告诉我将如何选择，喜欢或者不喜欢，前赴后继或者开天辟地。我仅仅是个娇小的女生，他们眼里的柔弱，我眼里的无法拯救，我无法拯救自己就像我无法安然的忘记忧伤，无法安然放下青春。
　　我哭着抱着文字的符号啃着苍黄的记忆。烙印了青春身后的忧伤，镌刻了青春梦想的繁华。我在这里纪念前世苍老，憧憬后世青春。
　　我仅仅是微微疼痛并且微微哭泣的女生，还是那个喜欢你的文字及你的女生。

June 19, 2006 (Computerworld) -- Willy Anderson remembers the day he realized the human impact of the work he does at Allstate Insurance Co. When he started as an intern at the insurance giant at the age of 19, Anderson was responsible for maintaining the company's claims loss reporting system. As part of that job, he listened in on a call that the claim center received from a woman who had just been in a car accident.

"She was crying because her husband was trapped in the car, and she wasn't sure if he was alive," says Anderson, now infrastructure services senior manager at the $33.9 billion insurer, which ranks No. 62 on Computerworld's 2006 Best Places to Work in IT list. "My work took on a whole new meaning after that. When you see how the claims reps can and can't touch the client when the system goes down, you realize you're in IT because of the promise Allstate sells its customers, not just because of your skill level with a given technology."

Just as important, Anderson later shared his eye-opening experience with all of his direct reports, who thereafter also got a chance to listen in on claims calls. Their ability to appreciate the way Allstate touches its customers' lives -- along with Anderson's own freedom to institute that kind of change -- are both key ways in which the company makes individuals in IT know that their work matters, he says.

It may seem difficult to believe that in this age where "employer" and "loyalty" don't often appear in the same sentence, employees of companies on this year's Best Places list agree that a big reason their firms deserve that ranking is because they foster a culture that nourishes not just their careers, but the human beings pursuing those careers as well. In fact, in our survey of more than 27,000 IT workers at this year's Best Places, 80% said their jobs are both interesting and challenging.

"Salaries are a good thing, but it's all about the feeling on the part of the employee that they're part of the whole experience," says Dennis Foster, vice president of enterprise technology planning and engineering and architecture at Washington-based Marriott International Inc., No. 19 on the list.

Or as Cathy Brune, chief technology officer at Allstate, puts it, it's about encouraging employees to bring "the whole person" to work. "We try to create an environment where you can be not just a great technologist -- which is the left-brain, logical side -- but you can also use your right-brain, empathetic, creative side." That means recognizing that IT people need to feel valued, stretch their capabilities, be part of a community and lead a life outside of work.

Best Places do this in myriad ways, such as making technology a vital part of the business strategy, fostering strong intracompany relationships, seeking and responding to feedback for improved work/life balance, enabling the flow of ideas and helping employees keep up with fast-changing technology.

And there are other reasons why employees of these companies showed high satisfaction levels this year. Just 37% of the companies experienced IT layoffs, versus 43% the year before. Hiring is up, salaries are expected to climb, and the majority of companies will issue bonuses. And although employee satisfaction with morale and salaries stayed virtually the same, the percentage of respondents who agreed or strongly agreed that their jobs are secure rose from 68% to 71% this year.

#ifndef CIniFile_H
#define CIniFile_H

// C++ Includes
#include <string>
#include <vector>

// C Includes
#include <stdlib.h>

#define MAX_KEYNAME    128
#define MAX_VALUENAME  128
#define MAX_VALUEDATA 2048

class CIniFile 
{
private:
  bool   caseInsensitive;
  string path;
  struct key {
    vector<string> names;
    vector<string> values;
    vector<string> comments;
  };
  vector<key>    keys;
  vector<string> names;
  vector<string> comments;
  string CheckCase( string s) const;

public:
  enum errors{ noID = -1};
  CIniFile( string const iniPath = "");
  virtual ~CIniFile()                            {}

  // Sets whether or not keynames and valuenames should be case sensitive.
  // The default is case insensitive.vfg
  void CaseSensitive()                           {caseInsensitive = false;}
  void CaseInsensitive()                         {caseInsensitive = true;}

  // Sets path of ini file to read and write from.
  void Path(string const newPath)                {path = newPath;}
  string Path() const                            {return path;}
  void SetPath(string const newPath)             {Path( newPath);}

  // Reads ini file specified using path.
  // Returns true if successful, false otherwise.
  bool ReadFile();
 
  // Writes data stored in class to ini file.
  bool WriteFile();
 
  // Deletes all stored ini data.
  void Erase();
  void Clear()                                   {Erase();}
  void Reset()                                   {Erase();}

  // Returns index of specified key, or noID if not found.
  long FindKey( string const keyname) const;

  // Returns index of specified value, in the specified key, or noID if not found.
  long FindValue( unsigned const keyID, string const valuename) const;

  // Returns number of keys currently in the ini.
  unsigned NumKeys() const                       {return names.size();}
  unsigned GetNumKeys() const                    {return NumKeys();}

  // Add a key name.
  unsigned AddKeyName( string const keyname);

  // Returns key names by index.
  string KeyName( unsigned const keyID) const;
  string GetKeyName( unsigned const keyID) const {return KeyName(keyID);}

  // Returns number of values stored for specified key.
  unsigned NumValues( unsigned const keyID);
  unsigned GetNumValues( unsigned const keyID)   {return NumValues( keyID);}
  unsigned NumValues( string const keyname);
  unsigned GetNumValues( string const keyname)   {return NumValues( keyname);}

  // Returns value name by index for a given keyname or keyID.
  string ValueName( unsigned const keyID, unsigned const valueID) const;
  string GetValueName( unsigned const keyID, unsigned const valueID) const {
    return ValueName( keyID, valueID);
  }
  string ValueName( string const keyname, unsigned const valueID) const;
  string GetValueName( string const keyname, unsigned const valueID) const {
    return ValueName( keyname, valueID);
  }

  // Gets value of [keyname] valuename =.
  // Overloaded to return string, int, and double.
  // Returns defValue if key/value not found.
  string GetValue( unsigned const keyID, unsigned const valueID, string const defValue = "") const;
  string GetValue(string const keyname, string const valuename, string const defValue = "") const;
  int    GetValueI(string const keyname, string const valuename, int const defValue = 0) const;
  bool   GetValueB(string const keyname, string const valuename, bool const defValue = false) const {
    return bool( GetValueI( keyname, valuename, int( defValue)));
  }
  double   GetValueF(string const keyname, string const valuename, double const defValue = 0.0) const;
  // This is a variable length formatted GetValue routine. All these voids
  // are required because there is no vsscanf() like there is a vsprintf().
  // Only a maximum of 8 variable can be read.
  unsigned GetValueV( string const keyname, string const valuename, char *format,
        void *v1 = 0, void *v2 = 0, void *v3 = 0, void *v4 = 0,
          void *v5 = 0, void *v6 = 0, void *v7 = 0, void *v8 = 0,
          void *v9 = 0, void *v10 = 0, void *v11 = 0, void *v12 = 0,
          void *v13 = 0, void *v14 = 0, void *v15 = 0, void *v16 = 0);

  // Sets value of [keyname] valuename =.
  // Specify the optional paramter as false (0) if you do not want it to create
  // the key if it doesn't exist. Returns true if data entered, false otherwise.
  // Overloaded to accept string, int, and double.
  bool SetValue( unsigned const keyID, unsigned const valueID, string const value);
  bool SetValue( string const keyname, string const valuename, string const value, bool const create = true);
  bool SetValueI( string const keyname, string const valuename, int const value, bool const create = true);
  bool SetValueB( string const keyname, string const valuename, bool const value, bool const create = true) {
    return SetValueI( keyname, valuename, int(value), create);
  }
  bool SetValueF( string const keyname, string const valuename, double const value, bool const create = true);
  bool SetValueV( string const keyname, string const valuename, char *format, ...);

  // Deletes specified value.
  // Returns true if value existed and deleted, false otherwise.
  bool DeleteValue( string const keyname, string const valuename);
 
  // Deletes specified key and all values contained within.
  // Returns true if key existed and deleted, false otherwise.
  bool DeleteKey(string keyname);

  // Header comment functions.
  // Header comments are those comments before the first key.
  //
  // Number of header comments.
  unsigned NumHeaderComments()                  {return comments.size();}
  // Add a header comment.
  void     HeaderComment( string const comment);
  // Return a header comment.
  string   HeaderComment( unsigned const commentID) const;
  // Delete a header comment.
  bool     DeleteHeaderComment( unsigned commentID);
  // Delete all header comments.
  void     DeleteHeaderComments()               {comments.clear();}

  // Key comment functions.
  // Key comments are those comments within a key. Any comments
  // defined within value names will be added to this list. Therefore,
  // these comments will be moved to the top of the key definition when
  // the CIniFile::WriteFile() is called.
  //
  // Number of key comments.
  unsigned NumKeyComments( unsigned const keyID) const;
  unsigned NumKeyComments( string const keyname) const;
  // Add a key comment.
  bool     KeyComment( unsigned const keyID, string const comment);
  bool     KeyComment( string const keyname, string const comment);
  // Return a key comment.
  string   KeyComment( unsigned const keyID, unsigned const commentID) const;
  string   KeyComment( string const keyname, unsigned const commentID) const;
  // Delete a key comment.
  bool     DeleteKeyComment( unsigned const keyID, unsigned const commentID);
  bool     DeleteKeyComment( string const keyname, unsigned const commentID);
  // Delete all comments for a key.
  bool     DeleteKeyComments( unsigned const keyID);
  bool     DeleteKeyComments( string const keyname);
};

#endif

// IniFile.cpp:  Implementation of the CIniFile class.
// Written by:   Adam Clauss
// Email: cabadam@houston.rr.com
// You may use this class/code as you wish in your programs.  Feel free to distribute it, and
// email suggested changes to me.
//
// Rewritten by: Shane Hill
// Date:         21/08/2001
// Email:        Shane.Hill@dsto.defence.gov.au
// Reason:       Remove dependancy on MFC. Code should compile on any
//               platform.
//////////////////////////////////////////////////////////////////////

// C++ Includes
#include <iostream>
#include <fstream>
#include <strstream>

using namespace std;

// C Includes
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>

// Local Includes
#include "iniFile.h"

#if defined(WIN32)
#define iniEOL endl
#else
#define iniEOL '\r' << endl
#endif

CIniFile::CIniFile( string const iniPath)
{
  Path( iniPath);
  caseInsensitive = true;
}

bool CIniFile::ReadFile()
{
  // Normally you would use ifstream, but the SGI CC compiler has
  // a few bugs with ifstream. So ... fstream used.
  fstream f;
  string   line;
  string   keyname, valuename, value;
  string::size_type pLeft, pRight;

  f.open( path.c_str(), ios::in);
  if ( f.fail())
    return false;
 
  while( getline( f, line)) {
    // To be compatible with Win32, check for existence of '\r'.
    // Win32 files have the '\r' and Unix files don't at the end of a line.
    // Note that the '\r' will be written to INI files from
    // Unix so that the created INI file can be read under Win32
    // without change.
    if ( line[line.length() - 1] == '\r')
      line = line.substr( 0, line.length() - 1);
   
    if ( line.length()) {
      // Check that the user hasn't openned a binary file by checking the first
      // character of each line!
      if ( !isprint( line[0])) {
 printf( "Failing on char %d\n", line[0]);
 f.close();
 return false;
      }
      if (( pLeft = line.find_first_of(";#[=")) != string::npos) {
 switch ( line[pLeft]) {
 case '[':
   if ((pRight = line.find_last_of("]")) != string::npos &&
       pRight > pLeft) {
     keyname = line.substr( pLeft + 1, pRight - pLeft - 1);
     AddKeyName( keyname);
   }
   break;
  
 case '=':
   valuename = line.substr( 0, pLeft);
   value = line.substr( pLeft + 1);
   SetValue( keyname, valuename, value);
   break;
  
 case ';':
 case '#':
   if ( !names.size())
     HeaderComment( line.substr( pLeft + 1));
   else
     KeyComment( keyname, line.substr( pLeft + 1));
   break;
 }
      }
    }
  }

  f.close();
  if ( names.size())
    return true;
  return false;
}

bool CIniFile::WriteFile()
{
  unsigned commentID, keyID, valueID;
  // Normally you would use ofstream, but the SGI CC compiler has
  // a few bugs with ofstream. So ... fstream used.
  fstream f;

  f.open( path.c_str(), ios::out);
  if ( f.fail())
    return false;

  // Write header comments.
  for ( commentID = 0; commentID < comments.size(); ++commentID)
    f << ';' << comments[commentID] << iniEOL;
  if ( comments.size())
    f << iniEOL;

  // Write keys and values.
  for ( keyID = 0; keyID < keys.size(); ++keyID) {
    f << '[' << names[keyID] << ']' << iniEOL;
    // Comments.
    for ( commentID = 0; commentID < keys[keyID].comments.size(); ++commentID)
      f << ';' << keys[keyID].comments[commentID] << iniEOL;
    // Values.
    for ( valueID = 0; valueID < keys[keyID].names.size(); ++valueID)
      f << keys[keyID].names[valueID] << '=' << keys[keyID].values[valueID] << iniEOL;
    f << iniEOL;
  }
  f.close();
 
  return true;
}

long CIniFile::FindKey( string const keyname) const
{
  for ( unsigned keyID = 0; keyID < names.size(); ++keyID)
    if ( CheckCase( names[keyID]) == CheckCase( keyname))
      return long(keyID);
  return noID;
}

long CIniFile::FindValue( unsigned const keyID, string const valuename) const
{
  if ( !keys.size() || keyID >= keys.size())
    return noID;

  for ( unsigned valueID = 0; valueID < keys[keyID].names.size(); ++valueID)
    if ( CheckCase( keys[keyID].names[valueID]) == CheckCase( valuename))
      return long(valueID);
  return noID;
}

unsigned CIniFile::AddKeyName( string const keyname)
{
  names.resize( names.size() + 1, keyname);
  keys.resize( keys.size() + 1);
  return names.size() - 1;
}

string CIniFile::KeyName( unsigned const keyID) const
{
  if ( keyID < names.size())
    return names[keyID];
  else
    return "";
}

unsigned CIniFile::NumValues( unsigned const keyID)
{
  if ( keyID < keys.size())
    return keys[keyID].names.size();
  return 0;
}

unsigned CIniFile::NumValues( string const keyname)
{
  long keyID = FindKey( keyname);
  if ( keyID == noID)
    return 0;
  return keys[keyID].names.size();
}

string CIniFile::ValueName( unsigned const keyID, unsigned const valueID) const
{
  if ( keyID < keys.size() && valueID < keys[keyID].names.size())
    return keys[keyID].names[valueID];
  return "";
}

string CIniFile::ValueName( string const keyname, unsigned const valueID) const
{
  long keyID = FindKey( keyname);
  if ( keyID == noID)
    return "";
  return ValueName( keyID, valueID);
}

bool CIniFile::SetValue( unsigned const keyID, unsigned const valueID, string const value)
{
  if ( keyID < keys.size() && valueID < keys[keyID].names.size())
    keys[keyID].values[valueID] = value;

  return false;
}

bool CIniFile::SetValue( string const keyname, string const valuename, string const value, bool const create)
{
  long keyID = FindKey( keyname);
  if ( keyID == noID) {
    if ( create)
      keyID = long( AddKeyName( keyname));
    else
      return false;
  }

  long valueID = FindValue( unsigned(keyID), valuename);
  if ( valueID == noID) {
    if ( !create)
      return false;
    keys[keyID].names.resize( keys[keyID].names.size() + 1, valuename);
    keys[keyID].values.resize( keys[keyID].values.size() + 1, value);
  } else
    keys[keyID].values[valueID] = value;

  return true;
}

bool CIniFile::SetValueI( string const keyname, string const valuename, int const value, bool const create)
{
  char svalue[MAX_VALUEDATA];

  sprintf( svalue, "%d", value);
  return SetValue( keyname, valuename, svalue);
}

bool CIniFile::SetValueF( string const keyname, string const valuename, double const value, bool const create)
{
  char svalue[MAX_VALUEDATA];

  sprintf( svalue, "%f", value);
  return SetValue( keyname, valuename, svalue);
}

bool CIniFile::SetValueV( string const keyname, string const valuename, char *format, ...)
{
  va_list args;
  char value[MAX_VALUEDATA];

  va_start( args, format);
  vsprintf( value, format, args);
  va_end( args);
  return SetValue( keyname, valuename, value);
}

string CIniFile::GetValue( unsigned const keyID, unsigned const valueID, string const defValue) const
{
  if ( keyID < keys.size() && valueID < keys[keyID].names.size())
    return keys[keyID].values[valueID];
  return defValue;
}

string CIniFile::GetValue( string const keyname, string const valuename, string const defValue) const
{
  long keyID = FindKey( keyname);
  if ( keyID == noID)
    return defValue;

  long valueID = FindValue( unsigned(keyID), valuename);
  if ( valueID == noID)
    return defValue;

  return keys[keyID].values[valueID];
}

int CIniFile::GetValueI(string const keyname, string const valuename, int const defValue) const
{
  char svalue[MAX_VALUEDATA];

  sprintf( svalue, "%d", defValue);
  return atoi( GetValue( keyname, valuename, svalue).c_str());
}

double CIniFile::GetValueF(string const keyname, string const valuename, double const defValue) const
{
  char svalue[MAX_VALUEDATA];

  sprintf( svalue, "%f", defValue);
  return atof( GetValue( keyname, valuename, svalue).c_str());
}

// 16 variables may be a bit of over kill, but hey, it's only code.
unsigned CIniFile::GetValueV( string const keyname, string const valuename, char *format,
         void *v1, void *v2, void *v3, void *v4,
           void *v5, void *v6, void *v7, void *v8,
           void *v9, void *v10, void *v11, void *v12,
           void *v13, void *v14, void *v15, void *v16)
{
  string   value;
  // va_list  args;
  unsigned nVals;

  value = GetValue( keyname, valuename);
  if ( !value.length())
    return false;
  // Why is there not vsscanf() function. Linux man pages say that there is
  // but no compiler I've seen has it defined. Bummer!
  //
  // va_start( args, format);
  // nVals = vsscanf( value.c_str(), format, args);
  // va_end( args);

  nVals = sscanf( value.c_str(), format,
    v1, v2, v3, v4, v5, v6, v7, v8,
    v9, v10, v11, v12, v13, v14, v15, v16);

  return nVals;
}

bool CIniFile::DeleteValue( string const keyname, string const valuename)
{
  long keyID = FindKey( keyname);
  if ( keyID == noID)
    return false;

  long valueID = FindValue( unsigned(keyID), valuename);
  if ( valueID == noID)
    return false;

  // This looks strange, but is neccessary.
  vector<string>::iterator npos = keys[keyID].names.begin() + valueID;
  vector<string>::iterator vpos = keys[keyID].values.begin() + valueID;
  keys[keyID].names.erase( npos, npos + 1);
  keys[keyID].values.erase( vpos, vpos + 1);

  return true;
}

bool CIniFile::DeleteKey( string const keyname)
{
  long keyID = FindKey( keyname);
  if ( keyID == noID)
    return false;

  // Now hopefully this destroys the vector lists within keys.
  // Looking at <vector> source, this should be the case using the destructor.
  // If not, I may have to do it explicitly. Memory leak check should tell.
  // memleak_test.cpp shows that the following not required.
  //keys[keyID].names.clear();
  //keys[keyID].values.clear();

  vector<string>::iterator npos = names.begin() + keyID;
  vector<key>::iterator    kpos = keys.begin() + keyID;
  names.erase( npos, npos + 1);
  keys.erase( kpos, kpos + 1);

  return true;
}

void CIniFile::Erase()
{
  // This loop not needed. The vector<> destructor seems to do
  // all the work itself. memleak_test.cpp shows this.
  //for ( unsigned i = 0; i < keys.size(); ++i) {
  //  keys[i].names.clear();
  //  keys[i].values.clear();
  //}
  names.clear();
  keys.clear();
  comments.clear();
}

void CIniFile::HeaderComment( string const comment)
{
  comments.resize( comments.size() + 1, comment);
}

string CIniFile::HeaderComment( unsigned const commentID) const
{
  if ( commentID < comments.size())
    return comments[commentID];
  return "";
}

bool CIniFile::DeleteHeaderComment( unsigned commentID)
{
  if ( commentID < comments.size()) {
    vector<string>::iterator cpos = comments.begin() + commentID;
    comments.erase( cpos, cpos + 1);
    return true;
  }
  return false;
}

unsigned CIniFile::NumKeyComments( unsigned const keyID) const
{
  if ( keyID < keys.size())
    return keys[keyID].comments.size();
  return 0;
}

unsigned CIniFile::NumKeyComments( string const keyname) const
{
  long keyID = FindKey( keyname);
  if ( keyID == noID)
    return 0;
  return keys[keyID].comments.size();
}

bool CIniFile::KeyComment( unsigned const keyID, string const comment)
{
  if ( keyID < keys.size()) {
    keys[keyID].comments.resize( keys[keyID].comments.size() + 1, comment);
    return true;
  }
  return false;
}

bool CIniFile::KeyComment( string const keyname, string const comment)
{
  long keyID = FindKey( keyname);
  if ( keyID == noID)
    return false;
  return KeyComment( unsigned(keyID), comment);
}

string CIniFile::KeyComment( unsigned const keyID, unsigned const commentID) const
{
  if ( keyID < keys.size() && commentID < keys[keyID].comments.size())
    return keys[keyID].comments[commentID];
  return "";
}

string CIniFile::KeyComment( string const keyname, unsigned const commentID) const
{
  long keyID = FindKey( keyname);
  if ( keyID == noID)
    return "";
  return KeyComment( unsigned(keyID), commentID);
}

bool CIniFile::DeleteKeyComment( unsigned const keyID, unsigned const commentID)
{
  if ( keyID < keys.size() && commentID < keys[keyID].comments.size()) {
    vector<string>::iterator cpos = keys[keyID].comments.begin() + commentID;
    keys[keyID].comments.erase( cpos, cpos + 1);
    return true;
  }
  return false;
}

bool CIniFile::DeleteKeyComment( string const keyname, unsigned const commentID)
{
  long keyID = FindKey( keyname);
  if ( keyID == noID)
    return false;
  return DeleteKeyComment( unsigned(keyID), commentID);
}

bool CIniFile::DeleteKeyComments( unsigned const keyID)
{
  if ( keyID < keys.size()) {
    keys[keyID].comments.clear();
    return true;
  }
  return false;
}

bool CIniFile::DeleteKeyComments( string const keyname)
{
  long keyID = FindKey( keyname);
  if ( keyID == noID)
    return false;
  return DeleteKeyComments( unsigned(keyID));
}

string CIniFile::CheckCase( string s) const
{
  if ( caseInsensitive)
    for ( string::size_type i = 0; i < s.length(); ++i)
      s[i] = tolower(s[i]);
  return s;
}

//info.h 为自己的应用提供接口
#include <string>

using namespace std;
class CGetInfo
{
public:
 CGetInfo();
 CGetInfo(string iniFileAddress);
 ~CGetInfo() {}
 string GetEmail();
 int GetRtime();
    int GetRnumber();
    string GetLlist();
    string GetRlist();
    string GetIp();
    int GetPort();
    string GetFilename();
    string GetUsername();
    string GetPassword();
private:
    string m_iniFileAddress;
};

//info.cpp

#include <stdio.h>
#include <string.h>
#include "info.h"
#include "iniFile.h"

CIniFile iniFile;

CGetInfo::CGetInfo()
{
 iniFile.Path("./ini_test.ini");
 iniFile.ReadFile();
}
CGetInfo::CGetInfo(string iniFileAddress)
{
 m_iniFileAddress=iniFileAddress;
 iniFile.Path(m_iniFileAddress);
 iniFile.ReadFile();
}
 string CGetInfo::GetEmail()
{ 
 return iniFile.GetValue( "userinfo", "emailadd");
}
 string CGetInfo::GetFilename()
{
 return iniFile.GetValue( "fileinfo", "filename");
}
 string CGetInfo::GetIp()
{
 return iniFile.GetValue( "hostinfo", "ipaddress");
}
 string CGetInfo::GetLlist()
{
 return iniFile.GetValue( "fileinfo", "locallist");
}
 string CGetInfo::GetPassword()
{
 return iniFile.GetValue( "userinfo", "password");
}
int CGetInfo::GetPort()
{
 return iniFile.GetValueI( "hostinfo", "port");
}
string CGetInfo::GetRlist()
{
 return iniFile.GetValue( "fileinfo", "remotelist");
}
int CGetInfo::GetRnumber()
{
 return iniFile.GetValueI( "timeinfo", "retrynumber");
}
int CGetInfo::GetRtime()
{
 return iniFile.GetValueI( "timeinfo", "retrytime");
}
 string CGetInfo::GetUsername()
{
 return iniFile.GetValue( "userinfo", "username");
}

//test
#include <iostream>

using namespace std;
#include <string>
#include "iniFile.h"
#include "info.h"

int main()
{
 //CGetInfo getInfo("c:\\ini_test.ini");
 CGetInfo getInfo；
 string sl;

 sl=getInfo.GetEmail();
 cout<< sl<<endl;

   int i;
   cin>>i;
   return 0;
}

ini_test.ini 文件放在自己设定的路径下，或者放在默认路径当前路径下[hostinfo]
ipaddress=127.0.0.1
port=21
; This is another test comment for 386enh
; This is another test comment for 386enh

[fileinfo]
filename=mappoint.h
locallist=f:\download\mappoint.h
remotelist=c:\mappoint.h

[timeinfo]
retrynumber=5
retrytime=2

[userinfo]
username=casper
password=123456
emailadd=huimingsu@nettech-global.com

ini.rar

#include <string>

using namespace std;

//日志文件类
//用来把系统运行过程中的状态信息保存在文件中以方便用户跟踪的类
class CLog
{
public:
 CLog();//默认情况下日志的保存地点为当前目录，日志名称info.log

 CLog(const string dir);//用户自定义日志文件的保存目录及文件名

 void log(const string title, const string desc);//用来向日志文件输出信息的成员函数

    void log(const string &text);

 CLog &operator << ( const char * text);

    CLog &operator << ( const string &text);
 
    CLog &operator << ( const int value);
 
    CLog &operator << ( const unsigned int value);
 
    CLog &operator << ( const float value);
 
    CLog &operator << ( const double value);
private:
    string m_LogDir;
    string m_FullName;
    bool m_IsStdout;
    bool m_IsFileOk; 
    const string getTimeStr(const bool isFileName = false);
};

//CLog.cpp

#include <time.h>
#include "Clog.h"

#define TIMESTAMP(t) ("[" + (t) + "]: ")

CLog::CLog()
{
 m_FullName = "./info.log";
    m_IsFileOk=true;
    m_IsStdout=false;
    FILE* fi;
    fi = fopen(m_FullName.c_str(), "a");
}
CLog::CLog(const string dir)
{
 m_FullName=dir;
    m_IsFileOk=true;
    m_IsStdout=false;
    FILE* fi;
    fi = fopen(m_FullName.c_str(), "w");
}
 
const string CLog::getTimeStr(const bool isFileName)
{
  time_t now;
  struct tm * ti; // timeinfo
  now = time(NULL);
  ti = localtime(&now);
 
  char buf[200];
  /// the string in format "YYYY-MM-dd_hh-mm-ss"
  sprintf(buf, isFileName?("%d-%02d-%02d_%02d-%02d-%02d"):("%d-%02d-%02d %02d:%02d:%02d"),
                       ti->tm_year + 1900,
                       ti->tm_mon + 1,
                       ti->tm_mday,
                       ti->tm_hour,
                       ti->tm_min,
                       ti->tm_sec );
  return string(buf);
}
void CLog::log(const string title, const string desc)
{
 
  log(title + " -- " + desc);

}
void CLog::log(const string &text)
{
  if( m_FullName != "" && !m_IsFileOk ) return;
  (*this) << text;
}
CLog &CLog::operator << ( const char *text)
{
  if( m_FullName != "")
  {
      if(!m_IsFileOk ) return *this;
      FILE* fi;
      fi = fopen(m_FullName.c_str(), "a");
      if (fi != NULL)
   {
        char buf[500];
        strcpy(buf, TIMESTAMP(getTimeStr()).c_str());
        strcat(buf, text);
        strcat(buf, "\n");
        fwrite(buf, sizeof(char), strlen(buf), fi);
        fclose(fi);
      }
  }
  else
  {
    fprintf(m_IsStdout?stdout:stderr, "%s%s\n", TIMESTAMP(getTimeStr()).c_str(), text);
  }
  return *this;
}
CLog &CLog::operator << ( const string &text)
{
  return (*this)<< text.c_str();
}
CLog &CLog::operator << ( const int value)
{
  char tmp[100];
  sprintf(tmp, "%d", value);
  return (*this)<< tmp;
}
CLog &CLog::operator << ( const unsigned int value)
{
  char tmp[100];
  sprintf(tmp, "%d", value);
  return (*this)<< tmp;
}
CLog &CLog::operator << ( const float value)
{
  char tmp[100];
  sprintf(tmp, "%-f", value);
  return (*this)<< tmp;
}
CLog &CLog::operator << ( const double value)
{
  char tmp[100];
  sprintf(tmp, "%-f", value);
  return (*this)<< tmp;
}

//test.cpp

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

int main()
{
 CLog lg;
 const string m="c:\\book\\test.cpp";
 const string n="connect error";
 for(int i=0;i<10;i++)
 {
  lg.log(m,n);
 }
  cin >> i;
 for (int j=0;j<i;j++)
 {
  lg.log(m,n);
 }

}

 对象（Object）是类（Class）的一个实例（Instance）。如果将对象比作房子，那么类就是房子的设计图纸。所以面向对象设计的重点是类的设计，而不是对象的设计。

对于C++程序而言，设计孤立的类是比较容易的，难的是正确设计基类及其派生类。本章仅仅论述“继承”（Inheritance）和“组合”（Composition）的概念。

注意，当前面向对象技术的应用热点是COM和CORBA，这些内容超出了C++教材的范畴，请阅读COM和CORBA相关论著。

10.1 继承

如果A是基类，B是A的派生类，那么B将继承A的数据和函数。例如：

       class A

{

  public:

              void  Func1(void);

              void  Func2(void);

};

class B : public A

{

  public:

              void  Func3(void);

              void  Func4(void);

};

       main()

{

              B  b;                    

              b.Func1();              // B从A继承了函数Func1

              b.Func2();              // B从A继承了函数Func2

              b.Func3();

              b.Func4();

}

这个简单的示例程序说明了一个事实：C++的“继承”特性可以提高程序的可复用性。正因为“继承”太有用、太容易用，才要防止乱用“继承”。我们应当给“继承”立一些使用规则。

l         【规则10-1-1】如果类A和类B毫不相关，不可以为了使B的功能更多些而让B继承A的功能和属性。不要觉得“白吃白不吃”，让一个好端端的健壮青年无缘无故地吃人参补身体。

l         【规则10-1-2】若在逻辑上B是A的“一种”（a kind of ），则允许B继承A的功能和属性。例如男人（Man）是人（Human）的一种，男孩（Boy）是男人的一种。那么类Man可以从类Human派生，类Boy可以从类Man派生。

         class Human

{

                  …

};

         class Man : public Human

{

                  …

};

         class Boy : public Man

{

                  …

};

u       注意事项

【规则10-1-2】看起来很简单，但是实际应用时可能会有意外，继承的概念在程序世界与现实世界并不完全相同。

例如从生物学角度讲，鸵鸟（Ostrich）是鸟（Bird）的一种，按理说类Ostrich应该可以从类Bird派生。但是鸵鸟不能飞，那么Ostrich::Fly是什么东西？

class Bird

{

public:   

       virtual void Fly(void);

…

};

class Ostrich : public Bird

{

…

};

例如从数学角度讲，圆（Circle）是一种特殊的椭圆（Ellipse），按理说类Circle应该可以从类Ellipse派生。但是椭圆有长轴和短轴，如果圆继承了椭圆的长轴和短轴，岂非画蛇添足？

       所以更加严格的继承规则应当是：若在逻辑上B是A的“一种”，并且A的所有功能和属性对B而言都有意义，则允许B继承A的功能和属性。

10.2 组合

l         【规则10-2-1】若在逻辑上A是B的“一部分”（a part of），则不允许B从A派生，而是要用A和其它东西组合出B。

例如眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head应该由类Eye、Nose、Mouth、Ear组合而成，不是派生而成。如示例10-2-1所示。

示例10-2-1 Head由Eye、Nose、Mouth、Ear组合而成

如果允许Head从Eye、Nose、Mouth、Ear派生而成，那么Head将自动具有Look、 Smell、Eat、Listen这些功能。示例10-2-2十分简短并且运行正确，但是这种设计方法却是不对的。

示例10-2-2  Head从Eye、Nose、Mouth、Ear派生而成

一只公鸡使劲地追打一只刚下了蛋的母鸡，你知道为什么吗？

因为母鸡下了鸭蛋。

很多程序员经不起“继承”的诱惑而犯下设计错误。“运行正确”的程序不见得是高质量的程序，此处就是一个例证。

Google announced plans Thursday at the O'Reilly Open Source Convention in Portland, Ore. to provide hosting for open source projects. While the effort may seem to compete with offerings such as SourceForge.net, the search giant says its intentions are not to replace those services.

The project hosting service would be available through Google Code, the company's repository for various APIs and developer tools that can be used to add Google services to applications.

If you can read this, thank your sysadmin

A sysadmin unpacked the server for this website from its box, installed an operating system, patched it for security, made sure the power and air conditioning was working in the server room, monitored it for stability, set up the software, and kept backups in case anything went wrong. All to serve this webpage.

A sysadmin installed the routers, laid the cables, configured the networks, set up the firewalls, and watched and guided the traffic for each hop of the network that runs over copper, fiber optic glass, and even the air itself to bring the Internet to your computer. All to make sure the webpage found its way from the server to your computer.

Fig. 1 Ted.

A sysadmin makes sure your network connection is safe, secure, open, and working. A sysadmin makes sure your computer is working in a healthy way on a healthy network. A sysadmin takes backups to guard against disaster both human and otherwise, holds the gates against security threats and crackers, and keeps the printers going no matter how many copies of the tax code someone from Accounting prints out.

A sysadmin worries about spam, viruses, spyware, but also power outages, fires and floods.

When the email server goes down at 2 AM on a Sunday, your sysadmin is paged, wakes up, and goes to work.

A sysadmin is a professional, who plans, worries, hacks, fixes, pushes, advocates, protects and creates good computer networks, to get you your data, to help you do work -- to bring the potential of computing ever closer to reality.

So if you can read this, thank your sysadmin -- and know she is only one of dozens or possibly hundreds whose work brings you the email from your aunt on the West Coast, the instant message from your son at college, the free phone call from the friend in Australia, and this webpage.

Show your appreciation

Friday, July 28th, 2006, is the 7th annual System Administrator Appreciation Day. On this special international day, give your System Administrator something that shows that you truly appreciate their hard work and dedication.

Let's face it, System Administrators get no respect 364 days a year. This is the day that all fellow System Administrators across the globe, will be showered with expensive sports cars and large piles of cash in appreciation of their diligent work. But seriously, we are asking for a nice token gift and some public acknowledgement. It's the least you could do.

Consider all the daunting tasks and long hours (weekends too.) Let's be honest, sometimes we don't know our System Administrators as well as they know us. Remember this is one day to recognize your System Administrator for their workplace contributions and to promote professional excellence. Thank them for all the things they do for you and your business.

   喜爱穿纯白色的女子，会让自己误以为看起来低调纯情，其实恰恰相反，纯白色的表现欲最为强烈，在所有颜色中是最出风头的，也有可能，最为性感。而，由为什么不呢？

   米白色会给白色带来一丝楚楚动人柔弱之感，会白色则会带来神秘莫测的气质。 

    懂得不同那个音调白色的表现语言，才能混合出想要表达的自我个性。

水漾艳阳

  2006年的夏天，有如热带雨林般浓烈的浮华的色调不再流行，取而代之的是以充满质感的纯白，肤色，和金色，结合淡淡的彩色与暖煦光芒，制造出透明、清新、自然而又质感的浪漫妆容。

  没有人永远童年，可是我们对童年的渴望永远。

  没有人永远童年，可是我们可以永远保持一份真纯的童心。

  永远的童话我们永远去读，

  永远的童话爱情我们永远期待。。。。。。

  在和王子的爱情里，零和不如双赢。

  爱情也是游戏，是游戏就有规则，就有输赢。在零和规律下，输赢就是盘子里的葡萄，赢家多吃了一颗，输家就要少吃一颗，一个人失去的恰巧是另一个人得到的。

  日本太子妃叫小和田雅子，原本出身于外交世家，教育良好，容貌秀丽，爱好广泛，11年前嫁给日本的德仁太子。但是，尊贵的皇太子妃的身份，并没有使她更加快乐，取而代之的是无穷无尽的烦恼。

  她的才华已渐渐被人们遗忘，为了丈夫、即为皇室传宗接代成了她人生的头等大事。尽管已经生下了小公主爱子，但根据日本战后宪法，只有男性可以继承王位，他的压力依旧。雅子在2003年年底曾经宣布，她已经因此感到精疲力尽，决定免除自己在皇室的职务。

  之后，她甚至不看重副导离开皇宫，搬回自己的娘家居住。日本皇室官员甚至表示，他们也不知道她什么时候会返回皇宫。虽然近来德仁太子曾经探访过她两次，但他大多数时间也只能住在附近的酒店里。

   假如某一天，德仁太子终于能够如愿以偿地得到一位皇太子，那他的所得，恰好是小和田雅子的所失，她失去了那么多年的快乐、以及才华释放的机会。

  而双赢，先是一种哲学意识，之后才运用于市场经济。

  约旦王后拉妮娅被誉为“阿拉伯世界的戴安娜”，她是世界上最年轻的王后，美艳照人学识丰富，婚前是苹果计算机公司的职员。拉妮娅很现代，喜欢上网，喜欢看电影，喜欢搞文学创作，喜欢打品牌的应季时装。她的行为不居一格，时间充裕的时候，她常自己驾车带家人到外面野餐，时间不充裕的时候，麦当劳餐厅也常常能迎来她的光顾。

   她每天的工作只要是治理于解决国家爱的贫穷和妇女问题，他积极参与慈善活动、去科索沃探望难民，还对企图侵吞难民救援物资的国际犯罪团伙给予严厉的痛斥，他要担当起作为一国之后的许多责任。虽然每天都在阿卜杜拉身边，但她从不越俎代庖，只是尽力做阿卜杜拉的好妻子，做丈夫的好外交牌照。

   婚姻让她更有光彩，她在婚姻里找到了自我的价值，并且协助国王更好地管理了自己的国家。

   如果把小和田雅和拉妮娅比较起来，拉妮娅生活的环境似乎更保守和更具宗教的色彩，这里的妇女甚至被禁止开车，更不用说参与政务了。但是，性格决定命运，拉妮娅敢于面对争议，她的做事风格和处事原则也得到了丈夫的支持，这才让她有机会向世界展示了自己多角度的魅力。

    和王子的真正爱情，就该是微软的cpu和浏览器，双赢！