高效编程十八式.pdf

《高效编程十八式.pdf》由会员分享，可在线阅读，更多相关《高效编程十八式.pdf（46页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、 1/46 高效编程十八式 王伟冰 2/46 目录目录 导言：编程五大原则.3 复数运算：类与函数.4 数据统计：泛型与委托.7 矩阵类：封装与约束.11 形体建模：继承与多态.15 宏思想与语法糖.18 命名、陷阱与异常.23 性能优化.27 多线程.31 代码编辑.35 测试.38 调试.40 总结.43 后记.45 3/46 导言：编程五大原则 本文讨论的是如何提高编程的质量和效率，涉及编程的十八个方面：类，函数，泛型，委托，封装，约束，继承，多态，宏思想，语法糖，命名，陷阱，异常，性能优化，多线程，代码编辑，测试，调试。示例代码主要是用 C+写的，但是我所讨论的原则同样适用于其它语言。

2、我根据自已实际编程的经验，以及阅读过的编程书籍，总结出编写代码的五条基本原则：简洁，安全，快速，灵活，清晰。下面用一些小小的例子，来接触一下这五个原则。我们在编程的时候，经常会遇到常量，比如说圆周率，我们可以这样写：const double PI=3.14159265;这样做的第一个好处就是，每一次用到圆周率时，只需要写 PI，就不用写什么 3.14一大串了，这就引出了第一个原则：简洁原则：写出来的代码简洁原则：写出来的代码要要尽量简洁尽量简洁，避免重复，避免重复。使用 PI 的另一个好处是，不容易出错。如果我们每一次都写 3.14，那么有可能某一次会不小心写错了哪位数字，导致计算结果不正确，

3、这种错误很难被发现。但是用 PI 的话，即使我们不小心把 PI 拼错了，编译器也会提醒我们。这就是第二个原则：安全安全原则：原则：写出来的代码要不易出错，易于查错。写出来的代码要不易出错，易于查错。那么，为什么要写成 const 呢？直接写 double PI=3.14159265 不也可以吗？这涉及到性能问题，const 型的变量编译时就能确定它的值，而非 const 型的变量在运行才能得到它的值，执行速度会慢一些。于是引出第三个原则：快快速原则：写出来的代码要快速运行，尽量省时。速原则：写出来的代码要快速运行，尽量省时。再来看另一个例子，比如你想输入 10 个数，然后排好序输出来：（省略具

