---

前言

参考书籍大家可入群下载：
qq群：829876251
也欢迎热爱C语言的朋友们一起学习交流！！！

关键字

关键字	意义
auto	声明自动变量，缺省时编译器默认为auto
int	声明整型变量
double	声明双精度变量
long	声明长整型变量
char	声明字符型变量
float	声明浮点型变量
short	声明短整型变量
signed	声明有符号类型变量
unsigend	声明无符号类型变量
struct	声明结构体变量
union	声明联合数据类型
enum	声明枚举类型
static	声明静态变量
switch	用于开关语句
case	用于语句分支
default	开关语句中的“其他”分支
break	跳出当前循环
register	声明寄存器变量
const	声明只读变量
volatile	说明变量在程序执行中可被隐含地改变
typedef	用以给数据类型取别名（当然还有其他作用）
extern	声明变量是在其他文件正声明（也可以看作是引用变量）
return	子程序返回语句（可以带参数，可不带参数）
void	声明函数无返回值或无参数，声明空类型指针
continue	结束当前循环，开始下一轮循环
do	循环语句的循环体
while	循环语句的循环条件
if	条件语句
else	条件语句否地暖管分支（与if连用）
for	一种循环语句（可意不可言传）
goto	无条件跳转语句
sizeof	计算对象所占内存空间大小

注：C语言关键字目前为止一共是32个、sizeof是关键字

定义和声明，你懂了吗？

int i;
extern int i;

定义：所谓定义就是（编译器）创建一个对象，为这个对象分配一块内存并给它取上一个名字，这个名字就是我们经常所说的变量名或对象名。但注意，这个名字一旦和这块内存匹配起来（可以想象是这个名字嫁给了这块空间，并且不要彩礼），它们就同生共死，终生不离不弃。并且这块内存位置也不能改变。一个变量或对象在一定区域内（比如函数，全局等）只能被定义一次，如果定义多次，编译器会提示你重复定义同一个变量或对象。

声明：有两重含义，如下：

1. 告诉编译器，这个名字已经匹配到一块内存上了（伊人已嫁，吾将何去何从？何以解忧，唯有稀粥），下面的代码用到变量或独享是在别的地方定义的。声明可以出现多次。

2. 告诉编译器，我这个名字我先预定了，别的地方再也不能用它来作为变量名或对象名。比如你在图书馆自习室的某个座位上放了一本书，表明这个座位已经有人预定，别人再也不允许使用这个座位。其实这个时候你本人并没有在这个作为上。这种声明最典型的例子就是函数参数的声明，例如：void fun(int i, char c);

最宽宏大量关键字——auto

auto：它很宽宏大量的，你就当它不存在吧。编译器默认的缺省情况下，所有变量都是auto的。

最快的关键字——register

register：这个关键字请求编译器尽可能的将变量存在CPU内部寄存器中而不是通过内存寻址访问以提高效率。注意是尽可能，不是绝对。你想想，一个CPU的寄存器也就那么几个或几十个，你要是定义了很多很多register变量，它累死也可能不能全部把这些变量放入寄存器，就算要放也轮不到你。

最名不副实的关键字——static

不要误以为关键字static'很安静，其实它一点也不安静。这个关键字在C语言里主要有两个作用，C++对它进行了扩展。

修饰变量

第一个作用：修饰变量。变量又分为局部和全局变量，但他们都存在内存的静态区。

静态全局变量：作用域仅限于变量被定义的文件中，其他文件即使使用extern声明也没法使用他。准确地说作用域是从定义之处开始，到文件结尾处结束，在定义之处前面的那些代码也不能使用它。想要使用就得在前面再加extern，所以一般会采取在文件顶端定义。

静态局部变量：在函数体里面定义的，就只能在这个函数里用了，同一个文档中其他函数也用不了。由于被static修饰的变量总是存在内存的静态区，所以即使这个函数运行结束，这个静态变量的值还是不会被销毁，函数下次使用时仍然能用到这个值。

修饰函数

第二个作用：修饰函数。函数前加static使得函数成为静态函数。但此处static的含义不是指存储方式，而是指对函数的作用域仅局限于本文件（所以又称内部函数）。使用内部函数的好处是：不同人编写不同函数时，不用担心自定定义的函数，是否会与其他文件中的函数同名。

