如何用cout输出CString

嗯，这个本来没有什么。
直接cout输出的是地址，通过类型转换以后输出字符串。

可是如果你用VS2005及更高版本，那么会发现，情况变了，输出了第一个字符。
这是由于缺省是_UNICODE的。
所以需要这样写：
#ifdef _UNICODE
    /*这些都可以
    wchar_t * pTemp = (wchar_t *)csInput.GetBuffer(csInput.GetLength());
    wcout << pTemp << endl;

    wcout << (wchar_t *)csInput.GetString() << endl;
    wcout << (LPCTSTR)csInput << endl;
    wcout << (wchar_t *)(LPCTSTR)csInput << endl;
    wcout << (wchar_t *)(csInput.GetBuffer(csInput.GetLength())) << endl;
    wcout << (csInput.GetBuffer(csInput.GetLength())) << endl;
    */
#else
    /*这些都可以
    cout << (char *)csInput.GetString() << endl;
    cout << (LPCTSTR)csInput << endl;
    cout << (char *)(LPCTSTR)csInput << endl;
    cout << (char *)(csInput.GetBuffer(csInput.GetLength())) << endl;
    cout << (csInput.GetBuffer(csInput.GetLength())) << endl;
    */

_MSC_VER

_MSC_VER	MSVC	Visual C++
1600	10.0	2010
1500	9.0	2008
1400	8.0	2005
1310	7.1	.NET 2003
1300	7.0	.NET 2002
1200	6.0	6.0
1100	5.0	5.0

(zt)中国30年里最流行的30首歌

http://jiaren.org/2010/11/24/liuxing-gequ/

从1979年到2008年这30年间中国最流行的30首歌，还是那样熟悉的旋律。

改革开放30年来，我们的生活发生了巨大的变化。而流行歌曲，则从另一个角度有趣地印证了人民生活和娱乐的轨迹。下面，我们就回顾一下从1979年到2008年这30年间所流行的歌曲。虽然30年的时间看上去很长，但这些流行歌曲仿佛在昨天一样回荡在我们耳畔。

1979年《甜蜜蜜》

从那个时候开始，很多人的家里开始出现邓丽君的大幅海报。人并不怎么漂亮，但温柔婉转，一如她的歌声。很多年之后，陈可辛拍了一部叫做《甜蜜蜜》的电影，当熟悉的音乐再次响起时，有多少人在黑暗中泪流满面……

1980年《光阴的故事》

坊间传说，那一年，一所大学的男生们在毕业的前一夜，把一架钢琴推到了女生宿舍楼下，对着楼里自己曾经爱过或者曾经恨过的女生们，唱了罗大佑的这首歌，所有的女生都躲在窗帘后面，想看又有点不好意思，于是黯然神伤。

1981年《在希望的田野上》

那一年，彭丽媛还不满20岁，但却在青歌赛上把这首歌唱祖国繁荣富强的歌唱得端庄大气。很多年之后，她成了民歌的一种高度。

1982年《我的中国心》

"长江，长城，黄山，黄河，在我心中重千斤。"央视春晚的一首歌不仅让张明敏一夜之间成为全民偶像，更让众多海外游子为此改变了选择，纷纷回归故里。从这个意义上说，因了这首歌，张明敏可以在歌坛"永垂不朽"了。

1983年《血染的风采》

这是一首纪念自卫反击战的歌。原唱者徐良是中国人民解放军一级战斗英雄。在对越自卫还击战期间，他所在班全体战士壮烈牺牲，他孤军作战，出生入死， 腿部重伤。截肢后遂为永久残疾人。在中央电视台的军民联欢晚会上，他着绿色戎装，挂金质奖章，坐特制轮椅，目光坚毅，看上去神采飞扬。站在他身后的，是双 手推着轮椅的温柔美丽的王虹。二人共同高歌一曲《血染的风采》。

1984年《酒干倘卖无》

"酒干倘卖无"的意思是，还有空酒瓶卖么？那一年，台湾出品了其电影史上的扛鼎之作《搭错车》，罗大佑、李寿全等几位日后主宰华语流行乐坛的"大师 级"人物参与创作音乐。作为电影的插曲之一，《酒干倘卖无》被评价为 "讲出了想讲的故事，也用音乐创造出了想创造的画面，最后却也是最重要的一步，就是找到了那个声音，那个唱出心声、唱出感情、唱出故事的声音"。

1985年《万里长城永不倒》

霍元甲！陈真！随着雄壮激越的旋律，霍元甲和陈真迅速成为一代中国人的偶像。很多人为此去学武，还有人为此产生了当一个演员的梦想。

1986年《一无所有》

中国因为这首歌才开始有"摇滚"。写出了这首歌的崔健，成为 "红旗下的蛋"那一代的符号，引领着一代年轻人不断追求"新长征路上的摇滚"。很多年之后，在北京和平里一间廉租房里，一个热血青年跟我说，他想出一本书，就叫做"红旗下的蛋下的蛋"。

1987年《冬天里的一把火》

当年的"白马王子"是什么样的？看看费翔就知道了。就是因为这首歌，费翔成了"阳光"，成了天使"，成了无数少女、少妇的 "梦中情人"。