4、体过程）const int Length=10;int aLength;for(int i=0;i Length;i+)/逐个输入/排序 for(int i=0;ix=a.x+b.x;pc-y=a.y+b.y;return*pc;实际上，Java 和 C#就是这样做的。但是 C+这样做会有一个严重问题：你在堆中创建了变量，什么时候回收？如果不回收，则会浪费内存（或者叫内存泄漏），如果要回收，则每次用完这个返回值之后都要自己手动回收，比如说：complex&c=add(a,b);/用 c 进行其它运算 delete&c;/手动回收 这简直就是麻烦。Java 和 C#以及其它很多高级语言都有自动垃

5、圾回收机制，所以不需要手动回收，但是 C+却只能这样。总之，在堆中创建的变量，要保证能回收。在堆中创建的变量，要保证能回收。（安全（安全原则原则2）现有 C+很难解决这个问题，不过，即将发布的 C+新标准，加入了“右值引用”的新特性，可以完美地解决这个问题。网上有很多资料，具体我就不介绍了。在现有的情况下，只能根据实际需要进行折衷设计，一般牺牲快速原则用 c=a+b。6/46 也许你会觉得我无聊，不就是一个复数加法吗，几行代码就完事，用得着讨论这么多吗？其实我只是想借用这个最简单例子来阐述一些普适性的原则。当你运用这些原则解决了复数加法的问题之后，你会发现同样的方法可以用来实现复数减法、乘法、

6、除法，甚至矩阵的加减乘除，集合的交、并、差，很多很多。7/46 数据统计：泛型与委托 我们常常会遇到这样的问题，比如说，统计一个班的学生中数学成绩大于 60 分的人数。假如说所有学生的成绩储存在一个 int 型数组中，那么我们可以定义这样的函数：int count(int scores,int n)int m=0;for(int i=0;i60)m+;return m;其中 scores 中储存学生成绩的数组，n 是数组的长度。于是我们就可以用诸如 count(a,30)这样的代码来统计一个 30 人的班上的及格人数了。但是，这样的一个函数，限死了只能统计大于 60 分的人数，不能统计大于 7

7、0 分、80分的人数，所以我们可以把函数改成这样：int count(int scores,int n,int min)int m=0;for(int i=0;imin)m+;return m;这样不就提高了灵活性了吗？所以，对于对于有可能改变的有可能改变的数值，不要写死，可以作为函数值，不要写死，可以作为函数参数传进来。数参数传进来。（灵活（灵活原则原则 1）但是可能过几天之后，你发现有的学生的成绩不是整数，可惜你的这个函数只能处理整数的情况，只好另写一个：double count(double scores,int n,double min)麻不麻烦？其实，如果从一开始就预料到类型可能会发

8、生改变，那么不妨把函数定义成模板：template int count(T scores,int n,T min)int m=0;for(int i=0;imin)m+;return m;其中 T 称为模板参数，如果 T 是 int，那么就得到前面 int 版本的 count 函数；如果 T是 double，就得到前面 double 版本的 count 函数。比如这样调用：m=count(a,30,60);/调用 int 版本 m=count(b,40,60);/调用 double 型版本 m=count(c,30,60);/编译器会根据 c 的类型自动推断出用哪个版本 所以，对于对于有可能改

9、变的有可能改变的类型，不要写死，可以写成模板，把类型作为模板参数传进类型，不要写死，可以写成模板，把类型作为模板参数传进来。来。包括类模板和函数模板。（灵活包括类模板和函数模板。（灵活原则原则 2）这就是“泛型编程”。而且这样也体现了简洁 8/46 原则，因为不需要对每种类型分别写一个单独的版本。但是，问题还没有完，有时我们不仅需要统计成绩大于某个值的人数，还要统计小于某个值的人数，或者是介于某两个值之间的人数。考虑到要尽量利用已有的类和函数来构尽量利用已有的类和函数来构造新的功能，而不改变类和函数的内部代码。造新的功能，而不改变类和函数的内部代码。（灵活（灵活原则原则 3）你可以这样子来实现

10、：m=30-count(a,30,60);/总人数减去大于 60 的人数得到小于 60 的人数 m=count(a,30,60)-count(a,30,70);/大于 60 的人数减去大于 70 的人数得到介于 60 和 70之间的人数 尽管这种方法很巧妙，在很多情况下是一种实用的思路，但是这毕竟是一种治标不治本的做法（而且性能不好），假如我要你统计出成绩是奇数或偶数的人数呢？无能为力了吧。根本的方法是使用函数指针：template int count(T scores,int n,bool func(T)/func 代表一个函数指针 int m=0;for(int i=0;i60;bool

11、func2(int x)/判断 x 是否是偶数 return x%2=0;这样你就可以这样子做统计：m=count(a,30,func1);/统计分数大于 60 的人数 m=count(a,30,func2);/统计分数是偶数的人数 其中 bool func(T)表示一个名为 func 的函数指针，它指向一个函数，这个函数的参数为T 型，返回值为 bool 型。当你把 func1（或 func2）作为参数传给 count 函数时，func 指针就指向了 func1（或 func2）函数。当执行到 func(scoresi)时，实际上就执行了func1(scoresi)（或 func2(scor

12、esi)）。所以，当一个函数里有一段当一个函数里有一段有可能改变的有可能改变的代码时，不要写死，可以把这段代码委托给代码时，不要写死，可以把这段代码委托给一个传进来的函数指针去执行。一个传进来的函数指针去执行。（灵活（灵活原则原则 4）这种思想就叫做“委托”。回顾前面的灵活原则 1，我们用一个 min 参数来代替 60，从而提高了灵活性和简洁性。我们希望 func1 函数也能做到这一点，能够判断 x 是否大于一个设定的数值 min.于是对它进行了改造：bool func1(double x,double min)return xmin;这样做对吗？那调用 count 怎么调用？count(a,

13、30,func(,60)？没有任何语言支持这种语法，count 要求传入的函数指针必须是 bool func(double)型的，也就是接受一个 double 型参数并返回 bool 型的，所以 func1 不能接受两个参数。解决方法 9/46 可以是这样：double min;bool func1(double x)return xmin;我们可以在调用 count 之前先设定 min 的值：min=60;m=count(a,30,func1);可惜的是，min 变量变成了一个全局变量，所有的函数都可以访问它，通常我们要严严格控制变量作用域，只有格控制变量作用域，只有真正需要用到真正需要用到

14、某个变量的代码段才可以访问到这个变量。某个变量的代码段才可以访问到这个变量。（清晰清晰原则原则 2）你可能觉得这没什么大不了，但是在大项目里，过多不必要的全局变量可能会导致不经意的命名冲突，使得在别的地方对另外一个变量的访问不小心变成了对这个变量的访问。即使不存在任何同名现象，在多线程的程序里对全局变量的异步访问也会导致意想不到的结果，这个后面还会说到。更好的实现应该使用函数对象，我们需要更改 count 和 func1 的定义：template int count(T scores,int n,T1 func)/func 的类型未定 int m=0;for(int i=0;imin;于是就可

15、以这样子：m=count(a,30,Func1(60);/统计分数大于 60 的人数 怎么这么复杂？这个过程发生了什么事？或许这样写会清楚一些：Func1 func1(60);m=count(a,30,func1);首先，Func1 是一个类型，而不是一个函数。Func1 func1(60)调用了 Func1 类的构造函数，新建了一个 Func1 型的对象 func1，并把它的成员变量 min 设为 60。然后把 func1 传给 count 函数的第三个参数，即 T1 func。所以 T1 就是 Func1，func 就是 func1。当执行 func(scoresi)的时候，就相当于执行

16、func1(scoresi)，即调用了 Func1 类的()运算符，把 scorei作为参数 x 传入，返回 xmin 即 scorei60 的值。在这里，func1 对象就叫做函数对象，因为它本质是一个对象，却表现得像一个函数指针。10/46 太麻烦了。为了增加灵活性得写这么长一个 Func1 类。有没有简单一点的办法？有。可以利用 C+内置的函数对象（需要#include）：m=count(a,30,bind2nd(greater(),60);这样就不用写 Func1 类了。但是这个实在很难看懂，我也不打算在这里解释它的意思你猜，如果要统计 60 到 70 间的人数该怎么写？m=count

17、(a,30,logical_and(bind2nd(greater(),60),bind2nd(less_equal(),70);也许有的人会觉得这个很酷，但是你看一下 C#是怎么写的：m=a.Count(x)=x60&x x60&x”是 lambda 表达式的标志，后面表示函数返回 x60&x return x60&x60&x”变成了“”，并且提到前面而已。总之，如果需要对函数指针进行更加灵活的定制，可以使用函数对象或者如果需要对函数指针进行更加灵活的定制，可以使用函数对象或者 lambda 表表达式。达式。（灵活（灵活原则原则 5）11/46 矩阵类：封装与约束 矩阵的元素可以用一个数组来

18、储存，我们希望建立一个矩阵类，来封装各种矩阵操作（比如加减乘、求逆、转置等等）。我们可以这么写：class matrix int width,height;/矩阵的宽度和高度 double*data;/储存矩阵数据的数组 public:matrix(int w1,int h1)/构造函数 width=w1;height=h1;data=new doublew1*h1;void add(const matrix&m1,const matrix&m2)/加法 for(int i=0;iwidth*height;i+)datai=m1.datai+m2.datai;/其它矩阵操作，不一一写出 ;在这

19、里我们把 width、height 和 data 都设为私有变量，因为我们不希望使用 matrix 类的代码对这些变量作随意的更改，如果外界代码对类的某个成员变量或函数的随意访问可如果外界代码对类的某个成员变量或函数的随意访问可能导致不好的结果，则应该把它设为私有成员。能导致不好的结果，则应该把它设为私有成员。（安全（安全原则原则 3）随意更改矩阵的高度、宽度或数据的储存位置，都可能导致原有数据的丢失。现在我们还不能对矩阵的具体元素进行访问，可以通过在 matrix 类中重载()运算符来实现：double&operator()(int i,int j)/返回第 i 行第 j 列元素 retur

20、n datai*width+j;由于返回类型是引用类型，所以不仅可以读取，还可以对它进行赋值：matrix m(3,3);double x=m(0,1);/读取第 0 行第 1 列元素 m(0,1)=x;/设置第 0 行第 1 列元素 这样，我们提供了对矩阵数据的封装，虽然外部代码无法直接访问矩阵数据，但是可以通过()运算符对它进行访问。现在我们的矩阵类看似可以做很多事情了，但实际上它有很多漏洞。比如，在构造函数里面用 new doublew1*h1分配了内存，但是却没有考虑它的回收，我们可以在 matrix 类中定义析构函数，让它自动回收：matrix()delete data;当一个 ma

21、trix 型变量销毁时（比如说，局部变量在函数返回时会自动销毁），就会调用析构函数matrix()，释放 data 指向的内存。12/46 然而这样还不够，假如我这样用，会发生什么事？matrix m1(3,3);matrix m2(m1);/调用 matrix 类的复制构造函数 m2=m1;/调用 matrix 类的=运算符 等等，我们并没有定义什么“复制构造函数”和“=运算符”啊？这是 C+为每一个类自动生成的，这两个函数都会自动地复制 m1 中变量的值到 m2 里去。上面代码的本意应该是把 m1 的数据复制给 m2，但实际上只是复制 data 指针的值，也就是说，m1、m2 里的data

22、 指针指向的是同一个地址，更改任一个矩阵的元素值也会同时更改另一个矩阵的元素值。而且，当这两个 matrix 对象销毁时，它们的析构函数会分别被调用，执行 delete data操作，同一个 data 地址被 delete 两次，这样很可能会使程序崩溃。所以 C+自动生成的这两个函数并不是什么好东西。解决方法是把它们显式地实现为复制数据，而不是复制指针：public:matrix(const matrix&m1)width=m1.width;/复制宽度 height=m1.height;/复制高度 data=new doublewidth*height;/新分配内存 for(int i=0;i

23、=0&i=0&jheight);return datai*width+j;assert 的作用就是，如果传给它的参数为 true，那么什么事都没发生，如果为 false，那么程序就会终止，或者进入调试状态。（需要包含 assert.h 头文件）所以，要确保每个数组的下标访问不会越界，每个函数的输入参数都合法。要确保每个数组的下标访问不会越界，每个函数的输入参数都合法。（安全（安全原原则则 5）void add(const matrix&m1,const matrix&m2)这个函数的输入参数就有可能不合法，要保证两个输入矩阵的宽与高都和当前矩阵一样：assert(m1.width=width&

24、m1.height=height 13/46&m2.width=width&m2.height=height);总之，为了防止外部代码随意访问而可能导致的不良后果，我们应当对这些访问加以约束。再来考虑一下矩阵的转置，比如：void transpose(matrix&m1)assert(m1.width=height&m1.height=width);for(int i=0;iheight;i+)for(int j=0;jdata1 if(&m1=this)/记得删除这个副本 delete pm1;就可以让自身转置了。总之，尽量减少尽量减少对对类和函数的类和函数的用法的用法的无理规定。无理规定。

25、（清晰原则清晰原则 3）注意，这里 transpose 函数设计成这样，只是为了引出上面的两条原则，这种设计并不是好的设计，好的设计应该是像 m=m1.transpose()这样。你有没有发现，本节提到的安全原则，基本上都是以牺牲灵活性为代价的，要么是限制访问类的某个成员，要么是限制数组下标或函数参数的范围，要么是限制两个指针不能指向同一变量。面向对象程序设计的教科书往往很推崇这种限制，或者叫做“封装”。但是我认为，这种限制有时候是没有必要的。比如我写这个 matrix 类只是为了给我自己用，我自己很清楚它是怎么实现的，所以我也不会笨到去乱改它的成员变量，不会笨到去传给它一个不合法的参数，那我

26、干嘛还要自己限制自己呢？14/46 而如果这个 matrix 类是给别人用的，就如同 printf、cout 是别人写给我们用的一样，那么封装限制就是必要的了。我们无法保证别人是否会合法地使用这个类，所以必须加以限制。所以，对于只在模块内部使用到的代码对于只在模块内部使用到的代码，访问限制松一些，参数检查松一些，类和变，访问限制松一些，参数检查松一些，类和变量的命名随意一些。量的命名随意一些。会被外部使用到会被外部使用到的代码则相反。的代码则相反。（灵活原则灵活原则 6）事物总有好处和坏处，对一个类进行封装和约束，虽然麻烦，但是以后你就可以在上层代码放心使用这个类了；不进行封装和约束，你在上层

27、代码就得小心使用，不过只要你自己有把握，就可以更灵活地使用这个类。这就好比 C/C+中的指针，其它高级语言都没有指针，因为使用指针很容易出问题；但是如果你指针用得很熟了，你可以用指针实现其它语言无法实现的强大功能。15/46 形体建模：继承与多态 我们经常会用计算机对一些现实的事物进行建模，比如说用代码来描述一些形体。我们可以用边长来描述一个立方体，这样就可以求出它的体积：class cube public:double length;double volume()return length*length*length;我们同样可以用半径来描述一个球体：class sphere public:

28、double radius;double volume()return 4*PI*radius*radius*radius/3;现在我们有若干个立方体和若干个球体，假设我们要求出它们的总体积，一种方法是分别求立方体和球的总体积，再把这两个总体积加起来。但是这样比较麻烦，我们希望能够统一地对待立方体和球体，所以我们可以为它们建立一个共同的基类 object：class object public:virtual double volume();class cube:public object/让 cube 继承 object ;class sphere:public object/让 spher

29、e 继承 object ;然后就可以用 object 类来统一代表 cube 和 sphere 了。比如：cube c1;object*p=&c1;/将 cube 类指针转换成 object 类指针 double v=p-volume();/调用 cube 类的 volume()函数 sphere s1;p=&s1;/将 sphere 类指针转换成 object 类指针 v=p-volume();/调用 sphere 类的 volume()函数 也就是说，通过基类的指针可以调用不同子类的函数，这种特点称为“多态性”。但是实现多态性有两个前提，一是基类中要给函数加上“virtual”修饰符，这样

30、的函数称为“虚函数”；二是必须通过指针或引用调用虚函数，如果不用指针或引用，比如 object p=c1;p.volume();只是简单地调用基类中的 volume 函数。16/46 现在我们可以把所有立方体和球的指针一起放到一个 object*型的数组里：object*objects10;/其它操作 double v=0;for(int i=0;ivolume();这样，我们用简单的几句代码求出了所有物体的总体积，而不需要管每个物体究竟是什么形状。因此，对于对于内部实现不同但对外接口相同的内部实现不同但对外接口相同的类成员函数类成员函数，可以建立共同的基类，可以建立共同的基类虚函数（或虚函数

31、（或 Java 和和 C#中的接口）中的接口），从而可以在，从而可以在外部外部代码中统一处理，简化代码中统一处理，简化外部外部代码。代码。（简简洁原则洁原则 3）现在我们的形体类都只有形状信息。我们可以还希望给它增加密度信息，这样可以求出质量：class object public:double density;/密度 double mass()/返回质量 return volume()*density;virtual double volume();注意到 mass 是“实函数”，并不用加 virtual，因为对于每一种形体，计算质量的方法都是一样的：密度乘体积。所以我们不需要在 cube

32、类和 sphere 类中分别定义 density 和mass()，而是把它们放在基类 object 中定义，于是在子类中就都可以使用这些变量和函数了。所以，对于对于内部实现完全一致的内部实现完全一致的类成员类成员变量和函数，可以放在基类中统一实现，简化变量和函数，可以放在基类中统一实现，简化内部代码。内部代码。（简洁原则简洁原则 4）于是我们看到，继承实际上分为两种，一种是实继承，继承的是内部实现，用于简化内部代码；一种是虚继承，继承的是对外接口，用于简化外部代码。但是，继承的时候一定要注意，当类 B 继承类 A 时，类 B 会全盘继承类 A 的变量、实函数和虚函数。所以，当且仅当类 B 确实

33、需要 A 的所有变量、实函数和虚函数时，才可以让 B 继承 A。如果 B 只需要 A 的一部分，应该让 B 和 A 继承自一个共同的基类。尽管面向对象的程序设计思想受到了很多人的推崇，但是程序中的类和现实中的事物毕竟不是完全对应。在现实中 B 属于 A 并不代表着 B 就必须继承自 A。比如正方形属于长方形，但是让正方形类继承自长方形类并不是一种好的设计。正方形类只需要边长一个变量，而长方形却需要长和宽两个变量，让正方形全盘继承这两个变量是一种多余，而且还得采取必要的手段确保这两个变量始终相等。如果想要统一地对正方形和长方形求面积，不如让正方形和长方形共同继承一个可以求面积的虚函数：class

34、 has_area public:virtual double area();不过，让“带有颜色的长方形”去继承“长方形”就不会错，因为前者完全是后者的扩展，所以需要继承后者的所有信息。17/46 类的继承和多态，只有能够真正简化代码时，才是有用的。一些面向对象程序设计的教材总喜欢举一些不切实际的例子。比如商店里买东西，每一种不同的商品都继承自“商品”这个类，每种商品都定义了自己的 getname()函数和 getprice()函数来获取它的名称和价格。问题是我何必这么麻烦？我只需要一个商品类就可以了：class commodity public:char name10;double pric

35、e;然后每种不同的商品就是 commodity 类的不同实例，具有不同的 name 和 price 而已。没错，“牙刷”是一种“商品”，但“牙刷”不一定要成为“商品”的子类，它可以是“商品”类的一个实例，因为“牙刷”和其它的商品的区别只是数据不同（name 和 price 都只是数据），而不是函数不同（立方体和球就是函数不同，因为它们求体积用的函数根本不一样）。仅仅是函数不同还不代表一定要用多态（因为使用函数指针也可以把不同的函数统一对待），还要求这里的函数不是全局函数而是类的实例成员函数，它和类的其它成员有着紧密的关联（比如立方体求体积与其边长有紧密关联），这种情况下使用多态是最合适的。To

36、pLanguage 上不时有 GP（泛型编程）和 OO（面向对象）之争，我认为全局函数用 GP，如第 2 节所示，类的实例成员函数用 OO，如本节所示，而类模板（或者说泛型类）则是GP 与 OO 的结合。最后，Java 没有函数指针或委托，所以 Java 只能使用多态。18/46 宏思想与语法糖 在 C 程序里我们会常用到宏定义，比如导言中 PI 的例子，也可以写成宏定义：#define PI 3.14159265 如同导言所讨论的，宏定义也有同样的好处：简化书写、便于修改、便于理解等。然而，正如许多 C/C+书籍所强调的，宏定义不安全，因为它只是执行简单的文本替换。比如#define f(x

37、)x*x，那么 f(1+2)会变成 1+2*1+2 而不是(1+2)*(1+2)。所以我们不提倡在代码中随便使用宏。但是，我们依然需要运用宏的思想，来做到简化书写、便于修改、便于理解的目的。C+的许多语言特性运用到了宏的思想，同时又避免了宏的不安全性：1.const 常量常量 这个我们在导言中已经讨论过。2.typedef 比如我们要使用 C+内置的复数类，完整的名称应该是 std:complex，这样写显然太麻烦，或许可以用宏：#define comp std:complex 然而这样可能不太安全，更保险的是用 typedef：typedef std:complex comp;表明 comp

38、 类型是 std:complex的别名。3.内联函数内联函数 比如我们在代码中多次用到三次方运算，我们可以定义一个宏：#define cube(x)(x)*(x)*(x)为了避免上面所提到的安全问题，我们加了好几个括号。但是这样并不代表着就完全没问题了，因为宏不会对输入参数进行类型检查，更好的方法是定义内联函数：inline double cube(double x)return x*x*x;内联函数和函数有什么区别？看起来就是多了个 inline 修饰符而已。但是内联函数在运行时是不存在的，它只是在编译的时候把调用 cube(x)的地方替换成 x*x*x 而已，跟宏一样，只不过它会进行参数的

39、类型检查，而且它保证正确运算次序，不需要像宏一样加括号才能保证。内联函数比起函数的好处就是性能，因为函数的调用需要进行参数的复制、控制的跳转、返回值的复制等多余操作，而内联函数只是简单的语句替换，所以它的性能会更好。4.sizeof sizeof 语句常用于内存分配的语句中：int*p=(int*)malloc(sizeof(int)*10);/分配 10 个整数的空间 我们明明知道 sizeof(int)是 4，但还是要写成 sizeof(int)，一方面是使表意清晰，另一方面是使代码可移植，如果我们换了一台机器来编译，说不定 sizeof(int)不再是 4 了，而我们用 sizeof 不

40、需要做任何更改。如果我们直接写成 4，那么移植的时候就要把每个 4 都改成别的，麻烦。19/46 5.枚举枚举 枚举常用于描述选项之类的信息，比如第四节的立方体与球体求体积，也可以这样实现：enum shape cube,sphere;class object public:shape type;/标志物体属于哪种形状，有两个选项：cube 和 sphere double length;/如果是立方体则表示边长，是球体则表示半径 double volume()switch(type)case cube:/如果是立方体 return length*length*length;case spher

41、e:/如果是球体 return 4*PI*length*length*length/3;枚举值本质上就是整数值，上面的 cube 实际上就是 0，而 sphere 就是 1。下面的代码和上面的本质上是一样的：int type;double volume()switch(type)case 0:/如果是立方体 return length*length*length;case 1:/如果是球体 return 4*PI*length*length*length/3;既然直接写 0 和 1 就可以解决问题，那为什么还要使用枚举呢？因为枚举含义清晰，比较好记，上例中的枚举只有两个可能值，假如说有 10

42、个可能值，那你就得时时刻刻记住哪个数对应哪个意思，稍有不慎就会弄错。还有，枚举可以随意排列，把上面的定义语句改成 enum shape sphere,cube，其它代码都不需要修改；但是如果直接用数字，你想让 0表示球体，让 1 表示立方体，那就所有代码都要改。6.条件编译条件编译 条件编译常用于程序版本的控制，比如说，你希望你的程序在测试版本中输出一些中间信息，以检查程序运行过程是否有问题，而在正式版本中你不想要这些信息，你可以一条一条手工地删除这些代码，但是这样做太麻烦，所以可以用条件编译：#define TEST#ifdef TEST cout信息 1;#endif 20/46#ifde

43、f TEST cout0&m13);month=m;那么你在用的时候就必须这样：int m=a.getMonth();/获取月份 a.setMonth(10);/设置月份 这时我们称 Month 为一个属性，属性就是提供一个 get 函数和一个 set 函数去约束对一个私有变量的访问。如果提供 get 函数，则称为只读属性。在 C#里，提供了用于专门定义属性的语法，使得你可以这样使用属性：int m=a.Month;a.Month=10;看起来 Month 好像是一个成员变量，但它实际上还是一个 get 函数和一个 set 函数。2.索引器索引器 假设 Student 类用来储存一个学生的信息

44、，而 Class 类用来储存一个班的信息，class1 21/46 是 Class 类的一个实例。那么 Class 类里应该有一个 Student 数组，假设数组名为 students，为了获取这个班的第一个学生，我们应该这样做：Student stu=class1.students0;C#提供了一索引器的语法，定义了索引器之后你可以这样做：Student stu=class10;就好像重载运算符一样。还可以这样做：Student stu=class1“张三”;可以找出名为张三的学生。而且索引器参数还可以不止一个：Student stu=class11,3;找出坐在第 1 排第 3 列的学生（

45、假如我们记录了每个学生的座位）。索引器本质上也是一个 get 函数和 set 函数：Student stu=class11,3;/相当于 class1.get(1,3)class11,3=stu;/相当于 class1.set(1,3,stu)3.扩展方法扩展方法 比如在 C+中，你定义了一个 print 函数来输出一个整数：void print(int x)coutxendl;然后你使用这个函数：print(10);C#提供了一种定义函数的语法，使得你可以这样调用它：10.print();仿佛 print 是 int 的成员函数，但本质上并不是。4.可变个数参数可变个数参数 考虑一个求和函数

46、，在 C+里你可以这样：int sum(int a,int n)int s=0;for(int i=0;in;i+)s+=ai;return s;然后你在代码中使用这个函数：int a3=1,2,3;int s=sum(a,2);/得到 3 s=sum(a,3);/得到 6 C#提供了一种语法，能够定义参数个数可变的函数，然后你就可以这样：int s=sum(1,2);/得到 3 s=sum(1,2,3);/得到 6 传任意多个参数都可以。这种函数本质上是按照输入的参数生成一个数组，然后把这个数组传给函数。5.var 关键字关键字 22/46 var 关键字可以使你定义变量的时候不需要写类型。

47、比如：var x=10;/x 就是 int 型 var x=”abcd”;/x 就是 string 型 有些类型的全称很长，用 var 就可以简化书写。C+新标准提出 auto 关键字，和 var 有同样的功能，比如：vector vec;auto iter=vec.begin();/相当于 vector:iterator iter=vec.begin();除了这里提及的，语法糖还有很多，包括其它语言里的。语法糖可以简化书写，这自然的好事，但是请不要太过依赖语法糖，真正决定编程质量和效率的，是整个程序的架构设计是否合理。也不要凭语法糖多少去评价一种编程语言的好坏。最后总结一下，应当充应当充分利

48、用分利用语法糖来简化书写，但也不要太过依赖。语法糖来简化书写，但也不要太过依赖。（简洁原则（简洁原则 5）23/46 命名、陷阱与异常 命名命名 命名其实包括两方面的内容，一个是起什么样的名字，一个是在什么地方定义。通常我们认为，一个变量、函数或类的名字应该能够清晰地表达出它的作用，但是有时候要想出一个合适的名字就很费时间，所以比较实际的做法是，一个变量、函数或类的重要性越一个变量、函数或类的重要性越大，它的名字就越应该清晰地表达出它的作用。大，它的名字就越应该清晰地表达出它的作用。（清晰原则清晰原则 4）衡量重要性有两个方面，一方面是本征重要性：类函数变量；另一方面是使用次数，一个变量、函数

49、或类在代码中出现的次数越多，它的重要性就越大。所以从某种角度来读，一种语言内置的库函数的重要性是最大的，因为有无数人的无数代码要使用它。所以像 scanf、printf 这样的名字简直罪大恶极，每一个学 C 语言的同学都必须被迫接受这样一些不是单词的单词呵呵开玩笑啦。大型项目需要避免的一个重要问题就是同名问题。解决同名的一个方法就是减少全局变量。比如你在程序中用到 100 个坐标，你可以这样定义：int x100;int y100;也可以这样定义：struct point int x,y;point p100;把关联密切的一组变量组合到一个结构或类里面去，这样就减少了全局变量。有些变量根本没必

50、要是全局变量，比如这样：int t;void swap(int&a,int&b)t=a,a=b,b=t;完全可以把 t 放到 swap 里定义。另一个方法是使用命名空间。比如：namespace A int x;void f()namespace B int x;void f()那么 A:x 和 B:x 就代表不同的变量，A:f()和 B:f()代表不同的函数。在 A 中使用 x 变量就是使用 A:x 变量。通常，我们把一组功能较为接近，关联较为密切的变量和函数放到同一个命名空间里。我本人喜欢把我自己写的代码放在一个以我的名字缩写为名的命名空间里。还有一种方法是使用静态变量和静态函数。有些全局