2、把根目录下的php5ts.dll复制到系统windows目录下；把php.ini-dist文件改名为php.ini后复制到系统windows目录下。

3、用文本编辑器打开php.ini文件，查找“register_globals”，把后面的Off改为On。该项设置是关于自定义全局变量。

4、查找“extension_dir”，把后面的值改为php解压文件夹的ext子目录下，如“C:\php5\ext”

5、查找“extension”，把需要用到的扩展模块前的；号去掉。如需要用mysql的就是php_mysql.dll，如需要用mysqli的话，就需要自己加一句extension=php_mysqli.dll。有些扩展库可能需要额外的 DLL 才能工作，具体请查看这里，如果列表里的注解中有说明，则需要在解压根目录或者ext子目录找到该文件，然后复制到系统windows目录中。
如php_mysql.dll和php_mysqli.dll就需要把根目录下的libmysql.dll复制到系统windows目录中

6、打开IIS，找到需要使用php的站点，点右键-属性，找到“主目录”选项卡，点击“配置”按钮，在“映射”选项卡中，点“添加”按钮，通过“浏览”，找到php解压目录下的php5isapi.dll文件，确定，“扩展名”填“.php”，其他选项默认即可。

7、找到IIS的web服务扩展，点击“添加一个新的web服务扩展”，扩展名可以为“php”，添加文件同样为php5isapi.dll，并把“设置扩展状态为允许”勾选。

8、在开始-运行里输入iisreset，确定，重启IIS。至此，在IIS6上安装PHP5已经完成。

常见问题：
1、如出现一些“failed to open stream”等提示，一般是因为权限问题，我的解决方法是给everyone对php的解压目录的读取和运行权限，给iis两个用户对网站的web目录读取和运行权限。相关参考文章：[小勤]WIN主机配置PHP的若干问题解决方案总结

PS：关于php.ini里的选项设置，可以查看这里。

在Windows上安装MySQL5(以5.0.24a为例)
在mysql.com上下载windows的安装文件，然后运行，根据提示一步步next，基本上不需要做任何调整。安装完成后会自动打开配置程序，根据需要做一些调整。至最后一步，配置程序可能会提示无法连接数据服务器，这时候，需要点击重试按钮，否则可能会发生程序无法连接服务器的情况。

如果出现如上所述情况，需通过mysql自身的卸载程序卸载mysql，并把安装目录和数据目录清空，重启，然后再安装。否则将会重复之前的问题。我第一次就是在这里卡了好久一段时间。

在IIS6上安装Perl5(以5.8.8.819为例)
1、在ActiveState上下载ActivePerl，运行，根据提示完成安装。

2、打开IIS，找到需要使用perl的站点，点右键-属性，找到“主目录”选项卡，点击“配置”按钮，在“映射”选项卡中，点“添加”按钮，通过“浏览”，找到perl安装目录的bin子目录，把查找文件类型设为CGI（*.exe文件），选择perl.exe文件，确定，“扩展名”填“.pl”，其他选项默认即可。

3、找到IIS的web服务扩展，把“Perl CGI Extension”设为允许状态。

4、对perl的安装目录，给予iis的两个帐户以读取和运行、修改、写入的权限。

在IIS6上安装DevMS的IIS-Tools(以1.1.0.0为例)
1、在DevMS.Com上下载压缩包，解压。

2、打开IIS，找到需要使用IIS-Tools的站点，点右键-属性，找到“ISAPI筛选器”选项卡，点击“添加”按钮，筛选器名称可以为“devms”，浏览文件，找到解压包里的Devms.Com.IISTools.dll文件。确定添加。

3、找到IIS的web服务扩展，点击“添加一个新的web服务扩展”，扩展名可以为“devms”，添加文件同样为Devms.Com.IISTools.dll，并把“设置扩展状态为允许”勾选。

4、对网站的web目录，给予SERVICE帐户的完全权限。

5、重启IIS即可。

想想警察和城管之类的也就都跟这交警一个样，治安由这种人来管理还有什么指望啊！

现跟大家分享下！

http://share.daviesliu.net/

美国《Techweb》网站日前评出了20年来，破坏力最大的10种计算机病毒：

1. CIH (1998年)

该计算机病毒属于W32家族，感染Windows 95/98中以EXE为后缀的可行性文件。它具有极大的破坏性，可以重写BIOS使之无用(只要计算机的微处理器是Pentium Intel 430TX)，其后果是使用户的计算机无法启动，唯一的解决方法是替换系统原有的芯片（chip），该计算机病毒于4月26日发作，它还会破坏计算机硬盘中的所以信息。该计算机病毒不会影响MS/DOS、Windows 3.x和Windows NT操作系统。

CIH可利用所有可能的途径进行传播：软盘、CD-ROM、Internet、FTP下载、电子邮件等。被公认为是有史以来最危险、破坏力最强的计算机病毒之一。1998年6月爆发于中国台湾，在全球范围内造成了2000万-8000万美元的损失。

2.梅利莎（Melissa,1999年）

这个病毒专门针对微软的电子邮件服务器和电子邮件收发软件，它隐藏在一个Word97格式的文件里，以附件的方式通过电子邮件传播，善于侵袭装有Word97或Word2000的计算机。它可以攻击Word97的注册器并修改其预防宏病毒的安全设置，使它感染的文件所具有的宏病毒预警功能丧失作用。

在发现Melissa病毒后短短的数小时内，该病毒即通过因特网在全球传染数百万台计算机和数万台服务器， 因特网在许多地方瘫痪。1999年3月26日爆发，感染了15%-20%的商业PC，给全球带来了3亿-6亿美元的损失。

3. I love you (2000年)

2000年5月3日爆发于中国香港，是一个用VBScript编写，可通过E-Mail散布的病毒，而受感染的电脑平台以Win95/98/2000为主。给全球带来100亿-150亿美元的损失。

4. 红色代码 (Code Red，2001年)