1988年《大约在冬季》

有这么一种说法：没有听过齐秦歌的人，是可怜的；而听不懂齐秦歌的人，是可悲的。这首歌的流行几乎就是这种说法的标尺。

1989年《爱的奉献》

这首歌最初是为一个患了白血病的孩子而唱响的。后来，每次有灾难来临的时候，这首歌都会再次响起，包括今年的汶川大地震。不过因这首歌而走红的韦唯后来说，如果可以没有灾难的话，她宁愿这首歌一直都不响起。

1990年《亚洲雄风》

刘欢那会儿还没有"亚洲雄风"般的体魄，但是中国确实因此在亚洲一举雄起，冲向世界了。

1991年《好人一生平安》

一个善良的祝福，却有一个悲伤的旋律，难道是因为这个希望其实本来就很绝望？伴随着电视剧《渴望》的热播，这个稍带哀婉祝福的电视剧主题曲，逆流行趋势而红遍全国的城市和乡村。

1992年《我不想说》

"我不想说，我很纯洁。"那一年，红遍中国的"玉女"杨钰莹在歌里这样唱道。这句话也很快就随着这首歌曲成为年轻女孩们的代言。那个时候杨钰莹肯定不会知道，自己后来竟然有一个"不纯洁"的结局。

1993年《涛声依旧》

悠扬、典雅，一首歌红了毛宁。走红之后的毛宁，是非多，但娱乐圈还是涛声依旧。

1994年《纤夫的爱》

这首歌词简单、旋律重复的小调为什么会红遍大江南北？也许唯一的解释就是，如同人们点评《功夫熊猫》时所说，"只有胖子才能拯救世界"。

1995年《弯弯的月亮》

据说当年这首歌写出来后，刚开始时没有一家音乐公司肯接受，没有一个歌手肯演唱，认为旋律与歌词都太"土"。后来，事业正走下坡路的吕方，在把歌词 中的"阿娇摇着船"改成"你我摇着船"的前提下，勉强同意唱这首歌，就此咸鱼翻身。不仅吕方借助它在当时登上一线歌手的位置，这首歌在中国流行歌曲史上具 有越来越重要的位置。

1996年《青藏高原》

老实说，在很长一段时间里，这首歌被我视为那种典型的矫情之作而不怎么待见它。但是让我没有想到的是它竟然能流行如此之久，久到几年之后我都上了大学，竟有一个女孩以这首歌在系里"一战成名"，更没有想到的是，这个女孩后来成了我的孩子她妈。

1997年《心太软》

一首莫名其妙的歌，但据说有三亿中国人都会唱，所以，这首歌莫名其妙地红了一个形容多少有些猥琐的男人。几年之后，这个男人甚至还出演了一回神雕大侠。

1998年《好汉歌》

再见刘欢，"吨位"已经到了足以拯救世界的级别。虽然人的体重跟是不是好汉似乎挂不上什么号，但是想把这首歌唱好，一般体重的人还真唱不出那股子韵味。所以，这些年在舞台上，很少见到有人翻唱《好汉歌》。

1999年《常回家看看》

那一年，甚至是那一年之后的好几年，每次我回老家时，老爸都会唱这首歌给我听。想来，应该有很多很多父母在心里默默地给儿女唱这首歌，一遍又一遍。所以有必要建议大家，去KTV时，把这首歌第一个点了，大家合唱。

2000年《至少还有你》

似乎是最流行的情歌，情侣们无论是热恋之中还是吵架之后，都会哼起。不知道林忆莲唱这首歌的时候，心里有没有想着李宗盛？无论这首歌怎么代表了他们最亲密的岁月，但劳燕纷飞的结局还是让人唏嘘感叹。

2001年《东北人都是活雷锋》

那年一个女性朋友在电话里嘲弄我说，这么红的歌，你竟然都没听说过？然后，她就在电话里唱了给我听。印象中，那应该是我唯一一次听这个朋友唱歌，可见当年这歌流行到了何种程度。

2002年《I believe》

一个苦熬多年的女演员，搭上了"野蛮女友"的顺风车，大红大紫了一把。当然这首歌跟着走红也就再正常不过了。不过让人神伤的是，当年的"野蛮女友"后来居然就一天天的变成了胖子。我想，人世间最悲惨的事情，莫过于美女变胖子这种事了吧。

2003年《东风破》

此前好几年就有人预言说，周杰伦将会成为台湾继罗大佑之后的又一个"现象级"人物。那时候我还不屑一顾呢。但《东风破》这首歌流行之后，世间再无罗大佑，人们似乎就只知道周杰伦了。长江后浪推前浪，前浪死在沙滩上。

2004年《2002年的第一场雪》

这首歌到底流行到什么程度，我们可以在一部大红大紫的电影《疯狂的石头》里面看到，一个卷鬈毛男人蹲在马桶上如此唱道， "2002年的第一泡屎，比以往时候来得更早一些。"哦，如此恶搞，被他打败了。

2005年《老鼠爱大米》