关键字static有者不同寻常的历史。起初，在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。随后static在C中有了第二种含义：用不来表示不能被其他文件访问的全局变量和函数。为了避免引入新的关键字，所以仍使用static关键字来表示这第二种含义。

当然，C++里对static赋予了第三种作用，这里先不讨论。

基本数据类型——short、int、long、char、flaot、double

变量命名规则

• 命名应当直观且可以拼读，可望文知意，便于记忆和阅读
• 命名长度应当符合“min-length & max-information”原则
• 当标识符由多个词组成时，每个词的第一个字母大写，其余部分小写。
• 尽量避免名字中出现数字编号，如Value1，Value2等，除非逻辑上的确需要编号。比如驱动开发时关键命名，非编号名字反而不好。
• 对在多个文件之间共同使用的全局变量或函数要加范围限定符（建议使用模块名（缩写）作为范围限定符）
• 标识符分为两部分：规范标识符前缀（后缀）+含义标识。非全局变量可以不使用范围限定符前缀。
  
• 程序中不得出现仅靠大小写区分的相似的标识符
• 所用宏定义、枚举常量、只读变量全用大写字母命名，用下划线分割单词
• 考虑到习惯问题，局部变量中可采用通用的命名方式，仅限于n、i、j等作为循环变量使用
• 定义变量的同时千万别忘了初始化。定义变量时编译器并不一定清空了这块内存，它的值可能是无效的数据
• 不同类型数据之间的运算要注意精度扩展问题，一般低精度数据向高精度数据扩展

最冤枉的关键字——sizeof

常年被人误认为函数

sizeof是关键字不是函数，其实就算不知道它是否为32个关键字之一时，我们也可以借助编译器确定它的身份。看下面的例子：

int i=0;
A)sizeof(int); B)sizeof(i); C)sizeof int; D) sizeof i;

答案都是4。

注意这里说明的时sizeof不需要括号也能运行，无论是32位还是64位int类型都是4个字节，sizeof int这个方式是错误的

sizeof(int) *p表示什么意思？

留几个问题（讲解指针与数组时会详细讲解），32位系统下：

int *p=NULL;
//sizeof(p)的值是多少？
//sizeof(*p)呢？
int a[100];
//sizeof(a)的值是多少？
//sizeof(a[100])呢？
//sizeof(&a)呢？
//sizeof(&a[0])呢？

int b[100];
void fun(int b[100])
{
    sizeof(b);//sizeof(b)的值是多少？
}

备注：sizeof(int) *p这是一个错误的表达方式，编译器无法识别。

signed、unsigned关键字

我们知道计算机底层只认识0、1.任何数据到了底层都会被转换成0、1。那负数怎么存储呢？肯定这个-号是无法存入内存的，怎么办？很好办，做个标记。把基本数据类型的最高位腾出来，用来存符号，同时约定如下：最高位如果是1，表明这个数是负数，其值位除最高位以外的剩余位的值添上这个-号；如果最高位是0，表明这个数是正数，其值为除最高位以外的剩余位的值。

考虑下面一个问题

int main()
{
    char a[1000];
    int i;
    for(i=0;i<1000;i++)
    {
        a[i]=-1-i;
    }
    printf("%d",strlen(a));
    return 0;
}

此踢看上去真的很简单，但是却鲜有人答对。答案是255.别惊讶，我们先分析分析。

for循环内，当i的值位0时，a[0]的值为-1.关键就是-1在内存里面如何存储。

我们都知道在计算机系统中，数值一律采用补码来表示（存储）。主要原因是使用补码，可以将符号位和其他位同一处理；同时，减法也可以按加法来处理。另外，两个用补码表示的数相机时，如果高位（符号位）有进位，则进位被舍弃。正数的补码与源码一致；负数的补码，符号位为1.其余为为该数绝对值的原码按位取反，然后整数加1。

按照负数补码的规则，可以知道-1的补码为0xff，-2的补码是0xfe…当i的值为127时，a[127]的值为-128。而-128是char类型数据能表示的最小的负数。当i继续增加，a[128]的值肯定不能是-129.因为这时候发生了溢出，-129需要9位才能存储下来，而char类型数据只有8位，所以最高位被丢弃，剩下的8位为原来9位补码中的低8位的值，即0x7f。当i继续增加到255时，-256的补码的低8位为0.然后当i增加到256时，-257的补码的低8位为全1，即低8位的补码位0xff，如此又开始新一轮循环。