该病毒能够迅速传播，并造成大范围的访问速度下降甚至阻断。这种病毒一般首先攻击计算机网络的服务器，遭到攻击的服务器会按照病毒的指令向政府网站发送大量数据，最终导致网站瘫痪。其造成的破坏主要是涂改网页，有迹象表明，这种蠕虫有修改文件的能力。2001年7月13日爆发，给全球带来26亿美元损失。

5. SQL Slammer (2003年)

该病毒利用SQL SERVER 2000的解析端口1434的缓冲区溢出漏洞对其服务进行攻击。2003年1月25日爆发，全球共有50万台服务器被攻击，但造成但经济损失较小。

6. 冲击波（Blaster，2003年)

该病毒运行时会不停地利用IP扫描技术寻找网络上系统为Win2K或XP的计算机，找到后就利用DCOM RPC缓冲区漏洞攻击该系统，一旦攻击成功，病毒体将会被传送到对方计算机中进行感染，使系统操作异常、不停重启、甚至导致系统崩溃。另外，该病毒还会对微软的一个升级网站进行拒绝服务攻击，导致该网站堵塞，使用户无法通过该网站升级系统。2003年夏爆发，数十万台计算机被感染，给全球造成20亿-100亿美元损失。

7. 大无极.F（Sobig.F，2003年)

Sobig.f是一个利用互联网进行传播的病毒，当其程序被执行时，它会将自己以电子邮件的形式发给它从被感染电脑中找到的所有邮件地址。在被执行后，Sobig.f病毒将自己以附件的方式通过电子邮件发给它从被感染电脑中找到的所有邮件地址，它使用自身的SMTP引擎来设置所发出的信息。此蠕虫病毒在被感染系统中的目录为C：\WINNT\WINPPR32.EXE。2003年8月19日爆发，为此前Sobig变种，给全球带来50亿-100亿美元损失。

8. 贝革热（Bagle，2004年)

该病毒通过电子邮件进行传播，运行后，在系统目录下生成自身的拷贝，修改注册表键值。病毒同时具有后门能力。2004年1月18日爆发，给全球带来数千万美元损失。

9. MyDoom (2004年)

MyDoom是一种通过电子邮件附件和P2P网络Kazaa传播的病毒,当用户打开并运行附件内的病毒程序后，病毒就会以用户信箱内的电子邮件地址为目标，伪造邮件的源地址，向外发送大量带有病毒附件的电子邮件，同时在用户主机上留下可以上载并执行任意代码的后门（TCP 3127到3198范围内）。2004年1月26日爆发，在高峰时期，导致网络加载时间慢50%以上。

10. Sasser (2004年)

该病毒是一个利用微软操作系统的Lsass缓冲区溢出漏洞（ MS04-011漏洞信息）进行传播的蠕虫。由于该蠕虫在传播过程中会发起大量的扫描，因此对个人用户使用和网络运行都会造成很大的冲击。2004年4月30日爆发，给全球带来数千万美元损失。

(转)

　　现在的孩子放学回家后，他们的一切活动都由成年人在安排。不论干什么，都有成年人在旁边监督。事实上，孩子们从同龄人那里学会了更多的东西，那是他们成长的一部分，是青少年时期的一部分。他们急于和同龄人交流，并通过互联网得到满足。这听起来并不新鲜，但新鲜的是交流场所的变化。对于需要和同龄人交流这种愿望，只有互联网可以满足。不允许出去玩的时候，谁愿意整天和父母呆在一起呢？有了互联网，他们就可以一周7天，一天24小时地和同龄朋友在一起，这实在太棒了。

　　萨尔诺：所以工作之后，他们就对那些试图阻止他们接触互联网的公司管理人员有抵触情绪？

　　基亚：那些阻止他们接触互联网的人有两种可能：一种是接受上级的命令，虽然同情员工的处境，但仍然不得不阻止员工接触互联网；另一种则属于较老的一代，还用他们自己的评估标准来思考生产力。

　　我觉得关键在于正在发生的文化变革。其实这并不是彻底的变化，当我们朝九晚五地上班的时候，同样会在工作场所给医生打电话，因为下班后医院就关门了；有时我们也会给杂货店打电话询问有没有我们需要的东西，或者偶尔给朋友打电话闲聊几句。问题是，这种现象现在越来越普遍。

　　我来举一个发生在欧洲的例子。我记得好像是在英国，一名员工因为在网上浏览报纸而被开除，因为这被认为是错误行为。法官当时支持了这名员工，他说，“在网上看报纸和原来我们在休息间隙看5分钟报纸有什么区别？和我们抽空打了个电话又有什么区别？”由此看出，他也不知道区别在哪里。生产力的衡量标准应当是你生产了什么，而不是你如何利用时间。

　　事实上，我们已经过了朝九晚五的时期，现在的工作方式是，“给我一个期限，我好决定什么时候做它。”这一切都因为世界变化太快，现代社会瞬息万变，对每件事人们都有自己不同的选择。

　　萨尔诺：那IT部门该如何应对这些网络用户呢？

　　基亚：IT部门应当提倡那种使用互联网工作的方式。如果阻止他们接触互联网，它们肯定会找到其它办法，这一点在IT领域尤其明显。事实上，每个人都有自己的备选方案。例如，如果公司不让使用即时信息服务，他们就用电子邮件来交流。我在德国的一家公司曾见到这样的场景：整个公司都在“叮叮叮叮”的响，因为公司不让使用即时信息服务，员工都用电子邮件来交流。如果公司不允许上班时间上网，员工下班回家后会上网查找需要的东西，并上传到办公PC上，他们的工作方式与在办公室上网并没有什么不同。员工们有太多应对措施，所以一味地阻止没有太大意义。

　　萨尔诺：你的研究和想法是否已经体现到微软产品上？

　　基亚：Windows Live就是一个最好的例子，我们希望为用户提供无缝的网络体验。在下一代操作系统Windows Vista中，我们也加入了很多新功能，例如父母控制(parental controls)，我们希望通过控制机制来建立家庭安全区域。(奥托)