就是这首歌，滥觞出了多少网络歌曲啊。奇怪的是，迄今为止，没有听到过一个人说这首歌好听，鬼知道这首歌到底是怎么 "红"起来的，流行得让人避之唯恐不及。

2006年《千里之外》

因为这首歌，费玉清从故纸堆里又跑到了舞台上。而他那四十五度角抬头举目的唱歌姿势，在很长一段时间里成了众多喜爱K歌的人争相模仿的POSE。

2007年《不怕不怕》

郭美美"昙花一现"。但这首歌在很长一段时间里成了我那个叫小美的女儿的最爱，一天能让你放上十几遍，听得我那段时间里满脑袋都是"蟑螂蟑螂"。可见，流行歌曲从娃娃抓起，还是会继续流行下去的。

2008年《北京欢迎你》

2008年奥运盛会的主人是中国，百年奥运史中的新成员。作为古老又现代的传统文明大国，中国人向世界敞开自己的愿望无比迫切。于是，一句普通的 "北京欢迎你"、一段亲切口语化的歌词加上一个悠扬上口的旋律，组合成一首让亿万人张口就来的流行歌曲。于是，老年版、网络版、国足版，眼花缭乱的版本让 满世界都知道了，北京欢迎你，北京欢迎世界！

如何让你的程序的输入密码的文本框也有大写字母提示

从XP开始，如果Caps Lock打开了，输入密码的文本框会有提示。
但是，你发现没有，你用Visual C++写出来的程序可能并没有这一功能。
事实上，我已经遇到由于大写锁定打开导致输入的密码不是我想要的这个问题了。
于是，我就研究怎么才能在自己的程序中实现这一功能。
过程是挺曲折的，但是方法是挺简单的。
简而言之，在stdafx.h中加入 #pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") 这句话。其次调用 InitCommonControls() 。这样基本就OK了。如果还有问题，请看这里： http://social.msdn.microsoft.com/forums/en-US/vcgeneral/thread/3ec21aae-f397-47c9-a69e-3eb6a5b5cf6b。

在VS2008下，这工作得很好。不过，我有在不同编译环境测试的习惯。很抱歉，在VC6下上述指令是不支持。
网上有人提供了VC6的方法http://www.zhornsoftware.co.uk/a_xp/index.html，可惜，我试了，没有成功。
留待以后慢慢去研究。暂时先用VS2008编译出的程序。

(zz)上学与不上学的区别

转自 http://blog.sina.com.cn/s/blog_48ea108c0100mcv6.html

上学与不上学的区别

 牛刀按语：网友发了这篇文章给我，看了后觉得好笑的同时也感触良多，也许这不仅仅是中国教育的悲哀，也是中国社会的悲哀，是这个光怪陆离的时代的缩影。刊发如此，请各位顾自欣赏，聊博一笑。

张二狗是我的同学。一直以来，我们都是被人拿来作为对比的两个极端，我曾经是他的梦魇，现在他却是我的梦魇。现将我和他的人生历程列出来，再一次深刻感受风水轮流转这一永恒真理。

1、小学入学第一天

我对老师说会背301首唐诗做100以内加减法，口齿清晰条理清楚，老师对我眉开眼笑；

张二狗对老师的提问一问摇头三不知，神情呆滞语无伦次，老师对他暗暗皱眉。

 

2、小学二年级

我考试次次第一，终于在一次满分后肩膀上多了三条杠杠；

张二狗和人打架有赢有输，终于在一次大败后脸上多了三条疤疤。

 

3、小学三年级

期末考试我再次拿到语文数学两门功课双一百，老爸被老师请到家长会上介绍家庭教育经验；

期末考试张二狗再次拿到语文数学两门功课总分三十，老爸被老师请进办公室聆听家庭教育经验。

 

4、小学四年级

领导前来视察我校，我作为少先队代表上台发言，被大家称为主席台上的模范学生。

校长宣布从严治校，张二狗作为闯祸精代表上台检讨，被大家说是站壁角的形象大使。

 

5、小学五年级

我的作文《一个难忘的晚上》在某次大赛中获奖，老师陪我到省城领奖并游玩了一天。

张二狗在一个难忘的晚上爬墙进入某个工厂搬运废铜，门卫陪他到派出所领奖并休养了一天。

 

6、升初中了

听说初中的几个班主任为抢我到自己班上而争得面红耳赤。

听说初中的几个班主任为把张二狗踢到别人班上闹得不可开交。

 

7、初一时

初一时，我爸在酒店设宴庆功，为我在中学生奥数中获奖请别人一起高兴。

初一时，张二狗爸在酒店设宴赔罪，为张二狗闯的祸请别人不要追究

 

8、初二时

初二时，我光荣地加入了学校里的团组织；

初二时，张二狗光荣地加入了学校里的痞子帮。

 

9、初三时

班上的班花给我写情书，情书还没到我手里就被班主任发现没收，班主任警告班花：不得妨碍我考重点高中；

张二狗给班上的胖妞如花递纸条，如花转身把纸条扔进垃圾桶，还告诫张二狗：不要妨碍她混初中文凭。

 

10、初中毕业了