按照上面分析，a[0]到a[254]里面的值都不为0，而a[255]的值为0.strlen函数时计算字符串长度的，并不包含字符串最后的\0。而判断一个字符串是否结束的标志就是看是否遇到\0。如果遇到\0，则认为本字符串结束。

留三个问题：

1. 按照上面我们的解释，那么-0和+0在内存里面分别怎么存储？

2. 都是0x00

3. int i=-20;unsigned j=10;i+j的值为多少，为什么?

4. 答案是-10，因为换算出来就是-10.并未溢出。

5. 下面的代码有什么问题?

unsigned i;
for(i=9;i>=0;i--)
{
    printf("%u\n",i);
}

死循环，无符号数肯定大于等于0.

if、else组合

bool变量与“零值”进行比较

bool变量与“零值”进行比较的if语句怎么写？

bool bTestFlag = FALSE; //想想为什么一般初始化为FALSE比较好？
A) if(bTestFlag == 0);
B) if(bTestFlag == 1);
C) if(bTestFlag);
D) if(!bTestFlag);

那一组或是那些租正确呢？我们来分析分析

A：写法：bTestFlag是什么？整型变量？如果要不是前面这个名字遵照了前面的命名规范，恐怕很容易让人误会成整形变量。所以这种写法不好。

B:写法：FLASG的值大家都知道，在编译器里被定义为0；TRUE值则为非0，因此直接定为1是不妥当的。

C和D是值得推荐的

float变量与“零值”进行比较

float变量与“零值”进行比较的if语句怎么写？

float fTestVal =0.0
A) if(fTestVal == 0.0); if(fTestVal != 0.0);
B) if((fTestVal >= -EPSINON) && (fTestVal <= -EPSINON));//EPSIONON为定义好的精度

那一组正确呢？我们来分析分析

float和double类型的数据都是有精度限制的，这样直接拿来与0.0比，能正确吗？明显不能，看例子：Π的值四舍五入精确到小数点后10位为：3.1415926536，你拿它去减0.00000000000001然后再四舍五入得到的结果是多少呢？你能说前后两个值一样吗？

EPSINON为定义好的精度，如果一个数落在[0.0-EPSIONON,0.0+EPSINON]这个区间内，我们认为在某个精度内它的值与零值相等；否则不等，扩展一下，把0.0替换为你想比较的任何一个浮点数，那我们就可以比较任意两个浮点数的大小了，当然是在某个精度内。

同样的也不要在很大的浮点数和很小的浮点数之间进行运算，否则计算结果会让你大吃一惊。

指针变量与“零值”进行比较

指针变量与“零值”进行比较的if语句怎么写？

int *p = NULL;//定义指针一定要同时初始化，指针与数组章节会详细讲解
A)if(p == 0); if(p != 0);
B) if(p); if(!p);
C) if(NULL == p) ; if(NULL != p);

那一组或那些组正确呢？我们来分析分析；

A）写法：类型不匹配，容易引起误会，虽然NULL的值和0一样，但是意义不同。

B）写法：p不是bool型变量，容易引起误会，不好

C）正确。推荐

else到底与那个if配对呢？

C语言规定：else始终与同一括号内最近的未匹配的if语句结合。

【建议1-16】程序中的分界符‘{’和‘}’对齐风格如下：

注意下表中代码的缩进一般为4个字符，但是不要使用tab键，因为不同的编辑器tab键定义的空格数量不一样，别的编辑器打开Tab键缩进的代码可能会一片混乱。

if语句后面的分号

关于if-else语句还有一个容易出错的地方就是与空语句的连用。看下面的例子：

if(NULL != p);
    fun();

这里的fun()函数并不是在NULL ！= p的时候被调用，而是任何时候都会被调用。问题就出现在if语句后面的分号上。在C语言中，分号预示着一条语句的结尾，但是并不是每条C语言语句都需要分号作为结束标志。if语句的后面并不需要分号，但如果你不小心写了分号，编译器并不会提示出错。因为整个编译器会把这个分号解析成一条空语句。

使用if语句的其他注意事项

【规则1-17】先处理正常情况，再处理异常情况。

【规则1-18】确保if和else子句没有弄反

switch、case组合

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

那既然你有了菜刀为什么还需要水果刀呢？

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