　　六年前，我刚热恋“面向对象”（Object-Oriented）时，一口气记住了近十个定义。六年后，我从几十万行程序中滚爬出来准备写点心得体会时，却无法解释什么是“面向对象”，就象说不清楚什么是数学那样。软件工程中的时髦术语“面向对象分析”和“面向对象设计”，通常是针对“需求分析”和“系统设计”环节的。“面向对象”有几大学派，就象如来佛、上帝和真主用各自的方式定义了这个世界，并留下一堆经书来解释这个世界。

　　有些学者建议这样找“对象”：分析一个句子的语法，找出名词和动词，名词就是对象，动词则是对象的方法（即函数）。

　　当年国民党的文人为了对抗毛泽东的《沁园春雪》，特意请清朝遗老们写了一些对仗工整的诗，请蒋介石过目。老蒋看了气得大骂：“娘希匹，全都有一股棺材里腐尸的气味。”我看了几千页的软件工程资料，终于发现自己有些“弱智”，无法理解“面向对象”的理论，同时醒悟到“编程是硬道理。”

　　面向对象程序设计语言很多，如Smalltalk、Ada、Eiffel、Object Pascal、Visual Basic、C++等等。C++语言最讨人喜欢，因为它兼容C 语言，并且具备C 语言的性能。近几年，一种叫Java 的纯面向对象语言红极一时，不少人叫喊着要用Java 革C++的命。我认为Java 好比是C++的外甥，虽然不是直接遗传的，但也几分象样。外甥在舅舅身上玩耍时洒了一泡尿，俩人不该为此而争吵。

　　关于C++程序设计的书藉非常多，本章不讲C++的语法，只讲一些小小的编程道理。如果我能早几年明白这些小道理，就可以大大改善数十万行程序的质量了。

1. C++面向对象程序设计的重要概念

　　早期革命影片里有这样一个角色，他说：“我是党代表，我代表党，我就是党。”后来他给同志们带来了灾难。

　　会用C++的程序员一定懂得面向对象程序设计吗？

　　不会用C++的程序员一定不懂得面向对象程序设计吗？

　　两者都未必。就象坏蛋入党后未必能成为好人，好人不入党未必变成坏蛋那样。

　　我不怕触犯众怒地说句大话：“C++没有高手，C 语言才有高手。”在用C 和C++编程8年之后，我深深地遗憾自己不是C 语言的高手，更遗憾没有人点拨我如何进行面向对象程序设计。我和很多C++程序员一样，在享用到C++语法的好处时便以为自己已经明白了面向对象程序设计。就象挤掉牙膏卖牙膏皮那样，真是暴殄天物呀。

　　人们不懂拼音也会讲普通话，如果懂得拼音则会把普通话讲得更好。不懂面向对象程序设计也可以用C++编程，如果懂得面向对象程序设计则会把C++程序编得更好。本节讲述三个非常基础的概念：“类与对象”、“继承与组合”、“虚函数与多态”。理解这些概念，有助于提高程序的质量，特别是提高“可复用性”与“可扩充性”。

1.1 类与对象

　　对象（Object）是类（Class）的一个实例（Instance）。如果将对象比作房子，那么类就是房子的设计图纸。所以面向对象程序设计的重点是类的设计，而不是对象的设计。类可以将数据和函数封装在一起，其中函数表示了类的行为（或称服务）。类提供关键字public、protected 和private 用于声明哪些数据和函数是公有的、受保护的或者是私有的。

　　这样可以达到信息隐藏的目的，即让类仅仅公开必须要让外界知道的内容，而隐藏其它一切内容。我们不可以滥用类的封装功能，不要把它当成火锅，什么东西都往里扔。

　　类的设计是以数据为中心，还是以行为为中心？

　　主张“以数据为中心”的那一派人关注类的内部数据结构，他们习惯上将private 类型的数据写在前面，而将public 类型的函数写在后面，如表8.1(a)所示。

　　主张“以行为为中心”的那一派人关注类应该提供什么样的服务和接口，他们习惯上将public 类型的函数写在前面，而将private 类型的数据写在后面，如表8.1(b)所示。

　　很多C++教课书主张在设计类时“以数据为中心”。我坚持并且建议读者在设计类时“以行为为中心”，即首先考虑类应该提供什么样的函数。Microsoft 公司的COM 规范的核心是接口设计，COM 的接口就相当于类的公有函数[Rogerson 1999]。在程序设计方面，咱们不要怀疑Microsoft 公司的风格。

　　设计孤立的类是比较容易的，难的是正确设计基类及其派生类。因为有些程序员搞不清楚“继承”（Inheritance）、“组合”（Composition）、“多态”（ Polymorphism）这些概念。

1.2 继承与组合

　　如果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);
};
// Example
main()
{
B b; // B的一个对象
b.Func1(); // B 从A 继承了函数Func1
b.Func2(); // B 从A 继承了函数Func2
b.Func3();
b.Func4();
}

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

　　一、如果类A 和类B 毫不相关，不可以为了使B 的功能更多些而让B 继承A 的功能。

　　不要觉得“不吃白不吃”，让一个好端端的健壮青年无缘无故地吃人参补身体。

　　二、如果类B 有必要使用A 的功能，则要分两种情况考虑：

　　（1）若在逻辑上B 是A 的“一种”（a kind of ），则允许B 继承A 的功能。如男人（Man）是人（Human）的一种，男孩（Boy）是男人的一种。那么类Man 可以从类Human 派生，类Boy 可以从类Man 派生。示例程序如下：

class Human
{
…
};
class Man : public Human
{
…
};
class Boy : public Man
{
…
};

　　（2）若在逻辑上A 是B 的“一部分”（a part of），则不允许B 继承A 的功能，而是要用A和其它东西组合出B。例如眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head 应该由类Eye、Nose、Mouth、Ear 组合而成，不是派生而成。示例程序如下：