我理所当然地进入了重点高中；

张二狗顺理成章地进入社会深造。

 

11、毕业那天

我们初中的门卫李大爷指着我教育大孙子：一定要像我这样好好学习天天向上，将来才能做个受尊敬的人；

我们初中的门卫李大爷指着张二狗教育大孙子：千万不要像他这样惹是生非门门红灯，将来一定是个受鄙视的人。

 

12、高中三年

我做过班长团支书学生会主席，获得了一个又一个荣誉、拿到了一笔又一笔的奖学金；

社会三年，张二狗做过混混推销员包工头，积累了一条又一条的人脉，攒下了一笔又一笔资金。

 

13、黑色七月

那个黑色七月，我如愿考上省城的大学；

那个火热七月，张二狗如愿在省城注册公司。

 

14、大学与商海

大学里我在学海遨游创业中，

张二狗在商海搏击。

 

15、毕业那年与创业四年

毕业那年，优秀毕业生我进入人才市场找工作，处处碰壁后不得不把薪金要求降低。

创业四年，民营企业家张二狗进入人才市场找员工，广受追捧后不得不把学历门槛提高到硕士起点，很轻松招揽一群高学历高层次的人才，感受了一夜之间从丑小鸭到白天鹅的荣耀

 

16、

我的破永久自行车跑遍全省城，孤身一人凄凄凉凉四处寻找租住的房子；

张二狗的保时捷跑遍全省城，市长区长作陪四处寻找建二狗大厦和工业园区的地块。

 

17、

我手头紧张，也想学张二狗白手起家自主创业，从小商品市场批发了一大堆东东搞兼职做起了推销，几星期内亏了一大笔，暗自感慨：做生意原来这么难

张二狗闲来无事，也想进大学校门学习深造增加内涵，请教授吃饭泡校里的美眉就是没认真上课，几年内拿到了MBA学位，暗自感慨：读书原来这么简单

 

18、

七夕节，别人介绍的恐龙女 朋友嫌弃我没房没车没出息，和我吹灯拔蜡分道扬镳

七夕节，大学里的校花因为张二狗家大业大前程大，向他眉目传情投怀送抱

 

20、

家门口，我哀求俗气的土包子房东缓交房费时唯唯诺诺支支吾吾，净给大学生丢脸

电视上，张二狗对着漂亮的财经频道女主持人大谈企业文化

 

21、

房价飞涨，我忽然发现在省城有一套房子只能是一个梦想，老爹老妈来省城看过我的租住房，回家后伤心不已

房价飞涨，张二狗把一套又一套的房子赠给各类美女，一小美女的老爹老妈来省城看过二狗赠的复式景观房，回家后得意不已

 

22、

春节我回家，没人理睬，我当年就读的初中，听说里面在办校庆，想去看看却被拒之门外，门卫李大爷指着我教育小孙子：不要学习这个人，读了这么多年书还是一穷二白，连自己都养不活。

春节张二狗回家，县长接驾，还参加当年就读的初中特意举办的校庆，张董在校庆上砸下巨额赞助，门卫李大爷指着张董教育小孙子：你要像主席台上的这个人学习，白手起家富甲一方，连亲戚都沾光。

 

23、

十几年前，老师感叹，要是所有学生都像我一样该有多好.

十几年后，老师感叹，要是所有学生都像张二狗一样该有多好

这就是中国教育的悲哀

 

(zz)火场逃生十法

来源：http://songshuhui.net/archives/45680.html

《少年科学》授权转载

迅速撤离法

迅速撤离法：当进入公共场所时，要留意其墙上、顶棚上、门上、转弯处设置的"太平门"、"紧急出口"、"安全通道"等疏散指示标志，一旦发生火灾，按疏散指示标志方向迅速撤离。

低身前进法

低身前进法：由于火灾发生时烟气大多聚集在上部空间，因此在逃生过程中应尽量将身体贴近地面匍匐或弯腰前进。

毛巾捂鼻法

毛巾捂鼻法：火场上的烟气温度高、毒性大，吸入后很容易引起呼吸系统灼伤或人体中毒。疏散中应用浸湿的毛巾、口罩等捂住口鼻，以起到降温及过滤的作用。

厚物护身法

厚物护身法：确定逃生路线后，可用浸湿的棉被或毛毯、棉大衣盖在身上，以最快的速度钻过火场并冲到安全区域。不能用塑料或化纤等类物品来保护身体，否则会适得其反。

跳板转移法

跳板转移法：可以在阳台上、窗台、屋顶平台等处用木板、木桩、竹竿等有承受力的物体，搭至相邻单元或相邻建筑，以此作为跳板转移到相对安全的区域。

管线下滑法

管线下滑法：当建筑物外墙或阳台边上有落水管、电线杆、避雷针引线等竖直管线时，可借助其下滑至地面，同时应注意一次下滑时人数不宜过多，以防止逃生途中因管线损坏而致人坠落。

结绳自救法

结绳自救法：家中有绳索的（或将床单、被罩、窗帘等撕成条，拧成麻花状），可直接将其一端拴在门、窗档或重物上，沿另一端爬下。逃生过程中，脚要成绞状夹紧绳子，双手交替往下爬，并尽量用手套、毛巾将手保护好。