swicth(variable)
{
    case Value1:
        //program code
        break;
    case Value2:
        //program code
        break;
    case Vaule3:
        //program
        break;
    ...
    default:
        break;
}

很简单，但有两个规则：

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

【规则1-20】最后必须使用default分支，即使程序真的不需要default处理，也应该保留语句default: break;这并非画蛇添足，可以避免让人误以为你忘了default处理。

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

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

为什么呢?

因为字符型，布尔型，枚举型都可以转换成整型来表示，而整型的相等判断是可以确定的，相反浮点型因为精度的问题无法有相等的确定性。

case语句的排列顺序

遵循下面的规则：

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

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

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

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

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

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

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

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

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

do、while、for关键字

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

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

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

while(1)
{
    if('#' == GetInputChar())
    {
        break;
    }
}

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循环可以很容易的控制循环次数，多用于事先知道循环次数的情况下。

问题：在switch case语句中能否使用continue关键字？为什么？

不能，因为continue只能在循环语句中使用。

循环语句的注意点

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

例如：

【建议1-28】建议for循环的循环控制变量的取值采用“半开半区间”写法。

半开半闭区间写法和闭区间写法虽然功能相同，但是相比之下，半开半闭区间写法更加直观。

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

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

不要超过20行

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

goto关键字

一般来说，编码的水平与goto语句使用的次数成反比。有的人主张慎用但不禁用goto语句，但我主张禁用。

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

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

struct student *p = NULL
...
goto state;
p=(struct student *)malloc(...);//被goto跳过，没有初始化
...
state:
//使用p指向内存里的值的代码
...

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

void关键字

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

void a？

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

void真正发挥的作用在于：

1. 对函数返回的限定；

2. 对函数参数的限定。

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

float *p1;
int *p2;
p1=p2;

其中p1=p2语句会编译出错，提示'=':cannot convert from 'int*' to 'float*' ,必须修改为：p1=(float*)p2;

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

void *p1;
int *p2;
p1=p2;

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

void *p1;
int *p2;
p2=p1;

提示'=':cannnot convert 'void*' to 'int*'。

void修饰函数返回值和参数

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

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

add(int a, int b)
{
    return a+b;
}
int main(int argc, char* argv[])//甚至很多人以为main函数无返回值
{
    printf("2+3=%d\n",add(2,3));
}

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

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

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

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

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

int function(void)
{
    return 1;
}

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

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

但是在Turbo C 2.0中编译：

#include"stdio.h"
fun()
{
    return 1;
}
main()
{
    printf("%d",fun(2));
    getchar();
}

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

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

void指针

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

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

void* pvoid;
pvoid++;//ANSI:错误
pvoid+=1;//ANSI:错误

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

例如：

int *pint;
pint++;//ANSI:正确

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

pvoid++;//GNU:正确
pvoid+=1;//GNU:正确

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

void *pvoid;
(char *)pvoid++;//ANSI:true;GNU:true
(char *)pvoid+=1;//ANSI:false;GNU:true

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

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

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

void *memcpy(void *dest, void *src, size_t len);
void *memset(void *buffer, int c, size_t num);

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

下面的代码执行正确：

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

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

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

int destInArray_a[100],srcIntArray_a[100];
//将srcIntArray_a拷贝给destIntArray_a
memcpy(destIntArray_a,srcIntArray_a,100*sizeof(int));

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

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

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

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

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

void a;//错误
function(void a);//错误

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

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

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

return关键字

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

return(Val);此括号可以省略。但是一般不省略，尤其在返回一个表达式的值时。

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

char *Func(void)
{
    char str[30];
    ...
    return str;
}

str属于局部变量，位于栈中，在Func结束的时候被释放，返回str将导致错误。

【规则1-38】return语句不可返回指向“栈内存”的“指针”，因为该内存在函数体结束时被自动销毁。

留个问题：

return ;

这个语句有问题吗？如果没有问题，那返回的是什么？

没有问题，返回的是函数体被调用至栈空间后PC指针指向的地址。

const关键字也许被替换为readonly

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

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

const修饰的只读变量

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

例如：

const int Max=100;
int Array[Max];

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

备注：C99以后的版本已经支持只读变量作为数组指定长度的标识符了。

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

定义的时候它的内存空间被限定死了。