class Eye
{
public:
void Look(void);
};
class Nose
{
public:
void Smell(void);
};
class Mouth
{
public:
void Eat(void);
};
class Ear
{
public:
void Listen(void);
};
// 正确的设计，冗长的程序
class Head
{
public:
void Look(void) { m_eye.Look(); }
void Smell(void) { m_nose.Smell(); }
void Eat(void) { m_mouth.Eat(); }
void Listen(void) { m_ear.Listen(); }
private:
Eye m_eye;
Nose m_nose;
Mouth m_mouth;
Ear m_ear;
};

　　如果允许Head 从Eye、Nose、Mouth、Ear 派生而成，那么Head 将自动具有Look、Smell、Eat、Listen 这些功能：

// 错误的设计
class Head : public Eye, public Nose, public Mouth, public Ear
{
};

　　上述程序十分简短并且运行正确，但是这种设计却是错误的。很多程序员经不起“继承”的诱惑而犯下设计错误。

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

　　因为母鸡下了鸭蛋。

　　本书3.3 节讲过“运行正确”的程序不见得就是高质量的程序，此处就是一个例证。

1.3 虚函数与多态

　　除了继承外，C++的另一个优良特性是支持多态，即允许将派生类的对象当作基类的对象使用。如果A 是基类，B 和C 是A 的派生类，多态函数Test 的参数是A 的 指针。那么Test 函数可以引用A、B、C 的对象。示例程序如下：

class A
{
public:
void Func1(void);
};
void Test(A *a)
{
a->Func1();
}
class B : public A
{
…
};
class C : public A
{
…
};
// Example
main()
{
A a;
B b;
C c;
Test(&a);
Test(&b);
Test(&c);
};

　　以上程序看不出“多态”有什么价值，加上虚函数和抽象基类后，“多态”的威力就显示出来了。

　　C++用关键字virtual 来声明一个函数为虚函数，派生类的虚函数将（override）基类对应的虚函数的功能。示例程序如下：

class A
{
public:
virtual void Func1(void){ cout<< “This is A::Func1 \n”}
};
void Test(A *a)
{
a->Func1();
}
class B : public A
{
public:
virtual void Func1(void){ cout<< “This is B::Func1 \n”}
};
class C : public A
{
public:
virtual void Func1(void){ cout<< “This is C::Func1 \n”}
};
// Example
main()
{
A a;
B b;
C c;
Test(&a); // 输出This is A::Func1
Test(&b); // 输出This is B::Func1
Test(&c); // 输出This is C::Func1
};

　　如果基类A 定义如下：

class A
{
public:
virtual void Func1(void)=0;
};

　　那么函数Func1 叫作纯虚函数，含有纯虚函数的类叫作抽象基类。抽象基类只管定义纯虚函数的形式，具体的功能由派生类实现。

　　结合“抽象基类”和“多态”有如下突出优点：

　　（1）应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。这一
招叫“以不变应万变”，可以大大提高程序的可复用性（这是接口设计的复用，而不是代码实现的复用）。

　　（2）派生类的功能可以被基类指针引用，这叫向后兼容，可以提高程序的可扩充性和可维护性。以前写的程序可以被将来写的程序调用不足为奇，但是将来写的程序可以被以前写的程序调用那可了不起。

2 良好的编程风格

　　内功深厚的武林高手出招往往平淡无奇。同理，编程高手也不会用奇门怪招写程序。良好的编程风格是产生高质量程序的前提。

2.1 命名约定

　　有不少人编程时用拼音给函数或变量命名，这样做并不能说明你很爱国，却会让用此程序的人迷糊（很多南方人不懂拼音，我就不懂）。程序中的英文一般不会太复杂，用词要力求准确。匈牙利命名法是Microsoft 公司倡导的[Maguire 1993]，虽然很烦琐，但用习惯了也就成了自然。没有人强迫你采用何种命名法，但有一点应该做到：自己的程序命名必须一致。

　　以下是我编程时采用的命名约定：

　　（1）宏定义用大写字母加下划线表示，如MAX_LENGTH；

　　（2）函数用大写字母开头的单词组合而成，如SetName, GetName ；

　　（3）指针变量加前缀p，如*pNode ；

　　（4）BOOL 变量加前缀b，如bFlag ；

　　（5）int 变量加前缀i，如iWidth ；

　　（6）float 变量加前缀f，如fWidth ；

　　（7）double 变量加前缀d，如dWidth ；

　　（8）字符串变量加前缀str，如strName ；

　　（9）枚举变量加前缀e，如eDrawMode ；

　　（10）类的成员变量加前缀m_，如m_strName, m_iWidth ；

　　对于int, float, double 型的变量，如果变量名的含义十分明显，则不加前缀，避免烦琐。如用于循环的int 型变量i,j,k ；float 型的三维坐标（x,y,z）等。

2.2 使用断言

　　程序一般分为Debug 版本和Release 版本，Debug 版本用于内部调试，Release 版本发行给用户使用。断言assert 是仅在Debug 版本起作用的宏，它用于检查“不应该”发生的情况。以下是一个内存复制程序，在运行过程中，如果assert 的参数为假，那么程序就会中止（一般地还会出现提示对话，说明在什么地方引发了assert）。

//复制不重叠的内存块
void memcpy(void *pvTo, void *pvFrom, size_t size)
{
void *pbTo = (byte *) pvTo;
void *pbFrom = (byte *) pvFrom;
assert( pvTo != NULL && pvFrom != NULL );
while(size - - > 0 )
*pbTo + + = *pbFrom + + ;
return (pvTo);
}

　　assert 不是一个仓促拼凑起来的宏，为了不在程序的Debug 版本和Release 版本引起差别，assert 不应该产生任何副作用。所以assert 不是函数，而是宏。程序员可以把assert 看成一个在任何系统状态下都可以安全使用的无害测试手段。