器械逃生法

器械逃生法：有条件的家庭可以利用平时准备的家用缓降器等专用救生设备逃生。

信号求救法

信号求救法：在等待救援的过程中，应通过大声呼救、挥动布条、敲击金属物品、投掷软 物 品 等 方 式 引起救援人员的注意；夜间可用手电筒、应急灯等能发光的物品发出信号。

空间避难法

空间避难法：在暂时无法向外疏散时，可选择卫生间、厨房等空间小且有水源和新鲜空气的地方暂时避难。将毛巾等棉织物塞进门缝阻挡烟气，在地面上泼水降温，等待救援。在消防队员到来后，可通过搭乘消防云梯、救生直升机或利用救生气垫逃生。

读后感

前几天读了本书，对其中一些文章有些心得，做些简单记录。

1. 王安忆《上海与北京》
我不想参与口水战。很多事情不是用好坏就可以简单区分的，更谈不上谁对谁错了。
记得多年以前听到一个关于清华和北大的说法，说现在社会越来越喜欢清华这样的风格而不喜欢北大的风格。
我想说的是：整个社会也越来越喜欢上海这样的风格。北京也在变化。

2. 林希《泪的重量》
我见过牛的泪。
很小的时候，我们那主要靠牛来犁地耕田。每个队一头牛，专人负责。
爷爷负责我们队里的牛，驾牛帮别人耕田。
爸爸经常帮着照料牛。到现在我都记得爸爸每天都牵牛去河边饮水，我则喜欢跟着爸爸后面。也还记得夜里爸爸带我一起去给牛"端尿"――防止牛把地上的草弄湿，那样就会很冷。
我们家那头牛一直非常健壮，也始终很干净，身上的毛非常有光泽。
那头牛很通人性，它认识家里的每个人。
那是我很小，个子矮，如果没有大人在边上我就没有办法骑到牛背上。但是，如果我想骑上牛背，我只需轻轻拍拍它，它就会很乖巧的跪在地上，让我爬上去，然后它再站起来，继续做它的事，吃草或者散步。
后来，农业机械化了，拖拉机普及了，牛的作用越来越小。
终于，有一天，队里决定把牛卖了。我们全家都很不舍得，可是没有办法，那是队里的牛。
有天早上，从外地来了几个人，看过牛。
牛就再也不吃不喝了。也许是它闻到了那些人身上的味道，也许是它从我们眼里发现了异样。那一刻起，牛的两只眼睛里一直含着泪水。
中午放学回家，听说全队的人都集中到一户人家的院子里去了。原来，那头牛被那些人杀掉了。因为杀牛是不简单的，作为酬劳，似乎部分牛肉和牛皮什么的给那些人，而另一部分牛肉则煮好分给全村的人吃。
我记得，那天我没有吃一口牛肉、喝一口汤。
我记得，后来那户人家我几乎再也不去了。虽然不是他们家干的，但我总觉得跟他们有关系。

3. 那本书读完后已经还了，有些文章一下子想不起来。这也是年纪大了的一个表现。
不管怎样，我还是有个感觉很强烈：经典文章，用词造句都非常用心，意境非常优美。
而现在的作品大都已做不到。这与这个崇尚物质、浮躁功利、以成败论英雄的时代，倒是吻合的。
就如同一个是方便快餐，调料丰富，当时吃了非常可口但饭后却感到口干舌燥，营养一般，因此不能经常吃，否则一定会出毛病；而另一个就是粗茶淡饭，貌似无味，实则健康营养。
又如同一个是塑料饰品，不论外面镀上何种东西，终究会掉色，没有价值；而另一个是水晶黄金，不论造型如何，不论时光如何流逝，一样让人愿意珍藏。

(zz)24点算法

搜索了一通，认为有三个程序比较好，转贴在此。欲了解算法原理，请至原出处查看。
版权和使用规则请查看出处，有事请联系原作者。

程序1和2出处：http://www.ieee.org.cn/dispbbs.asp?boardID=60&ID=15720
程序3出处：http://www.joansky.com/95.html

程序1：

#include <iostream>
#include <string>
#include <cmath>

using namespace std;

const double PRECISION = 1E-6;
const int COUNT_OF_NUMBER  = 4;
const int NUMBER_TO_CAL = 24;

double number[COUNT_OF_NUMBER];
string expression[COUNT_OF_NUMBER];