留一个问题：case语句后面是否可以是const修饰的只读变量呢？请动手试一试。

不能。

提示错误

error: case label does not reduce to an integer constant

节省空间，避免不必要的内存分配，同时提高效率

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

#define M 3 //宏常量
const int N=5; //此时并未将N放入内存中
...
int i=N; //此时为N分配内存，以后不再分配
int I=M; //与扁你期间进行宏替换，分配内存
int j=N; //没有内存分配
int J=M; //再次进行宏替换，又一次分配内存

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

修饰一般变量

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

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

修饰数组

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

int const a[5]={1,2,3,4,5};
const int a[5]={1,2,3,4,5};

修饰指针

const int *p; //p是可变的，但是p指向的对象是不可变
int const *p; //p可变，p指向的对象不可变
int * const p; //p不可变，p指向的对象可变
const int * const p;//p不可变，p指向的对象也不可变

先忽略类型名（编译器解析的时候也是忽略类型名），我们看const离那个近，离谁近就修饰谁。

修饰函数的参数

const修饰符也可以修饰函数参数，当不希望这个参数值被函数体意外改变时使用。例如：

void Fun(const int i);

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

修饰函数的返回值

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

const int Fun(void);

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

extern const int i; //正确
extern const int j=10; //错误！只读变量的值不能改变

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

最易变的关键字——volatile

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

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

先看看下面的例子：

int i=10;
int j=i;//(1)语句
int k=i;//(2)语句

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

再看另一个例子：

volatile int i=10;
int j=i;//3
int k=i;//4

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

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

留一个问题：

const volatile int i=10;这样代码有没有问题？如果有，那么到底是什么属性？

答：没有问题

"const"含义是“请作为常量使用”，而并非“放心吧，那肯定是个常量”
"volatile"的含义是“请不要做没谱的优化，这个值可能改变”，而并非“你可以修改这个值”

最会带帽子的关键字——extern

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

答：声明

当然关于extern的讨论还没结束，在指针于数组那一章，我们还会继续分析。

struct关键字

struct是个神奇的关键字，他将一些相关联的数据打包成一个整体，方便使用。

在网络协议、通信控制、嵌入式系统、驱动开发等地方，我们经常要传送的不是简单的字节流（char型数组），而是多种数据组合起来的一个整体，其表现形式是一个结构体。经验不足的开发人员往往将所有需要传送的内容依顺序保存在char型数组中，通过指针偏移的方法传送网络报文等信息。这样做编程复杂，易出错，而且一旦控制方式以及通信协议有所变化，程序就要进行非常细致的修改，非常容易出错。这个时候只需要一个结构体就能搞定。平时我们要求函数的参数尽量不要超过四个，如果函数的参数多余4个使用起来非常容易出错（包括每个参数的意义和顺序都容易弄错），效率也会降低（与具体CPU相关，ARM芯片对于超过4个参数的处理就有讲究，具体参考相关资料）。这个时候，可以用结构体压缩参数个数。

空结构体多大？

结构体所占的内存空间大小是其成员所占内存之和（关于结构体的内存对齐，请参考预处理部分）。这点很容易理解，但是下面的这种情况呢？

struct student
{

}stu;

sizeof(stu)的值是多少呢？不同标准不一样，Linux gcc是0。（C99标准规定不允许有空结构体）

很遗憾，不是0，而是1。为什么呢？你想一想，如果我们把struct student看成一个模子的话，你能造出一个没有任何容积的模子呢？显然不行，编译器也是认为如此。编译器认为任何一种数据类型都有其大小，用它来定义一个变量能够分配确定大小的空间。既然如此，编译器就理所应当的认为任何一个结构体都是有大小的，哪怕这个结构体为空。编译器认为你构造一个结构体数据类型是用来打包一些数据成员的，而最小的数据成员需要1byte，编译器为每个接哦古提类型数据至少预留1个byte的空间，所以，空结构体的大小就定位为1个byte。

柔性数组

C99中，结构体的最后一个元素允许是未知大小的数组，者就叫做柔性数组成员，但结构中的柔性数组成员前面必须至少一个其他成员。柔性数组成员允许结构体中包含一个大小可变的数组。sizeof返回的这种结构大小不包括柔性数组的内存。包含柔性数组成员的结构可用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

柔性数组到底如何使用呢？看下面的例子：