　　很少有比跟踪到程序的断言，却不知道该断言的作用更让人沮丧的事了。你化了很多时间，不是为了排除错误，而只是为了弄清楚这个错误到底是什么。有的时候，程序员偶尔还会设计出有错误的断言。所以如果搞不清楚断言检查的是什么，就很难判断错误是出现在程序中，还是出现在断言中。幸运的是这个问题很好解决，只要加上清晰的注释即可。这本是显而易见的事情，可是很少有程序员这样做。这好比一个人在森林里，看到树上钉着一块“危险”的大牌子。但危险到底是什么？树要倒？有废井？有野兽？除非告诉人们“危险”是什么，否则这个警告牌难以起到积极有效的作用。难以理解的断言常常被程序员忽略，甚至被删除。[Maguire 1993]

　　以下是使用断言的几个原则：

　　（1）使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况之间的区别，后者是必然存在的并且是一定要作出处理的。

　　（2）使用断言对函数的参数进行确认。

　　（3）在编写函数时，要进行反复的考查，并且自问：“我打算做哪些假定？”一旦确定了的
假定，就要使用断言对假定进行检查。

　　（4）一般教科书都鼓励程序员们进行防错性的程序设计，但要记住这种编程风格会隐瞒错误。当进行防错性编程时，如果“不可能发生”的事情的确发生了，则要使用断言进行报警。

2.3 new、delete 与指针

　　在C++中，操作符new 用于申请内存，操作符delete 用于释放内存。在C 语言中，函数malloc 用于申请内存，函数free 用于释放内 存。由于C++兼容C 语言，所以new、delete、malloc、free 都有可能一起使用。new 能比malloc 干更多的事，它可以申请对象的内存，而malloc 不能。C++和C 语言中的指针威猛无比，用错了会带来灾难。对于一个指针p，如果是用new申请的内存，则必须用delete 而不能用free 来释放。如果是用malloc 申请的内存，则必须用free 而不能用delete 来释放。在用delete 或用free 释放p 所指的内存后，应该马上显式地将p 置为NULL，以防下次使用p 时发生错误。示例程序如下：

void Test(void)
{
float *p;
p = new float[100];
if(p==NULL) return;
…// do something
delete p;
p=NULL; // 良好的编程风格
// 可以继续使用p
p = new float[500];
if(p==NULL) return;
…// do something else
delete p;
p=NULL;
}

　　我们还要预防“野指针”，“野指针”是指向“垃圾”内存的指针，主要成因有两种：

　　（1）指针没有初始化。
　　（2）指针指向已经释放的内存，这种情况最让人防不胜防，示例程序如下：

class A
{
public:
void Func(void){…}
};
void Test(void)
{
A *p;
{
A a;
p = &a; // 注意a 的生命期
}
p->Func(); // p 是“野指针”，程序出错
}

2.4 使用const

　　在定义一个常量时，const 比#define 更加灵活。用const 定义的常量含有数据类型，该常量可以参与逻辑运算。例如：

const int LENGTH = 100; // LENGTH 是int 类型
const float MAX=100; // MAX 是float 类型
#define LENGTH 100 // LENGTH 无类型
#define MAX 100 // MAX 无类型

　　除了能定义常量外，const 还有两个“保护”功能：

　　一、强制保护函数的参数值不发生变化

　　以下程序中，函数f 不会改变输入参数name 的值，但是函数g 和h 都有可能改变name的值。

void f(String s); // pass by value
void g(String &s); // pass by referance
void h(String *s); // pass by pointer
main()
{
String name=“Dog”;
f(name); // name 的值不会改变
g(name); // name 的值可能改变
h(name); // name 的值可能改变
}

　　对于一个函数而言，如果其‘&’或‘*’类型的参数只作输入用，不作输出用，那么应当在该参数前加上const，以确保函数的代码不会改变该参数的值（如果改变了该参数的值，编译器会出现错误警告）。因此上述程序中的函数g 和h 应该定义成：

void g(const String &s);
void h(const String *s);

　　二、强制保护类的成员函数不改变任何数据成员的值

　　以下程序中，类stack 的成员函数Count 仅用于计数，为了确保Count 不改变类中的任何数据成员的值，应将函数Count 定义成const 类型。

class Stack
{
public:
void push(int elem);
void pop(void);
int Count(void) const; // const 类型的函数
private:
int num;
int data[100];
};
int Stack::Count(void) const
{
++ num; // 编译错误，num 值发生变化
pop(); // 编译错误，pop 将改变成员变量的值
return num;
}

2.5 其它建议

　　（1）不要编写一条过分复杂的语句，紧凑的C++/C 代码并不见到能得到高效率的机器代码，却会降低程序的可理解性，程序出错误的几率也会提高。
　　（2）不要编写集多种功能于一身的函数，在函数的返回值中，不要将正常值和错误标志混在一起。
　　（3）不要将BOOL 值TRUE 和FALSE 对应于1 和0 进行编程。大多数编程语言将FALSE定义为0，任何非0 值都是TRUE。Visual C++将TRUE 定义为1，而Visual Basic 则将TRUE定义为-1。示例程序如下：