bool Search(int n)
{
    if (n == 1) {
        if ( fabs(number[0] - NUMBER_TO_CAL) < PRECISION ) {
            cout << expression[0] << endl;
            return true;
        } else {
            return false;
        }
    }

    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            double a, b;
            string expa, expb;

            a = number[i];
            b = number[j];
            number[j] = number[n - 1];

            expa = expression[i];
            expb = expression[j];
            expression[j] = expression[n - 1];

            expression[i] = '(' + expa + '+' + expb + ')';
            number[i] = a + b;
            if ( Search(n - 1) ) return true;
            
            expression[i] = '(' + expa + '-' + expb + ')';
            number[i] = a - b;
            if ( Search(n - 1) ) return true;
            
            expression[i] = '(' + expb + '-' + expa + ')';
            number[i] = b - a;
            if ( Search(n - 1) ) return true;
                        

            expression[i] = '(' + expa + '*' + expb + ')';
            number[i] = a * b;
            if ( Search(n - 1) ) return true;

            if (b != 0) {
                expression[i] = '(' + expa + '/' + expb + ')';
                number[i] = a / b;
                if ( Search(n - 1) ) return true;
            }
            if (a != 0) {
                expression[i] = '(' + expb + '/' + expa + ')';
                number[i] = b / a;
                if ( Search(n - 1) ) return true;
            }

            number[i] = a;
            number[j] = b;
            expression[i] = expa;
            expression[j] = expb;
        }
    }
    return false;
}

void main()
{
    for (int i = 0; i < COUNT_OF_NUMBER; i++) {
        char buffer[20];
        int  x;
        cin >> x;
        number[i] = x;
        itoa(x, buffer, 10);
        expression[i] = buffer;
    }

    if ( Search(COUNT_OF_NUMBER) ) {
        cout << "Success." << endl;
    } else {
        cout << "Fail." << endl;
    }        
}

程序2：计算任意值，求出最接近值

#include <fstream>
#include <algorithm>
#include <string>
#include <sstream>
#include <list>
#include <cmath>
#include <climits>
#include <bitset>
using namespace std;

const char* INPUT_FILE  = "game.in";
const char* OUTPUT_FILE = "game.out";
const int NUMBER_COUNT  = 6;
const int STATE_COUNT   = (1 << NUMBER_COUNT);
const int MAX_NUMBER    = 100;
const int MAX_EXPECTION = 1000;
const int MAX_VALUE             = MAX_EXPECTION * MAX_NUMBER;

struct Node {
        int value;
        int left, right;        
        int leftvalue, rightvalue;
        char opr;
};

typedef list<Node> NodeList;

struct State {
        bitset<MAX_VALUE+10> exist;
        NodeList nodelist;
};

int number[NUMBER_COUNT], expection;
State state[STATE_COUNT];

void ReadData()
{
        ifstream fin(INPUT_FILE);
        
        for (int i = 0; i < NUMBER_COUNT; i++) {
                fin >> number[i];
        }
        fin >> expection;
}

void Init()
{
        Node node ;
        for (int i = 0; i < NUMBER_COUNT; i++) {
                node.value              = number[i];
                node.left = node.right = -1;
                state[(1 << i)].nodelist.push_back(node);
                state[(1 << i)].exist[node.value] = true;
        }
}

void Merge(int a, int b, int x)
{       
        Node node;      
        NodeList::const_iterator i, j;

        for (i = state[a].nodelist.begin(); i != state[a].nodelist.end();
i++) {
                for (j = state[b].nodelist.begin(); j != state[b].nodelist.en

d(); j++)
{                                      
                        node.value = (*i).value + (*j).value;
                        node.left  = a;
                        node.right = b;                 
                        node.leftvalue  = (*i).value;
                        node.rightvalue = (*j).value;
                        node.opr   = '+';
                        if ( (node.value <= MAX_VALUE) && (!state[x].exist[node.value]) ) {
                                state[x].nodelist.push_back(node);
                                state[x].exist[node.value] = true;
                        }

                        /////////////////////////////////////////////////////

                        double tmp = double((*i).value) * double((*j).value);

                        if (tmp < INT_MAX) {
                                node.value = (*i).value * (*j).value;
                                node.left  = a;
                                node.right = b;
                                node.leftvalue  = (*i).value;
                                node.rightvalue = (*j).value;
                                node.opr   = '*';
                                if ( (node.value <= MAX_VALUE) && (!state[x].exist[node.value]) )
{
                                        state[x].nodelist.push_back(node);
                                        state[x].exist[node.value] = true;
                                }
                        }

                        /////////////////////////////////////////////////////

                        if ((*i).value >= (*j).value) {
                                node.value = (*i).value - (*j).value;
                                node.left  = a;
                                node.right = b;
                                node.leftvalue  = (*i).value;
                                node.rightvalue = (*j).value;
                                node.opr   = '-';
                        } else {
                                node.value = (*j).value - (*i).value;
                                node.left  = b;
                                node.right = a;
                                node.leftvalue  = (*j).value;
                                node.rightvalue = (*i).value;
                                node.opr   = '-';
                        }
                                                
                        if ( (node.value <= MAX_VALUE) && (!state[x].exist[node.value]) ) {
                                state[x].nodelist.push_back(node);
                                state[x].exist[node.value] = true;
                        }

                        /////////////////////////////////////////////////////

                        if ( ((*j).value != 0) && ((*i).value >= (*j).value) &&
                                        ((*i).value % (*j).value == 0) )
                        {
                                node.value = (*i).value / (*j).value;
                                node.left  = a;
                                node.right = b;         
                                node.leftvalue  = (*i).value;
                                node.rightvalue = (*j).value;
                                node.opr   = '/';
                        } else if ( ((*i).value != 0) && ((*j).value >= (*i).value) &&
                                        ((*j).value % (*i).value == 0) )
                        {
                                node.value = (*j).value / (*i).value;
                                node.left  = b;
                                node.right = a;
                                node.leftvalue  = (*j).value;
                                node.rightvalue = (*i).value;
                                node.opr   = '/';
                        }
                                                
                        if ( (node.value <= MAX_VALUE) && (!state[x].exist[node.value]) )
{                               
                                state[x].nodelist.push_back(node);
                                state[x].exist[node.value] = true;
                        }                       
                        /////////////////////////////////////////////////////

                }
        }
}

