深入C（关键字）四五六_1.7.1 不要拿青龙偃月刀去削苹果-CSDN博客

1.7，switch、case组合

既然有了if、else组合为什么还需要switch、case组合呢？

1.7.1，不要拿青龙偃月刀去削苹果

那你既然有了菜刀为什么还需要水果刀呢？你总不能扛着云长的青龙偃月刀（又名冷艳锯）去削苹果吧。如果你真能做到，关二爷也会佩服你的。^_^。

if、else一般表示两个分支或是嵌套表示少量的分支，但如果分支很多的话……还是用switch、case组合吧。其基本格式为:

switch(variable)

{

caseValue1:

//program code

break;

caseValue2:

//program code

break;

caseValue3:

//program code

break;

…

default:

break;

}

很简单，但有两个规则：

【规则1-19】每个case 语句的结尾绝对不要忘了加break，否则将导致多个分支重叠（除非有意使多个分支重叠）。

【规则1-20】最后必须使用default 分支。即使程序真的不需要default处理，也应该保留语句：

default:

break;

这样做并非画蛇添足，可以避免让人误以为你忘了default处理。

1.7.2，case关键字后面的值有什么要求吗？

好，再问问：真的就这么简单吗？看看下面的问题：

Value1 的值为0.1行吗？-0.1呢？-1呢？0.1+0.9呢？ 1+2呢？3/2呢？‘A’呢？“A”呢？变量i（假设i已经被初始化）呢？NULL呢？等等。这些情形希望你亲自上机调试一下，看看到底哪些行，哪些不行。

记住：case 后面只能是整型或字符型的常量或常量表达式（想想字符型数据在内存里是怎么存的）。

1.7.3，case语句的排列顺序

似乎从来没有人考虑过这个问题，也有很多人认为case语句的顺序无所谓。但事实却不是如此。如果case语句很少，你也许可以忽略这点，但是如果case语句非常多，那就不得不好好考虑这个问题了。比如你写的是某个驱动程序，也许会经常遇到几十个case语句的情况。一般来说，我们可以遵循下面的规则：

【规则1-21】按字母或数字顺序排列各条case语句。

如果所有的case语句没有明显的重要性差别，那就按A-B-C或1-2-3等顺序排列case语句。这样做的话，你可以很容易的找到某条case语句。比如：

switch(variable)

{

case A:

//program code

break;

case B:

//program code

break;

case C:

//program code

break;

…

default:

break;

}

【规则1-22】把正常情况放在前面，而把异常情况放在后面。

如果有多个正常情况和异常情况，把正常情况放在前面，并做好注释；把异常情况放在后面，同样要做注释。比如：

switch(variable)

{

///

//正常情况开始

case A:

//program code

break;

case B:

//program code

break;

//正常情况结束

//异常情况开始

case -1:

//program code

break;

//异常情况结束

…

default:

break;

}

【规则1-23】按执行频率排列case语句

把最常执行的情况放在前面，而把最不常执行的情况放在后面。最常执行的代码可能也是调试的时候要单步执行的最多的代码。如果放在后面的话，找起来可能会比较困难，而放在前面的话，可以很快的找到。

1.7.4，使用case语句的其他注意事项

【规则1-24】简化每种情况对应的操作。

使得与每种情况相关的代码尽可能的精炼。case语句后面的代码越精炼，case语句的结果就会越清晰。你想想，如果case语句后面的代码整个屏幕都放不下，这样的代码谁也难看得很清晰吧。如果某个case语句确实需要这么多的代码来执行某个操作，那可以把这些操作写成一个或几个子程序，然后在case语句后面调用这些子程序就ok了。一般来说case语句后面的代码尽量不要超过20行。

【规则1-25】不要为了使用case语句而刻意制造一个变量。

case语句应该用于处理简单的，容易分类的数据。如果你的数据并不简单，那可能使用if-elseif的组合更好一些。为了使用case而刻意构造出来的变量很容易把人搞糊涂，应该避免这种变量。比如：