typedef struct st_type
{
    int i;
    int a[0];
}type_a;

有些编译器会报错无法编译可以改成：

typedef struct st_type
{
    int i;
    int a[];
}type_a

这样我们就可以定义一个可变长的结构体，用sizeof(type_a)得到的只有4个字节，就是sizeof(i)=sizeof(int)。那个0个元素的数组没有占用空间，而后我们可以进行变长操作了。通过如下表达式给结构体分配内存：

type_a *p=(type_a *)malloc(sizeof(type_a)+100*sizeof(int));

这样我们为结构体指针p分配了一块内存。用p->item[n]就能简单的访问可变长元素。但是这时候我们再用sizeof(*p)测试结构体的大小，发现仍然是4，是不是很惊讶？我们不是给数组分配空间了吗？

别急，我们先回忆一下前面讲过的“模子”。在定义这个结构体的时候，模子的大小就已经确定不包含柔性数组的内存大小。柔性数组只是编外人员，不占结构体的编制。只是说在使用柔性数组时需要把它当作结构体的一个成员，仅此而已。再说白点，柔性数组其实与结构体没什么关系，只是“挂羊头卖狗肉”而已，算不得结构体的正式成员。

需要说明的是：C89不支持这种东西，C99把它作为一种特例加入了标准。但是C99所支持的是incompete type，而不是zero array，形同int item[0];这种形式是非法的，C99支持的形式是形同int item[];只不过有些编译器把int item[0]；作为非标准扩展来支持，而且在C99发布之前已经有了这种非标准扩展了，C99发布之后，有些编译器把两者合一了。

struct于class的区别

在C++里struct关键字与class关键字一般可以通用，只有一个很小的区别。struct的成员默认情况下属性是public的，而class成员确实private的。很多人觉得不好记，其实很容易。你平时使用结构体时用public修饰它的成员了吗？既然struct关键字与class关键字可以通用，你也不哟啊认为结构体内不能放函数了。

当然，关于结构体的讨论还没有结束，指针与数组一章会继续分析。

union关键字

unoin关键字用法与struct的用法非常类似。

union维护足够的空间来置放多个数据成员中的“一种”，而不是为每个数据成员配置空间。在union中所有的数据成员共占用一个空间，同一时间只能存储其中一个数据成员，所有的数据成员具有相同的起始地址。例子如下：

union StatMachine
{
    char character;
    int number;
    char *str;
    double exp;
};

一个union只配置一个足够大的空间来容纳最大长度的数据成员，以上例而言，最大长度是double形态，所以StateMachine的空间大小就是double数据类型的大小。

在C++里，union的成员默认属性页为public。union主要用来压缩空间。如果一些数据不可能在同一时间被用到，则可以使用union。

大小端模式对union类型数据的影响

下面再看一个例子：

union
{
    int i;
    char a[2];   
}*p,u;
p->a[0]=0x39;
p->a[1]=0x38;

p.i的值应该为多少呢？

这里需要考虑存储模式：大端模式与小端模式。

大端模式：字数据的高字节存储在低地址中，而字数据的低字节则存放在高地址中。

小端模式：字数据的高字节存储在高地址中，而字数据的低字节存放在低地址中。

union型数据所占的空间等于其最大的成员所占的空间。对union型的成员的存取都是相对于该联合体基地址的偏移量为0处开始，也就是联合体的访问不论对那个变量的存取都是从union的首地址位置开始。如此一解释，上面的问题是否已经有了答案呢？

如何用程序确认当前系统的存储模式？

上述问题似乎还比较简单，那来个有技术含量的：请写一个C函数，若处理器是大端的，则返回0；若是小端的，则返回1。

先分析一下，按照上面关于大小端模式的定义，假设int类型变量i被初始化为1.

以大端模式存储，其内存布局如下图：

以小端模式存储，其内存布局图如下:

变量i占4个字节，但只有一个字节的值为1，另外三个字节的值都为0.如果取出低地址上的值为0，毫无疑问，这是大端模式；如果取出低地址上的值为1，毫无疑问，这是小端地址。既然如此，我们可以完全利用union类型数据的特点：所有成员起始地址一致。到现在，应该知道怎么写了吧？参考答案如下：

int chechSystem()
{
    union check
    {
        int i;
        char ch;
    }c;
    c.i=1;
    return (c.ch==1);
}