void Solve()
{
        Init();
        
        for (int x = 2; x < STATE_COUNT; x++) {
                for (int i = 1; i < x; i++) {                   
                        if ( (x & i) == i ) {
                                int j = x - i;
                                if (i <= j) {
                                        Merge(i, j, x);         
                                }
                        }
                }
        }
}

void PrintExpression(ostream& out, Node node)
{
        if (node.left == -1) {
                out << node.value;
        } else {
                NodeList::const_iterator iter;
                
                out << "(";

                for (iter = state[node.left].nodelist.begin();
                                iter != state[node.left].nodelist.end();
                                iter++)
                {
                        if ((*iter).value == node.leftvalue) {
                                PrintExpression(out, *iter);
                                break;
                        }
                }

                out << node.opr;

                for (iter = state[node.right].nodelist.begin();
                                iter != state[node.right].nodelist.end();
                                iter++)
                {
                        if ((*iter).value == node.rightvalue) {
                                PrintExpression(out, *iter);
                                break;
                        }
                }

                out << ")";
        }               
}

void Output()
{
        ofstream fout(OUTPUT_FILE);

        int bestValue = -INT_MAX;       
        NodeList::const_iterator iter, bestIter;

        NodeList& nodelist = state[STATE_COUNT-1].nodelist;

        for (iter = nodelist.begin(); iter != nodelist.end(); iter++)
        {       
                if ( ((*iter).value <= expection) && (bestValue < (*iter).value) ) {
                        bestValue = (*iter).value;
                        bestIter  = iter;
                }
        }       
        fout << bestValue << endl;
        PrintExpression(fout, *bestIter );
        fout << endl;
}

int main()
{
        ReadData();
        Solve();
        Output();
        return 0;
}

程序3：列出所有结果

#include<stdio.h>
 
int x[100];
 //保存四个数的所有组合 
int arrange[100][100];
 //保存读入的四个数 
int num[100];
 //标记该数是否被访问过 
int a[100] = {0};
  
char sym[5]={'0','+','-','*','/'};
 //保存使用的算术运算符 
int bol[100];
 // 标记运算符是否被访问过 
int b[100]={0};
  
//保存四个数的组合总数 
int sum = 0;
 int n,r;
int ok=1;
  
//保存所有可能的组合数 
void save(int sum)
 {
    int i;
    for(i=0;i<4;++i)
     {
        arrange[sum][i] = x[i];
  
    }
}
 
 
//判断使用该运算符是否合法 
int symbollegal(int t,int i,int sum,int layer)
 {
    switch(i)
    {
     case 1:
        if(arrange[layer][t]+sum>24)
             return 0;
        else return arrange[layer][t]+sum;
     case 2:
        if(sum-arrange[layer][t]<0)
             return 0;
        else return sum-arrange[layer][t];
     case 3:
        if(arrange[layer][t]*sum>24)
             return 0;
        else return arrange[layer][t]*sum;
     case 4:
        if(arrange[layer][t]!=0&&sum%arrange[layer][t]!=0)
             return 0;
        else return sum/arrange[layer][t];
  
    }
}
// 打印结果 
void pri(int layer)
 {
    int i,temp;
    int totle = arrange[layer][0];
     for(i= 1;i<=3;++i)
     {
        if(totle > arrange[layer][i])
         {
            temp = symbollegal(i,bol[i],totle,layer);
             printf("%d %c %d = %d\n",totle,sym[bol[i]],arrange[layer][i],temp);
         }
        else
        {
            temp = symbollegal(i,bol[i],totle,layer);
             printf("%d %c %d = %d\n",arrange[layer][i],sym[bol[i]],totle,temp);
         }
        totle = temp;
 
    }
     printf("\n");
 }
 
//回溯计算四个组合数出现的情况 
void backtrack(int t)
 {
    int i;
    //遍历四个数 
    for(i = 1;i<= 4;++i)
     {
        x[t] = num[i];
         //如果当前这个数没有被选择  
        if(a[i]==0)
         {
            //标记该数已经选择 
            a[i] = 1;
             //结束条件：已经找到符合条件的四个数 
            if(t == 3 )
             {
                save(sum);
                 ++sum;
 
            }
            else
             {
                backtrack(t+1);     
             }
            //不符合条件，恢复该数的访问权限 
            a[i] = 0;
         }
    }
}
 