charaction=a[0];

switch(action)

{

case‘c’:

fun1（）；

break;

case‘d’:

…

break;

default:

break;

}

这里控制case语句的变量是action。而action的值是取字符数组a的一个字符。但是这种方式可能带来一些隐含的错误。一般而言，当你为了使用case语句而刻意去造出一个变量时，真正的数据可能不会按照你所希望的方式映射到case语句里。在这个例子中，如果用户输入字符数组a里面存的是“const”这个字符串，那么case语句会匹配到第一个case上，并调用fun1（）函数。然而如果这个数组里存的是别的以字符c开头的任何字符串（比如：“col”，“can”），case分支同样会匹配到第一个case上。但是这也许并不是你想要的结果，这个隐含的错误往往使人抓狂。如果这样的话还不如使用if-elseif组合。比如：

if（0==strcmp(“const”，a））

{

fun1();

}

elseif

{

…

}

【规则1-26】把default子句只用于检查真正的默认情况。

有时候，你只剩下了最后一种情况需要处理，于是就决定把这种情况用default子句来处理。这样也许会让你偷懒少敲几个字符，但是这却很不明智。这样将失去case语句的标号所提供的自说明功能，而且也丧失了使用default子句处理错误情况的能力。所以，奉劝你不要偷懒，老老实实的把每一种情况都用case语句来完成，而把真正的默认情况的处理交给default子句。

1.8，do、while、for关键字

C语言中循环语句有三种：while循环、do-while循环、for循环。

while循环：先判断while后面括号里的值，如果为真则执行其后面的代码；否则不执行。while（1）表示死循环。死循环有没有用呢？看下面例子：

比如你开发一个系统要日夜不停的运行，但是只有操作员输入某个特定的字符‘#’才可以停下来。

while（1）

{

if(‘#’==GetInputChar())

{

break;

}

1.8.1，break与continue的区别

break关键字很重要，表示终止本层循环。现在这个例子只有一层循环，当代码执行到break时，循环便终止。

如果把break换成continue会是什么样子呢？continue表示终止本次（本轮）循环。当代码执行到continue时，本轮循环终止，进入下一轮循环。

while（1）也有写成while(true)或者while(1==1) 或者while((bool)1)等形式的，效果一样。

do-while循环：先执行do后面的代码，然后再判断while后面括号里的值，如果为真，循环开始；否则，循环不开始。其用法与while循环没有区别，但相对较少用。

for循环：for循环可以很容易的控制循环次数，多用于事先知道循环次数的情况下。

留一个问题：在switchcase 语句中能否使用continue关键字？为什么？

1.8.2，循环语句的注意点

【建议1-27】在多重循环中，如果有可能，应当将最长的循环放在最内层，最短的循环放在最外层，以减少CPU跨切循环层的次数。

例如：

长循环在最内层，效率高长循环在最外层，效率低

for(col=0;col<5;col++) for(row=0;row<100;row++)

{ {

for(row=0;row<100;row++) for(col=0;col<5;col++)

{ {

sum=sum+a[row][col]; sum=sum+a[row][col];

} }

【建议1-28】建议for语句的循环控制变量的取值采用“半开半闭区间”写法。半开半闭区间写法和闭区间写法虽然功能是相同，但相比之下，半开半闭区间写法写法更加直观。

半开半闭区间写法闭区间写法

for(n=0;n<10;n++) for(n=0;n<=9;n++)

{ {

⋯ ⋯

} }

【规则1-29】不能在for循环体内修改循环变量，防止循环失控。

for(n=0;n<10;n++)

{

…

n=8;//不可，很可能违背了你的原意

…

}

【规则1-30】循环要尽可能的短，要使代码清晰，一目了然。

如果你写的一个循环的代码超过一显示屏，那会让读代码的人发狂的。解决的办法由两个：第一，重新设计这个循环，确认是否这些操作都必须放在这个循环里；第二，将这些代码改写成一个子函数，循环中只调用这个子函数即可。一般来说循环内的代码不要超过20行。

【规则1-31】把循环嵌套控制在3层以内。

国外有研究数据表明，当循环嵌套超过3层，程序员对循环的理解能力会极大的降低。如果你的循环嵌套超过3层，建议你重新设计循环或是将循环内的代码改写成一个字函数。

1.9，goto关键字

一般来说，编码的水平与goto语句使用的次数成反比。有的人主张慎用但不禁用goto语句，但我主张禁用。关于goto语句的更多讨论可以参看SteveMcConnell的名著《CodeComplete.SecondEdition》。

【规则1-32】禁用goto语句。

自从提倡结构化设计以来，goto就成了有争议的语句。首先，由于goto 语句可以灵活跳转，如果不加限制，它的确会破坏结构化设计风格；其次，goto 语句经常带来错误或隐患。它可能跳过了变量的初始化、重要的计算等语句，例如：

structstudent*p=NULL;

…

gotostate;

p=(structstudent*)malloc(…);//被goto跳过,没有初始化

⋯

state:

//使用p指向的内存里的值的代码

⋯

如果编译器不能发觉此类错误，每用一次goto 语句都可能留下隐患。

1.10，void关键字

void有什么好讲的呢？如果你认为没有，那就没有；但如果你认为有，那就真的有。有点像“色即是空，空即是色”。

1.10.1，void a？

void的字面意思是“空类型”，void*则为“空类型指针”，void*可以指向任何类型的数据。void几乎只有“注释”和限制程序的作用，因为从来没有人会定义一个void变量，看看下面的例子：

voida;

VisualC++6.0上，这行语句编译时会出错，提示“illegaluseoftype'void'”。不过，即使voida的编译不会出错，它也没有任何实际意义。

void真正发挥的作用在于：

（1）对函数返回的限定；

（2）对函数参数的限定。

众所周知，如果指针p1和p2的类型相同，那么我们可以直接在p1和p2间互相赋值；如果p1和p2指向不同的数据类型，则必须使用强制类型转换运算符把赋值运算符右边的指针类型转换为左边指针的类型。

例如：

float *p1;

int *p2;

p1=p2;

其中p1=p2语句会编译出错，提示“'=':cannotconvertfrom'int*'to'float*'”，必须改为：

p1=(float*)p2;

而void*则不同，任何类型的指针都可以直接赋值给它，无需进行强制类型转换：

void *p1;

int *p2;

p1=p2;

但这并不意味着，void*也可以无需强制类型转换地赋给其它类型的指针。因为“空类型”可以包容“有类型”，而“有类型”则不能包容“空类型”。比如，我们可以说“男人和女人都是人”，但不能说“人是男人”或者“人是女人”。下面的语句编译出错：

void *p1;

int *p2;

p2=p1;

提示“'=':cannotconvertfrom'void*'to'int*'”。

1.10.2，void修饰函数返回值和参数

【规则1-33】如果函数没有返回值，那么应声明为void类型

在C语言中，凡不加返回值类型限定的函数，就会被编译器作为返回整型值处理。但是许多程序员却误以为其为void类型。例如：

add(inta,intb)

{

return a+b;

}

intmain(intargc,char*argv[])//甚至很多人以为main函数无返回值

//或是为void型的

{

printf("2+3=%d",add(2,3));

}

程序运行的结果为输出： 2+3=5

这说明不加返回值说明的函数的确为int函数。

因此，为了避免混乱，我们在编写C程序时，对于任何函数都必须一个不漏地指定其类型。如果函数没有返回值，一定要声明为void类型。这既是程序良好可读性的需要，也是编程规范性的要求。另外，加上void类型声明后，也可以发挥代码的“自注释”作用。所谓的代码的“自注释”即代码能自己注释自己。

【规则1-34】如果函数无参数,那么应声明其参数为void

在C++语言中声明一个这样的函数：

intfunction(void)

{

return1;

}

则进行下面的调用是不合法的：function(2);

因为在C++中，函数参数为void的意思是这个函数不接受任何参数。

但是在TurboC2.0中编译：

#include"stdio.h"

fun()

{

return1;

}

main()

{

printf("%d",fun(2));

getchar();

}

编译正确且输出1，这说明，在C语言中，可以给无参数的函数传送任意类型的参数，但是在C++编译器中编译同样的代码则会出错。在C++中，不能向无参数的函数传送任何参数，出错提示“'fun':functiondoesnottake1parameters”。

所以，无论在C还是C++中，若函数不接受任何参数，一定要指明参数为void。1.10.3，void指针

【规则1-35】千万小心又小心使用void指针类型。

按照ANSI(AmericanNationalStandardsInstitute)标准，不能对void指针进行算法操作，即下列操作都是不合法的：

void*pvoid;

pvoid++;//ANSI：错误

pvoid+=1;//ANSI：错误

ANSI标准之所以这样认定，是因为它坚持：进行算法操作的指针必须是确定知道其指向数据类型大小的。也就是说必须知道内存目的地址的确切值。

例如：

int*pint;

pint++;//ANSI：正确

但是大名鼎鼎的GNU(GNU'sNotUnix的递归缩写)则不这么认定，它指定void*的算法操作与char*一致。因此下列语句在GNU编译器中皆正确：

pvoid++;//GNU：正确

pvoid+=1;//GNU：正确

在实际的程序设计中，为符合ANSI标准，并提高程序的可移植性，我们可以这样编写实现同样功能的代码：

void*pvoid;

(char*)pvoid++;//ANSI：正确；GNU：正确

(char*)pvoid+=1;//ANSI：错误；GNU：正确

GNU和ANSI还有一些区别，总体而言，GNU较ANSI更“开放”，提供了对更多语法的支持。但是我们在真实设计时，还是应该尽可能地符合ANSI标准。

【规则1-36】如果函数的参数可以是任意类型指针，那么应声明其参数为void*。

典型的如内存操作函数memcpy和memset的函数原型分别为：

void*memcpy(void*dest,constvoid*src,size_tlen);

void*memset(void*buffer,intc,size_tnum);

这样，任何类型的指针都可以传入memcpy和memset中，这也真实地体现了内存操作函数的意义，因为它操作的对象仅仅是一片内存，而不论这片内存是什么类型。如果memcpy和memset的参数类型不是void*，而是char*，那才叫真的奇怪了！这样的memcpy和memset明显不是一个“纯粹的，脱离低级趣味的”函数！

下面的代码执行正确：

例子：memset接受任意类型指针

intIntArray_a[100];

memset(IntArray_a,0,100*sizeof(int));//将IntArray_a清0

例子：memcpy接受任意类型指针

intdestIntArray_a[100],srcintarray_a[100];

//将srcintarray_a拷贝给destIntArray_a

memcpy(destIntArray_a,srcintarray_a,100*sizeof(int));

有趣的是，memcpy和memset函数返回的也是void*类型，标准库函数的编写者都不是一般人。

1.10.4，void不能代表一个真实的变量

【规则1-37】void不能代表一个真实的变量。

因为定义变量时必须分配内存空间，定义void类型变量，编译器到底分配多大的内存呢。

下面代码都企图让void代表一个真实的变量，因此都是错误的代码：

voida;//错误

function(voida);//错误

void体现了一种抽象，这个世界上的变量都是“有类型”的，譬如一个人不是男人就是女人（人妖不算）。

void的出现只是为了一种抽象的需要，如果你正确地理解了面向对象中“抽象基类”的概念，也很容易理解void数据类型。正如不能给抽象基类定义一个实例，我们也不能定义一个void（让我们类比的称void为“抽象数据类型”）变量。

void简单吧？到底是“色”还是“空”呢？

1.10，return关键字

return用来终止一个函数并返回其后面跟着的值。

return（Val）；//此括号可以省略。但一般不省略，尤其在返回一个表达式的值时。

return可以返回些什么东西呢？看下面例子：

char*Func(void)

{

charstr[30];

…

returnstr;

}

str属于局部变量，位于栈内存中，在Func 结束的时候被释放，所以返回str 将导致错误。【规则1-38】return语句不可返回指向“栈内存”的“指针”，因为该内存在函数体结束时被自动销毁。

1.11，const关键字也许该被替换为readolny

const是constant的缩写，是恒定不变的意思，也翻译为常量、常数等。很不幸，正是因为这一点，很多人都认为被const修饰的值是常量。这是不精确的，精确的说应该是只读的变量，其值在编译时不能被使用，因为编译器在编译时不知道其存储的内容。或许当初这个关键字应该被替换为readonly。那么这个关键字有什么用处和意义呢？

const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。我们看看它与define宏的区别。（很多人误以为define是关键字，在这里我提醒你再回到本章前面看看32个关键字里是否有define）。

1.11.1，const修饰的只读变量

定义const只读变量，具有不可变性。

例如：

constintMax=100;

intArray[Max];

这里请在VisualC++6.0里分别创建.c文件和.cpp文件测试一下。你会发现在.c文件中，编译器会提示出错，而在.cpp文件中则顺利运行。为什么呢？我们知道定义一个数组必须指定其元素的个数。这也从侧面证实在C语言中，const修饰的Max仍然是变量，只不过是只读属性罢了；而在C++里，扩展了const的含义，这里就不讨论了。

注意：const修饰的只读变量必须在定义的同时初始化，想想为什么？

留一个问题：case语句后面是否可以是const修饰的只读变量呢？请动手测试一下。1.11.2，节省空间，避免不必要的内存分配，同时提高效率

编译器通常不为普通const只读变量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的值，没有了存储与读内存的操作，使得它的效率也很高。例如：

#defineM3 //宏常量

constintN=5; //此时并未将N放入内存中

......

inti=N; //此时为N分配内存，以后不再分配！

intI=M; //预编译期间进行宏替换，分配内存

intj=N; //没有内存分配

intJ=M; //再进行宏替换，又一次分配内存！

const定义的只读变量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的只读变量在程序运行过程中只有一份拷贝（因为它是全局的只读变量，存放在静态区），而#define定义的宏常量在内存中有若干个拷贝。#define宏是在预编译阶段进行替换，而const修饰的只读变量是在编译的时候确定其值。#define宏没有类型，而const修饰的只读变量具有特定的类型。

1.11.3，修饰一般变量

一般常量是指简单类型的只读变量。这种只读变量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。例如：

int const i=2; 或 const int i=2;

1.11.4，修饰数组

定义或说明一个只读数组可采用如下格式：

intconsta[5]={1,2,3,4,5};或

constinta[5]={1,2,3,4,5};

1.11.5，修饰指针

constint*p; //p可变，p指向的对象不可变

intconst*p; //p可变，p指向的对象不可变

int*constp; //p不可变，p指向的对象可变

constint*constp;//指针p和p指向的对象都不可变

在平时的授课中发现学生很难记住这几种情况。这里给出一个记忆和理解的方法：

先忽略类型名（编译器解析的时候也是忽略类型名），我们看const离哪个近。“近水楼台先得月”，离谁近就修饰谁。

constint*p; //const修饰*p,p是指针，*p是指针指向的对象，不可变

intconst*p; //const修饰*p,p是指针，*p是指针指向的对象，不可变

int*constp; //const修饰p，p不可变，p指向的对象可变

constint*constp;//前一个const修饰*p,后一个const修饰p，指针p和p指向的对象

都不可变

1.11.6，修饰函数的参数

const修饰符也可以修饰函数的参数，当不希望这个参数值被函数体内意外改变时使

用。例如：

voidFun(constinti);

告诉编译器i在函数体中的不能改变，从而防止了使用者的一些无意的或错误的修改。1.11.7，修饰函数的返回值

const修饰符也可以修饰函数的返回值，返回值不可被改变。例如：

constintFun(void);

在另一连接文件中引用const只读变量：

externconstinti; //正确的声明

externconstintj=10;//错误！只读变量的值不能改变。

注意这里是声明不是定义，关于声明和定义的区别，请看本章开始处。

讲了这么多讲完了吗？远没有。在C++里，对const做了进一步的扩展，还有很多知识未能讲完。有兴趣的话，不妨查找相关资料研究研究。

1.12，最易变的关键字----volatile

volatile是易变的、不稳定的意思。很多人根本就没见过这个关键字，不知道它的存在。也有很多程序员知道它的存在，但从来没用过它。我对它有种“杨家有女初长成,养在深闺人未识” 的感觉。

volatile关键字和const一样是一种类型修饰符，用它修饰的变量表示可以被某些编译器未知的因素更改，比如操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。先看看下面的例子：

inti=10;

intj=i；//(1)语句

intk=i；//(2)语句

这时候编译器对代码进行优化，因为在（1）、（2）两条语句中，i没有被用作左值。这时候编译器认为i的值没有发生改变，所以在（1）语句时从内存中取出i的值赋给j之后，这个值并没有被丢掉，而是在（2）语句时继续用这个值给k赋值。编译器不会生成出汇编代码重新从内存里取i的值，这样提高了效率。但要注意：（1）、（2）语句之间i没有被用作左值才行。

再看另一个例子：

volatile inti=10;

intj=i；//(3)语句

intk=i；//(4)语句

volatile关键字告诉编译器 i是随时可能发生变化的，每次使用它的时候必须从内存中取出i的值，因而编译器生成的汇编代码会重新从i的地址处读取数据放在k中。

这样看来，如果i是一个寄存器变量或者表示一个端口数据或者是多个线程的共享数据，就容易出错，所以说volatile可以保证对特殊地址的稳定访问。

但是注意：在VC++6.0中，一般Debug模式没有进行代码优化，所以这个关键字的作用有可能看不出来。你可以同时生成Debug版和Release版的程序做个测试。

留一个问题：constvolatileinti=10；这行代码有没有问题？如果没有，那i到底是什么属性？

1.13，最会带帽子的关键字----extern

extern，外面的、外来的意思。那它有什么作用呢？举个例子：假设你在大街上看到一个黑皮肤绿眼睛红头发的美女（外星人？）或者帅哥。你的第一反应就是这人不是国产的。extern就相当于他们的这些区别于中国人的特性。extern可以置于变量或者函数前，以标示变量或者函数的定义在别的文件中，下面的代码用到的这些变量或函数是外来的，不是本文件定义的，提示编译器遇到此变量和函数时在其他模块中寻找其定义。就好比在本文件中给这些外来的变量或函数带了顶帽子，告诉本文件中所有代码，这些家伙不是土著。那你想想extern修饰的变量或函数是定义还是声明？

看列子：

A.c文件中定义： B.c文件中用extern修饰：

inti=10； externinti；//写成i=10；行吗？

voidfun（void） externvoidfun（void）；//两个void可否省略？

{

//code

}

C.h文件中定义： D.c文件中用extern修饰：

int j =1; externdoublej；//这样行吗？为什么？

int k =2; j=3.0；//这样行吗？为什么？

至于extern“C”的用法，一般认为属于C++的范畴，这里就先不讨论。当然关于extern的讨论还远没有结束，在指针与数组那一章，你还会和它亲密接触的。

留个问题：