BOOL flag;
…
if(flag) { // do something } // 正确的用法
if(flag==TRUE) { // do something } // 危险的用法
if(flag==1) { // do something } // 危险的用法
if(!flag) { // do something } // 正确的用法
if(flag==FALSE) { // do something } // 不合理的用法
if(flag==0) { // do something } // 不合理的用法

　　（4）小心不要将“= =”写成“=”，编译器不会自动发现这种错误。

　　（5）不要将123 写成0123，后者是八进制的数值。

　　（6）将自己经常犯的编程错误记录下来，制成表格贴在计算机旁边。

3 小结

　　C++/C 程序设计如同少林寺的武功一样博大精深，我练了8 年，大概只学到二三成。所以无论什么时候，都不要觉得自己的编程水平天下第一，看到别人好的技术和风格，要虚心学习。本章的内容少得可怜，就象口渴时只给你一颗杨梅吃，你一定不过瘾。我借花献佛，推荐一本好书：Marshall P. Cline 著的《C++ FAQs》[Cline 1995]。你看了后一定会赞不绝口。会编写C++/C 程序，不要因此得意洋洋，这只是程序员基本的技能要求而已。如果把系统分析和系统设计比作“战略决策”，那么编程充其量只是“战术”。如果指挥官是个大笨蛋，士兵再勇敢也会吃败仗。所以我们程序员不要只把眼光盯在程序上，要让自己博学多才。我们应该向北京胡同里的小孩们学习，他们小小年纪就能指点江山，评论世界大事。

1. 概述

前几天在设计软件时，选择VC作为开发工具，想做个启动画面，由于以前没有制作过，所以到网上搜了一通。网上有几篇相关文章，有两篇我觉得很有价值：一篇是关于 为方便显示图像制作的CPicture类的文章，原文是由Paul DiLascia写的解答，很有影响力；还有一篇是关于制作真彩启动画面的文章，不过其限制对位图操作，而不支持jpg, gif，而且使用繁琐，基本上是对Splash Screen组件导入后的代码进行简单修改。琢磨了好大一会儿才学会使用。

有感于现有材料使用起来不方便，随进行了整合和再封装处理,设计了CSplashWnd类，使用起来非常简便。下面就把我设计的类介绍给大家。有什么不当或错误之处，敬请指正。我的Email: zhengxiliu@sohu.com

2．CSplashWnd功能

能够显示真彩启动画面，能在画面上显示初始化文字信息，支持jpg,gif,bmp图像文件。

3. CSplashWnd的设计

3.1 用户关心的接口

用户使用的公开接口：

public:
CSplashWnd(LPCTSTR lpszFileName);// 指定作为启动画面的图像文件,并装载
BOOL ShowSplash();//显示画面
void CloseSplash();//关闭画面
void ShowText(LPCTSTR pCh);在显示的图像上中间位置处显示初始化信息文字

3.2 其他接口
系统使用的公开接口：(用户不关心)
~CSplashWnd()
void PostNcDestroy();

私有接口：(用户不关心)
BOOL Create(CWnd* pParentWnd = NULL);
int OnCreate(LPCREATESTRUCT lpCreateStruct);
void OnPaint();

3.3 数据设计(用户不关心)
BOOL fileIsValid//指示
CPicture pic;//用于对图像文件进行操作的类
int width,height;

3.4 限制

√ 不允许继承。
√ 为简化接口，只提供从文件装载图像
3.5 需要的头文件

StdAfx.h, VC++6.0自动生成的对MFC的支持，不同的工程选项会产生不同的StdAfx.h。

afxwin.h 支持CRect类

atlbase.h 提供对IPicture （COM类）的支持。

afxpriv2.h提供对CArchiveStream类的支持。

4.类的健壮性和可调试性设计

图像文件是否有效?

需要检查文件是否有效，当装载图像文件失败时，fileIsValid为false，否则为true。这样在调用ShowSplash时将什么都不做，返回false。这时，用户应检查图像文件是否存在，文件名称拼写是否正确。

5. 用法

√ 将CSplashWnd类加入项目中

√ 在使用CSplashWnd类的文件中#include “Splash.h”

√ 在合适的位置定义一个CSplashWnd对象

√ 在想显示启动画面的地方调用ShowSplash显示于屏幕上

√ 如果想在启动画面上显示一些初始化或其他提示信息，调用ShowText。

√ 在你想关闭启动画面的地方

在你的App类InitInstance函数中,显示主窗口之前使用，进行上述步骤，这是最典型的用法，如下面代码所示。

BOOL CTsApp::InitInstance()
{
 AfxEnableControlContainer();

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

 SetRegistryKey(_T("Local AppWizard-Generated Applications"));
 LoadStdProfileSettings();// Load standard INI file options (including MRU)

 CSingleDocTemplate* pDocTemplate;
 pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CTsDoc),
RUNTIME_CLASS(CMainFrame), // main SDI frame window
RUNTIME_CLASS(CTsView));
 AddDocTemplate(pDocTemplate);

 CCommandLineInfo cmdInfo;
 ParseCommandLine(cmdInfo);

 if (!ProcessShellCommand(cmdInfo))
return FALSE;

/////////////////////////////////////////////////////////////////////////////////////
 CSplashWnd* pCsw = new CSplashWnd("fx.jpg");//located in the local directory,or else full-path file name is needed
 pCsw->ShowSplash();
 Sleep(750);//delay some time to observe the image displayed.
 pCsw->CloseSplash();
 delete pCsw;
 pCsw = NULL;
/////////////////////////////////////////////////////////////////////////////////////

 // The one and only window has been initialized, so show and update it.
 m_pMainWnd->ShowWindow(SW_SHOW);
 m_pMainWnd->UpdateWindow();

 return TRUE;
}
6. 类代码

6.1 Splash.h
/////////////////////////////////////////////////////////////////////////////
//Written by Liu Zhengxi
//May 5,2003
//Compiles with Visual C++ 6.0 for Windows 98 and probably Windows 2000
// too.
/////////////////////////////////////////////////////////////////////////////

#ifndef _SPLASH
#define _SPLASH
#include
#include

// Splash.h : header file
//

/////////////////////////////////////////////////////////////////////////////
// Splash Screen class

#pragma once

///////////////////////////////////////////////////////////////////////////
// Picture object—encapsulates IPicture
//Written by Paul DiLascia.
//used to display picture
//

// declare CPicture class
//

class CPicture {
public:
BOOL Render(CDC* pDC,CRect rc,LPCRECT prcMFBounds=NULL) const;
 CPicture();
 ~CPicture();

 // Load from various resources
 BOOL Load(UINT nIDRes);
 BOOL Load(LPCTSTR pszPathName);
 BOOL Load(CFile& file);
 BOOL Load(CArchive& ar);
 BOOL Load(IStream* pstm);

 // render to device context

 CSize GetImageSize(CDC* pDC=NULL) const;
 operator IPicture*() {
return m_spIPicture;
 }

 void GetHIMETRICSize(OLE_XSIZE_HIMETRIC& cx, OLE_YSIZE_HIMETRIC& cy)
const {
cx = cy = 0;
const_cast<CPicture*>(this)->m_hr = m_spIPicture->get_Width(&cx);
ASSERT(SUCCEEDED(m_hr));
const_cast<CPicture*>(this)->m_hr = m_spIPicture->get_Height(&cy);
ASSERT(SUCCEEDED(m_hr));
 }

 void Free() {
if (m_spIPicture) {
 m_spIPicture.Release();
}
 }

protected:
 CComQIPtr<IPicture>m_spIPicture; // ATL smart pointer to IPicture
 HRESULT m_hr;// last error code
};


///////////////////////////////////////////////////////////////////
//
//declare CSplashWnd
//

class CSplashWnd : public CWnd
{
// Construction
public:
CSplashWnd(LPCTSTR lpszFileName);
// Operations
public:
BOOL ShowSplash();
BOOL PreTranslateAppMessage(MSG* pMsg);
void ShowText(LPCTSTR lpStr);
void CloseSplash();
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CSplashWnd)
//}}AFX_VIRTUAL
// Implementation
public:
~CSplashWnd();
virtual void PostNcDestroy();
private:
BOOL Create(CWnd* pParentWnd = NULL);
// Generated message map functions
private:
//{{AFX_MSG(CSplashWnd)
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnPaint();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
private:
int height;//the height of the displayed picture
int width;//the width of the displayed picture
CPicture pic;//used to operate the picture
 BOOL fileIsValid;
};

#endif
6.2 Splash.cpp
///////////////////////////////////////////////////////////////////////////////
//Written by Liu Zhengxi
//May 5,2003
//Compiles with Visual C++ 6.0 for Windows 98 and probably Windows 2000
// too.
/////////////////////////////////////////////////////////////////////////////

//
// Splash.cpp : implementation file
//


#include <atlbase.h>
#include <afxwin.h>
#include <afxpriv2.h>
#include "stdafx.h"// e. g. stdafx.h
#include "Splash.h"// e.g. splash.h

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CSplashWnd class

////////////////////////////////////////////////////////////////////////////
//constructor
//Load image from the given file
//

CSplashWnd::CSplashWnd(LPCTSTR lpszFileName)
{
 fileIsValid = pic.Load(lpszFileName);
 if(fileIsValid)
 {
CSize cz = pic.GetImageSize(NULL);
width = cz.cx;
height = cz.cy;
 }
}


////////////////////////////////////////////////////////////////////////////////
//nothing to do
//deconstructor
//
CSplashWnd::~CSplashWnd()
{
}



////////////////////////////////////////////////////////////////////////////////
//message map
//

BEGIN_MESSAGE_MAP(CSplashWnd, CWnd)
 //{{AFX_MSG_MAP(CSplashWnd)
 ON_WM_CREATE()
 ON_WM_PAINT()
 ON_WM_TIMER()
 //}}AFX_MSG_MAP
END_MESSAGE_MAP()


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

//ShowSplash
//to display the given image on screen
//
BOOL CSplashWnd::ShowSplash()
{
 if(fileIsValid)
 {
if (!Create(AfxGetMainWnd()))
 return false;
else
{
 UpdateWindow();
 return true;
}
 }
 else
 {
return false;
 }
}


////////////////////////////////////////////////////////////////////////////////
//PreTranslateAppMessage
//

BOOL CSplashWnd::PreTranslateAppMessage(MSG* pMsg)
{
 // If we get a keyboard or mouse message, hide the splash screen.
 if (pMsg->message == WM_KEYDOWN ||
 pMsg->message == WM_SYSKEYDOWN ||
 pMsg->message == WM_LBUTTONDOWN ||
 pMsg->message == WM_RBUTTONDOWN ||
 pMsg->message == WM_MBUTTONDOWN ||
 pMsg->message == WM_NCLBUTTONDOWN ||
 pMsg->message == WM_NCRBUTTONDOWN ||
 pMsg->message == WM_NCMBUTTONDOWN)
 {
CloseSplash();
return TRUE; // message handled here
 }
 return FALSE;// message not handled
}

////////////////////////////////////////////////////////////////////////////////
//Create
//make a popup splash window
//

BOOL CSplashWnd::Create(CWnd* pParentWnd /*= NULL*/)
{
 return CreateEx(0,
AfxRegisterWndClass(0, AfxGetApp()->LoadStandardCursor(IDC_ARROW)),
NULL, WS_POPUP | WS_VISIBLE, 0, 0, width, height, pParentWnd->GetSafeHwnd(), NULL);
}

////////////////////////////////////////////////////////////////////////////////
//CloseSplash
//Quit the splash window
//

void CSplashWnd::CloseSplash()
{
 // Destroy the window, and update the mainframe.
 DestroyWindow();
}

////////////////////////////////////////////////////////////////////////////////
//do nothing
//

void CSplashWnd::PostNcDestroy()
{
}



////////////////////////////////////////////////////////////////////////////////
//OnCreate
//put the splash window on center
//

int CSplashWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
 if (CWnd::OnCreate(lpCreateStruct) == -1)
return -1;

 // Center the window.
 CenterWindow();
 return 0;
}



////////////////////////////////////////////////////////////////////////////////
//OnPaint
//Display the given image

//

void CSplashWnd::OnPaint()
{
CPaintDC dc(this);
CRect rc(0,0,0,0);;
pic.Render(&dc, rc);
}


////////////////////////////////////////////////////////////////////////////////
//ShowText
//sometimes if we show what we are doing (I display the information on the center of //the picture ), the customer will be more //patient
//
//

void CSplashWnd::ShowText(LPCTSTR lpStr)
{
 Invalidate();
 CPaintDC dc(this);
 dc.SetBkMode(TRANSPARENT);
 SIZE sz;
 sz = (SIZE)dc.GetTextExtent(lpStr,strlen(lpStr));
 dc.TextOut((width-sz.cx)/2,height/2,lpStr);
}

////////////////////////////////////////////////////////////////
// MSDN Magazine — October 2001
// If this code works, it was written by Paul DiLascia.
// If not, I don''t know who wrote it.
// Compiles with Visual C++ 6.0 for Windows 98 and probably Windows 2000
// too.
// Set tabsize = 3 in your editor.
//

////////////////////////////////////////////////////////////////
// CPicture implementation
//

CPicture::CPicture()
{
}

CPicture::~CPicture()
{
}

//////////////////
// Load from resource. Looks for "IMAGE" type.
//

BOOL CPicture::Load(UINT nIDRes)
{
 // find resource in resource file
 HINSTANCE hInst = AfxGetResourceHandle();
 HRSRC hRsrc = ::FindResource(hInst,
MAKEINTRESOURCE(nIDRes),
"IMAGE"); // type
 if (!hRsrc)
return FALSE;

 // load resource into memory
 DWORD len = SizeofResource(hInst, hRsrc);
 BYTE* lpRsrc = (BYTE*)LoadResource(hInst, hRsrc);
 if (!lpRsrc)
return FALSE;

 // create memory file and load it
 CMemFile file(lpRsrc, len);
 BOOL bRet = Load(file);
 FreeResource(hRsrc);
 return bRet;
}



//////////////////
// Load from path name.
//

BOOL CPicture::Load(LPCTSTR pszPathName)
{
 CFile file;
 if (!file.Open(pszPathName, Cfile&::modeRead|Cfile&::shareDenyWrite))
return FALSE;
 BOOL bRet = Load(file);
 file.Close();
 return bRet;
}


//////////////////
// Load from CFile
//

BOOL CPicture::Load(CFile& file)
{
 CArchive ar(&file, CArchive::load | CArchive::bNoFlushOnDelete);
 return Load(ar);
}



//////////////////
// Load from archive—create stream and load from stream.
//

BOOL CPicture::Load(CArchive& ar)
{
 CArchiveStream arcstream(&ar);
 return Load((IStream*)&arcstream);
}


//////////////////
// Load from stream (IStream). This is the one that really does it: call
// OleLoadPicture to do the work.
//

BOOL CPicture::Load(IStream* pstm)
{
 Free();
 HRESULT hr = OleLoadPicture(pstm, 0, FALSE,
IID_IPicture, (void**)&m_spIPicture);
 ASSERT(SUCCEEDED(hr) && m_spIPicture);
 return TRUE;
}


//////////////////
// Get image size in pixels. Converts from HIMETRIC to device coords.
//

CSize CPicture::GetImageSize(CDC* pDC) const
{
 if (!m_spIPicture)
return CSize(0,0);

 LONG hmWidth, hmHeight; // HIMETRIC units
 m_spIPicture->get_Width(&hmWidth);
 m_spIPicture->get_Height(&hmHeight);
 CSize sz(hmWidth,hmHeight);
 if (pDC==NULL) {
CWindowDC dc(NULL);
dc.HIMETRICtoDP(&sz); // convert to pixels
 } else {
pDC->HIMETRICtoDP(&sz);
 }
 return sz;
}

//////////////////
// Render to device context. Covert to HIMETRIC for IPicture.
//

BOOL CPicture::Render(CDC* pDC, CRect rc, LPCRECT prcMFBounds) const
{
 ASSERT(pDC);
 if (rc.IsRectNull()) {
CSize sz = GetImageSize(pDC);
rc.right = sz.cx;
rc.bottom = sz.cy;
 }
 long hmWidth,hmHeight; // HIMETRIC units
 GetHIMETRICSize(hmWidth, hmHeight);
 m_spIPicture->Render(*pDC, rc.left, rc.top, rc.Width(), rc.Height(),
0, hmHeight, hmWidth, -hmHeight, prcMFBounds);
 return TRUE;
}

（转）

　　路边停着一辆宝马，属违章停车。警察过来，贴条儿，抄单子。哥们儿从商场出来：“你丫不就是警察么，牛什么啊？不就会贴条儿、抄单子么！”警察看他一眼，没说话，继续抄单子。你要真牛b，甭贴条儿，你直接叫拖车拖走！”警察看他一眼，还没说话。“牛什么啊！除了贴条儿吓唬我们你们还会什么！牛b你拖走！”警察抄完单子，打电话，叫拖车。拖车来了。警察看着那哥们儿。“嘿，你还真牛啊！你真牛，你拖走啊！借你俩胆儿！”警察一摆手，拖走了。警察看他两眼，想劝劝他，往后别这么叫板。哥们儿一翻白眼儿：“你牛b，待会儿你等车主来了你告诉他,你把他的车拖走了！”

飚车的拖拉机

　　一个老板酒后，心情非常高兴，吹着口哨，开着心爱的奔驰600在公路上行使，这时，他发现路边停着一辆农用拖拉机，并且有一个人在摆手。于是，他停下车，原来，这个拖拉机坏在路上，想找人帮助拖走。老板今天心情非常高兴，便答应了。两个人同时约定好，如果拖拉机打右转向灯，请继续开。如果拖拉机打左转向，请停车。然后，老板开着奔驰600与拖拉机一起上路了。(当然开的很慢了)突然，一辆宝马轿车从后面以极快的速度超过他们，老板一看，非常生气，怒骂到：“还没有人敢超我奔驰600的呢！”于是，他马上挂高档，急踩油门，奔着宝马就追了上去。(因为喝了酒，他已忘了后面还拖了一辆拖拉机)老板很快的追上了宝马，正当他们以280迈的速度飚车的时候，被路边的一个交通警察发现了，想拦已经来不及了，连忙拿出对讲机，跟下一路段警察联系：“喂，喂，喂，发现两辆车在飚车，速度非常快，一个是宝马，一个是奔驰600，请你拦阻他们，不对，是三辆车在飚车，后面还紧紧的跟着一辆拖拉机，并且拖拉机还打着左转向灯，想超车……

开过大奔吗