// 计算该组合数能得出24的情况 
 void find(int sum,int t,int layer)
 {
    int i,temp,sign;
    //遍历加、减、乘、除四个符合 
     for(i=1;i<=4;++i)
     {
        bol[t] = i;
         //如果选择的符号满足条件 
        if( (temp = symbollegal(t,i,sum,layer)))
         {
            //标记该符号已经选择并修改sum值 
            b[i] = 1;
             sign = sum;
            sum = temp;
             //结束条件：四个数都已经完成运算 
            if(t == 3)
             {
                //结果是24点，则打印 
                if(sum==24)
                 {
                    ok=0;
                     pri(layer);
                }
             }
            else
            {
                find(sum,t+1,layer);
             }
            //不符合条件，恢复该符号的访问权限与sum的值 
            b[i] = 0;
             sum = sign;
        }
    }
 }
int main()
{
     int i,j;
    for(i=1;i<=4;++i)
         scanf("%d",&num[i]);
     backtrack(0);
    // 遍历所有的组合数 
     for(i=0;i<sum;++i)
     {
        find(arrange[i][0],1,i);
     }
    if(ok)
    {
         printf("No answer!\n");
     }
    system("pause");
     return 0;
}

鄙视一下新蛋

之前对新蛋印象一直很好：每次发货时都包装得格外认真，还会在原包装外再加个纸箱。
今天可是我有点郁闷，感觉新蛋的所作所为好像突然换了个人。
情况是这样：买了款手机，提交订单无法成功。昨天太晚就算了，刚才打客服电话一问，是因为配送方式选了免费的圆通。
客服说，因为是手机，有电池，最近航空管制，所以要选择付费的宅急送。
首先，这管制也还看人？
其次，为什么就偏偏免费配送的都管制呢？
第三，从上海仓发货到杭州，需要航空吗？对此，客服的答复说：我们不知道圆通从上海到杭州会不会走航空。
我想，要么就是圆通太牛了，到处飞来飞去；要么，新蛋免运费的幌子也太不靠谱了。

删除目录名变成问号(或者含有问号)的目录

上次因为用PQ转换时，把中文目录变成了乱码。
后来通过Windows的CHKDSK修复，结果变成了一堆问号。
这些目录有问号的目录，无法删除，不论是在Ubuntu还是DOS下，试了很多工具。

今天试了一个Runtime DiskExplorer，没有搞定。
后来使用WinHex。注意：操作之前把要删除目录同级目录下其他目录和文件转移到其他地方。
网上有人提供了WinHex删除目录的方法，前面几步可以做下来：
2.2   启动   WinHex，选择“工具”-> “打开磁盘”选择你要修改的磁盘（就是要删除文件的磁盘）。
2.3   WinHex   会扫描磁盘的扇区，并且模仿资源管理器的样子提供文件夹列表（上面）和磁盘数据编辑窗口（下面）。找到你要删除的文件夹或文件。
2.4   右击该文件夹，选择“位置”-> “转到   目录开始”
2.5   点击下面的数据区，选择第一个字节，右击“选块开始”；
2.6   向下滚动，注意左边的“簇编号”下显示的文件夹名称，一直滚动直到名称刚好改变为别的文件夹开始，则上一行的末端，右击，选择“选块结束”；
2.7   右击，“编辑”“填充数据”直接确认，忽略一切警告直接继续。
此后的步骤就不一样了。
这样，目录变成了文件，仍然没有删除。
后来，通过右击该文件夹，选择“位置”-> “转到   目录项”，把那几个字节修改成00。（说明：实际上，以上步骤不进行，只做这一步就可以了。）
退出WinHex。然后运行CHKDSK会把目录表截断（该目录项之后的目录和文件将不再看到，这也是为什么要把其他目录和文件提前转移的原因），这些问号目录就全部删除了。

Vista/Windows 7中文版：内存 硬错误/秒

Vista/Windows 7中文版 任务管理器 的 资源监视器 上华丽的写着 内存 硬错误/秒。
本来内存的硬错误软错误通常是指内存物理故障造成数据出错(软错误一般只受外部影响临时出错)，可是Vista/Windows 7中文版的硬错误实际上是指hard fault/page fault。
这个翻译得也忒寒碜了吧。

高速公路命名(纯属八卦)

从杭州南京之间的高速开始说起。在浙江境内，称为"杭宁高速"，在江苏境内，称为"宁杭高速"。
也就是说，两个省会城市之间，谁也不理谁，都把自己放前面。
当然，省内高速，一定是省会城市放在前面的，比如"杭金衢高速"。

但是，省会城市碰上直辖市，那么，直辖市就牛了。比如，杭州上海之间的高速，不论在浙江还是上海境内，都叫"沪杭高速"而没有"杭沪高速"这一说。高铁也体现了这一特点。

不过，最牛当然还是京城了。不论与哪里连接的高速，一定都是京在前面的。

也许名字颠来倒去的太费神，弄不好还伤害了兄弟城市的友情，所以国家干脆统一去除名字而以编号代替。这样一条公路就只有一个叫法了。（随着时代变化，孩子的姓有时也成为父母争取的一个项目。要是借鉴高速公路的命名方法以后把人的名字也数字化，那么这一问题同样迎刃而解。）