留个问题，

下面的代码输出的值为多少？

5，2

enum关键字

很多初学者对枚举(enum)感到迷惑，或者认为没什么用，其实枚举(enum)是个很有用的数据类型

枚举类型的使用方法

一般的定义方式如下：

enum enum_type_name
{
    ENUM_CONST_1,
    ENUM_CONST_2,
    ....
    ENUM_CONST_n
}enum_variable_name;

注意：enum_type_name是自定义的一种数据类型名，而enum_variable_name为enum_type_name类型的一个变量，也就是我们平时常说的枚举变量。实际上enum_type_name类型是对一个变量取值范围的限定，而花括号内是它的取值范围，即enum_type_name类型的变量enum_variable_name只能取值为花括号内的任何一个值，如果赋给该类型变量的值不在列表中，则会报错或者警告。ENUM_CONST_1, ENUM_CONST_2,ENUM_CONST_n这些值都是常量，也就是我们平时所说的枚举常量（常量一般用大写）。enum变量类型还可以给其中的常量符号赋值，如果不赋值则会从被赋初值的那个常量开始依次加1，如果都没有赋值，他们的值从0开始依次递增。如分别用一个常数表示不同颜色：

枚举与#define宏的区别

下面再看看枚举与#define宏的区别：

1. #define宏常量是在预处理阶段进行简单替换。枚举常量则是在编译的时候确定其值。

2. 一般在编译器里，可以调试枚举常量，但是不能调试宏常量。

3. 枚举可以一次定义大量相关的常量，而#define宏一次只能定义一个。

留两个问题：

1. 枚举能做到的事，#define能不能都做到？如果能，那为什么还需要枚举？

2. sizeof(ColorVal)的值为多少？为什么？

答：

1. 一方面枚举可以集中管理数据，具有相同属性的整型数据可以使用枚举存放；另外枚举可以实现取值自增，编写代码容易，较少出错的机会，后续维护时如果需要新增一个信息无需计算该信息取值。

2. 枚举的大小是按照enum中元素最大值所占的内存大小来决定的，不像结构体那样有多个元素就按各个元素所占字节叠加。

3. 当枚举成员的值小于4个字节时，占4个字节

4. 当枚举成员的值大于4个字节时，最大只能是longlong类型，占8个字节。

伟大的缝纫师——typedef关键字

历史的误会——也许应该是typerename

很多人认为typedef是定义新的数据类型，这可能与这个关键字有关。毕竟，type是数据类型的意思，def(ine)是定义的意思，合起来就是定义数据类型。不过很遗憾，这种理解是不正确的，也许这个关键字应该被替换为typerename或是别的词。

typedef的真正含义是给一个已经存在的数据类型取一个别名，而非定义一个新的数据类型。

在实际项目中，为了方便，可能很多数据类型（尤其是结构体之类的自定义数据类型）需要我们重新取一个适用实际情况的别名。这时候typedef就可以帮助我们。例如：

typedef struct student
{
    //code
}Stu_st, *Stu_pst;//命名规则请参考前面部分

好，下面再把typedef与const放在一起看看：

C）const Stu_pst stu3;
D) Stu_pst const stu4;

大多数初学者认为C里const修饰的是stu3指向的对象；D里const修饰的是stu4这个指针。很遗憾，C里const修饰的并不是stu3指向的对象。那const这时候到底修饰的是什么呢？我们在讲解const int i的时候说过const放在类型名int前后都可以；而const int *p与int * const p则完全不一样。也就是说，我们看const修饰非指针变量时完全可以将数据类型名视而不见，当它不存在。返回来再看const Stu_pst stu3，Stu_pst是struct student {//code}*的别名。对于编译器来说，只认为Stu_pst是一个类型名，所以再解析的时候很自然的把Stu_pst这个数据类型名忽略掉。

typedef与#define的区别

看下面的例子

E) #define INT32 int
unsigned INT32 i=10;

F) typedef int int32
unsigned int32 j=10;

F编译错误，E能正常被编译。

错误的原因是typedef取别名后不允许再进行修饰。

下面再看一个例子

G) #define PCHAR char*
PCHAR p3,p4;
H) typedef char* 

两组代码都没有问题，但是p4不是指针，仅仅是一个char类型的字符。这种错误很容易被忽略，所以使用#define的时候要慎之又慎。