写在前面

最近再次温习C语言深度剖析，对C语言的一些易错的和重要的知识点做了以下整理。

第一章 关键字

一 register

1 关键字请求编译器尽可能将变量存在CPU内部的寄存器内中，避免存入聂功通过寻址访问来提高效率。

2 变量类型必须是CPU寄存器可以接受的类型，即必须是一个单个的值，其长度小于或者等于整型的长度。

3 不能用&来获取register变量的地址（因为是存在了寄存器而不是内存中）。

二 static

1 修饰变量，变量存在内存的静态区。当修饰全局变量时，表示变量只能在被定义的文件中使用，其他文件即时使用extern也不能使用。修饰局部变量时，表示只能在函数里使用。跳出函数后值并不销毁。

2 修饰函数，不表示存储方式是静态的，而是针对函数作用域，表示作用域仅局限于本文件。在C++中，static有第3个作用：类中的静态数据成员，可以实现多个对象间的数据共享。静态数据成员需要相应的静态成员函数访问。

三 sizeof

1 sizeof是关键字而不是函数。在计算变量所占空间大小时括号可以省略，而计算类型大小时不可以省略。

2 sizeof是在编译时求值（在C99中，计算柔性数组所占空间大小是其是运行时求值）。sizeof操作符里面不要有其他运算，否则不会达到预期的目的。

四 signed和unsigned关键字

先看一段程序，考虑其输出结果。

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

输出为255。答对了吗？答对了可以跳过下面的分析。

首先介绍一下计算机信息表示的几个易混淆的概念：原码、反码、补码。原码是符号位加上真值的绝对值，即第一位表示符号，其余表示值；反码规定，正数的反码是本身，负数的反码是在其原码的基础上，符号位不变，其余位各个取反。补码是计算机系统中数值的表示方法，正数的补码与原码一致，即也与反码一致，负数的补码是其反码加1.用补码可以将符号位和其他位统一处理，减法按加法处理。两个用补码表示的数相加时，如果最高位（符号位）有进位，则进位被舍弃。

下面来介绍有符号数和无符号数之间的转换。在C语言中，对有符号数和无符号数之间的强制转换，保持不变的是位模式。由此可以把有符号数和无符号数之间的变换，看成有符号数的补码表示和无符号数之间的转换。

下图是补码到无符号数之间的转换示意图：

用公式表示即为：

下图是无符号数到补码之间的转换示意图：

用公式表示即为：

回归到题目，strlen函数是计算字符串长度的，遇到'\0'即认为字符串的结束（长度值不包括最后的'\0'）。则题目可转换为计算从a[0]到a[n]之间的长度，其中n为第一个a[n]位模式为0的位置。-1,-2..到多少的位模式会为0？根据补码到无符号数之间的转换公式，可以得到-256的位模式为0。则长度为255。

另外，无符号数的表示范围为$0-2^{w}$，有符号数为$-2^{w-1}-2^{w-1}-1$。$w$为类型的bit数。可以看到，有符号数的正数表示范围比负数少1，是因为-0和+0，人为规定+0视为0，-0视为$-2^{w-1}$。

五 if和else的组合

1 bool变量与“零值”比较，写成if(flag)或if(!flag)最好。

2 float与“零值”进行比较，使用if(val>=-EPSINON&&val<=EPSINON)，EPSIONO为定义好的精度。

3 说到浮点数，还要注意不要在很大的浮点数和很小的浮点数之间进行运算，如：

#include <stdio.h>
int main()
{
    double i = 1000000000.00;
    double j = 0.00000000001;
    printf("%.15f",i+j);
    return 0;
}

输出：1000000000.000000000000000，会有截断。为什么？涉及到浮点数在计算机里的表示。

float：1bit（符号位） 8bits（指数位） 23bits（尾数位）

double：1bit（符号位） 11bits（指数位） 52bits（尾数位）

精度由尾数的位数决定。比如，对于float，$\log_{10}{2^{23}}=6.923689900271567$，则其精度最多有7位有效数字，但绝对能保证的为6位，也即float的精度为6~7位有效数字；对于double类似，精度为15~16位。题目中，i+j的有效位数为21位，超过了double的最高有效位数，则会产生截断。

4 指针变量与“零值”比较，使用if(NULL==p)和if(NULL!=p)。

六 switch和case

1 分支比较多的话使用switch和case会提高效率。

2 每个case后不要忘了break。

3 case后面只能是整型或字符型的常量或常量表达式（不可以是字符串）。

七 const

1 在ANSI C标准中（不适用于C++），const精确来说应该是只读变量而不是常量，其值在编译时不能被使用，编译器在编译时不知道其存储的内容。所以case后也不可以跟const修饰的只读变量。

2 修饰指针

const int *p; //常量指针，p可变，p指向的对象不可变
int const *p; //常量指针，p可变，p指向的对象不可变
int *const p; //常指针，p不可变，指向的对象可以变
const int* const p;//指针p和其指向的内容都不可以变

记忆方法：忽略类型名，看const离谁近就修饰谁。

八 volatile

1 修饰的变量表示可以被某些编译器未知的因素更改，不然操作系统、硬件或者其他线程。 2 volatile int i=10，volatile告诉编译器，i是随时可能发生更改的，每次使用时必须从内存中取出i的值。保证对特殊地址的稳定访问。

九 struct关键字

1 空结构体大小为1字节。

2 柔性数组。C99中，结构中的最后一个元素允许是未知大小的数组，即柔性数组成员，但其前必须有至少一个其他成员。sizeof返回的结构大小不包括柔性数组的内存。

十 union关键字

1 union中的所有数据成员共用一个空间，同一时间只能存储一个数据成员，所有的成员有相同的起始地址。

2 union默认属性为public，大小为最大程度的数据成员的空间。

3 利用union来确定当前系统的存储模式（大小端）。

首先看什么是大小端模式，大端模式表示字数据的高字节存储在低地址，而字数据的低字节存储在高地址；小短模式表示字数据的高字节存储在高地址，而字数据的低字节存储在低地址。 比如，一个存在地址0x100处的int型的变量x的16进制表示为0x01234567，则其大小端的表示为：

则利用union可以很快的写出检测大小端模式的程序：

int check_system()
{
    union check
    {
        int i;
        char ch;
    }c;

    c.i=1;
    return (c.ch==1);//ture为小端模式，false为大端模式。
}

留一个问题，在x86系统下，以下程序的输出值为多少

#include <stdio.h>
int main(void)
{
    int a[5] = {1,2,3,4,5};
    int *ptr1 = (int *)(&a + 1);
    int *ptr2 = (int *)((int)a + 1);
    printf("%x,%x\n",ptr1[-1],*ptr2);
    return 0;
}

正确答案是5,2000000。为什么？详细分析可转到后文中的第四章。

十一 enum关键字

1 一般的定义方法如下：

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_CONST_*如果不赋值，会从被赋值的那个常量开始加1，默认的第一个常量值为0.

2 枚举在编译时确定值，define在预编译确定。

十二 typedef

1 用于给一个已经存在的数据类型取一个别名。看例子：

typedef struct student
{
    //Code
}Stu_st,*Stu_pst;

以上代码表示给struct student{}取了个别名叫Stu_st，给struct student{}* 取了个别名叫Stu_pst。

第二章 符号

一 注释符号

1 编译器处理注释时不是简单的剔除，而是用空格取代。

2 "/"和"*"之间如果没有空格，都会被当做注释的开始。可以y=x/ *p或者y=x/(*p)，但不可以y=x/*p。

3 C语言里反斜杠"\"表示断行，编译器会将反斜杠剔除掉，跟在反斜杠后面的字符自动接续到前一行。但要注意，反斜杠之后不能有空格，反斜杠的下一行也不能有空格。

二 位运算符

1 按位异或可以实现不用第三个临时变量来交换两个变量的值:a^=b;b^=a;a^=b;但不推荐这样做，不易读。

2 如果位操作符"~"和"<<"应用于基本类型无符号字符型或无符号短整型的操作数，结果会立即转换成操作数的基本类型。

uint8_t port = 0x5aU;
unit8_t result_8;
unit16_t result_16;

result_8 = (~port) >> 4; //不能得到期待的0xa5
result_8 = ((uint8_t)(~port))>>4; //正确的写法
result_16=((uint16_t)(~(uint16_t)port))>>4; //正确的写法

3 位运算符不能用于基本类型是有符号数的操作数上。

4 一元减运算符不能用在基本类型为无符号的表达式上。将一元减运算符用在unsigned int 或 unsigned long 的表达式上会分别产生类型为 unsigned int 或 unsigned long的结果，是无意义的操作。

unsigned int a = 12;
unsigned int b = -a;
int c=-a; // U2T

cout<<a<<endl; //12
cout<<b<<endl; //4294967284,及-12+2^32
cout<<c<<endl; //-12
cout<<(b==c)<<endl; //1

5 左移，右移运算符。左移时，高位丢弃，地位补0；右移时，低位丢弃，符号位随同移动（一般正数补0，负数补什么取决于编译系统的规定）。左移和右移的位数不能大于和等于数据长度，不能小于0（取决于编译器支持与否）；

三 ++和--操作符

1 后缀的++，--是在本计算单位计算结束后再自加或自减。

int i=1;
int k=(i++)+(i++)+(i++); //3 

2 贪心法则。C语言有这样一个规则：每一个符号应该包含尽可能多的字符。

int a = 3, b = 1;
int c=a+++b;
cout<<a<<" "<<b<<" "<<c<<endl; // 4 1 4

四 除法运算符

1 假定q=a/b，r=a%b，先假定b>0，则由整数除法和余数操作应具备的相知有：

• q*b+r==a。
• 如果改变a的正负号，希望q的正负号随着改变，但q的绝对值不变。
• 当b>0，希望保证r>=0且r<b。

但上述三条不能同时成立（如-3/2），C语言或其他语言在实现整数除法截断运算时，必须放弃其中一条，大多编程语言了最后一条。

2 由上述规定，有2/(-2)=-1, 2%(-2)=0, 3/(-2)=-1, 3%(-2)=1, (-3)/2=-1, (-3)%2=-1。

五 运算符的优先级

1 运算符的优先级顺序如下。

记忆技巧：

① 伪运算符的优先级最高，单目运算符优先级总是高于双目；

② 对于双目运算符而言，算术运算>位运算>逻辑运算；

③ 自右向左结合的运算符只有单目运算符和赋值运算符。

2 一些容易出错的优先级问题，见下表。

第三章 预处理

一 宏定义

1 注释先与预处理指令被处理，所以不可以用define宏定义注释符号。

2 C的宏只能扩展为用大括号括起来的初始化、常量、小括号括起来的表达式、类型限定符、存储类标识符或do-while-zero。

3 在定义函数宏时，每个参数实例都应该以小括号括起来，除非他们做为#（字符串化操作符）或##（粘合剂）的操作数。

4 注意宏定义中的空格。

#define SUM (x) (x)+(x) //错误
#define SUM(x) (x)+(x) //正确写法

二 一些其他预处理

1 遇到#error后会生成一个编译错误提示消息并停止编译,#error error-message。

2 #pragma comment，将一个诸世纪路放入一个对象文件或可执行文件中。

#pragma comment(lib,"user32.lib") //将user32.lib库放入到本工程

3 #pragma pack，用于内存对齐。

首先介绍下什么是内存对齐，看一个例子：

struct TestStruct
{
    char c1;
    short s;
    char c2;
    int i;
};

求上述结构体所占字节数。由于内存对齐的存在，使得答案不是8（1 11 1 1111）而是12（1x 11 1xxx 1111），1代表使用内存，x代表空内存。

什么时候会产生内存对齐？一个字（2个字节）或者双字（4个字节）跨越了4字节边界，或者1个四字（8个字节）跨越了8字节边界，被认为是未对齐的，从而需要两次总线来访问内存。一个字起始地址是奇数但是没有跨越字边界被认为是对齐的。缺省条件下编译器会将结构、栈中的成员函数进行内存对齐。

接下来来看下#pragma pack的使用方法。使用它可以改变编译器默认的内存对齐方式。

#pragma pack(n) //告诉编译器按n字节对齐
#pragma pack() //取消自定义字节对齐方式
#pragma pack(push) //保存当前对齐方式到packing stack
#pragma pack(push,n) //等效于#pragma pack(push);#pragma pack(n);
#pragma pack(pop) //packing stack出栈，并将对齐方式设置为出栈的对齐方式

看一个例子

#pragma pack(8)
struct TestStruct1
{
    char a;
    long b; //假定所用编译器long为4字节
};

struct TestStruct2
{
    char c;
    TestStruct1 d;
    long long e; //假定所用编译器long为8字节
};
#pragma pack()

求sizeof(TestStruct1)和sizeof(TestStruct2)。直接放上答案：8,24。具体内存布局为：TestStruct1（1xxx(a) 1111(b)）,TestStruct2（1xxx(c) 1xxx(d.a) 1111(d.b) xxxx 11111111(e)）。为什么？

① 每个成员按照其类型的对齐参数（通常是其大小）和指定对齐参数（上例中n=8）中较小的一个对齐，并且结构的长度必须为所用过的所有对齐参数的整数倍，不够就补空；

② 复杂类型（如结构体）的默认对齐方式是它最长的成员的对齐方式；

③ 对齐后的长度必须是成员中最大的对齐参数的整数倍。

第四章 指针和数组

指针

1 int *p=NULL 和 int *p; *p=NULL的区别。前者是表示把p的值设置为0x00000000，后者是把*p的值设置为0x00000000（即p指向的地址设为0x00000000）。

2 将数值存储到指定的内存地址。比如往内存地址0x12ff7c上存储一个整型数0x100。

int *p = (int *)0x12ff7c;
*p = 0x100;

//或者这样写
*(int *)0x12ff7c = 0x100;

数组和指针

1 &a和a的区别。看一个例子：

int a[5]={1,2,3,4,5};
int *ptr=(int *)(&a +1);
printf("%d, %d",*(a+1),*(ptr-1))

分析：&a+1表示区取数组a的首地址，该地址的值加上sizeof(a)的值，即：&a+5*sizeof(int); *(a+1)，虽然a和&a的值是一样的，但a表示数组首元素的首地址，(a+1)的地址为&a[0]+1*sizeof(int)，即a[1]的地址。所以上例中输出为2,5。用类似的分析，第一章第九小结中留的问题应该可以解决了吧？

2 不可以定义为数组，声明为指针。例如，文件1中定义char a[100]; 文件2中声明 extern char *a;这样的话， 编译文件2是编译器会认为a是一个指针变量，占四字节。会取a[0]~a[4]四个字节去寻址。

3 不可以定义为指针声明为数组。例如文件1中定义 char *p="abcdefg"; 文件2中声明 extern char p[]; 这样编译文件2是编译器会认为p是一个数组，会把直接读p的地址，并不会通过p间接寻到"abcdefg"的实际地址。

指针数组和数组指针

看下例，指出哪个是数组指针，哪个是指针数组：

int *p1[10];
int (*p2)[10];

分析：[]的优先级高于*，p1表示指针数组（存放指针的数组）；p2表示数组指针（指向一个包含10个int类型数据的数组）。

多维数组和多级指针

1 看例题，计算打印的结果：

int a[3][2]={(0,1),(2,3),(4,5)};
int *p;
p=a[0];
printf("%d",p[0]);

答案是1，答对了吗？分析：注意初始化的时候错把大括号用成了小括号，赋值相当于了a[3][2]={1,3,5}。初始化注意写法。

2 看一个面试经常遇到的例子：

int a[5][5];
int *(p)[4];
p=a;

问：&p[4][2]-&a[4][2]的值。问题不难，答案是-4，答错的可以结合下面内存布局图仔细理解下。

数组参数和指针参数

1 一级指针参数无法把指针变量本身传递给一个函数，可以用return或者二级指针参数来实现。看例子：

void GetMemory(char* p, int num)
{
    p=(char *)malloc(num*sizeof(char));
}

char *str=NULL
GetMomory(str,10); //str本身并没有改变，还是指向NULL

通过return实现：

char* GetMemory(char* p, int num)
{
    p=(char *)malloc(num*sizeof(char));
    return p;
}

通过二级指针：

void GetMemory(char** p, int num)
{
    *p=(char *)malloc(num*sizeof(char));
}

char *str=NULL;
GetMemory(&str,10); //OK

函数指针

1 一个函数指针长的样子： char* (*fun)(char* p1, char* p2)。

2 *(int *)&p是个什么鬼。看例子：

void Function()
{
    printf("Call Function! \n");
}

int main()
{
    void (*p)();
    *(int*)&p=(int)Function;
    *(p)();
    return 0;
}

分析：p是一个函数指针变量，*(int*)&p=(int)Function表示将函数Function的入口地址赋值给指针变量p。

3 函数指针数组，长这个样子：char* (*pf[3])(char *p)。使用时可以直接 pf[0]=fun;或者 pf[0]=&fun;

4 函数指针数组指针。读完后是不是想抓狂。其实没那么复杂，就是一个指针，指针指向一个数组，数组里存放的是指向函数的指针而已。 大概面貌：char* (*(*pf)[3])(char* p)。结合下面的例子会更好的理解。

char* fun1(char* p)
{
    printf("%s\n",p);
    return p;
}

char* fun2(char* p)
{
    printf("%s\n",p);
    return p;
}

char* fun3(char* p)
{
    printf("%s\n",p);
    return p;
}

int main()
{
    char* (*a[3])(char* p); //函数指针数组
    char* (*(*pf)[3])(char* p); //函数指针数组指针
    pf=&a;
    a[0]=fun1;
    a[1]=fun2;
    a[2]=fun3;

    pf[0][0]("fun1"); //也可以用(*pf)[0]("fun1");
    pf[0][1]("fun2"); //也可以用(*pf)[1]("fun2");
    pf[0][2]("fun3"); //也可以用(*pf)[2]("fun3");

    return 0;
}

第五章 内存泄露

没涉及到多少易错点和重点。记得定义指针变量的同时最好初始化为NULL，用完后也置为NULL；访问提防越界；记得给结构体里的指针分配内存；分配的内存记得释放。

第六章 函数

没有什么需要特别注意的。

第七章 文件结构

1 需要对外公开的常量放在头文件中，不需要的放在源文件。

2 不要在头文件中定义对象或函数体。

第八章 关于面试的秘密

态度是一种习惯，习惯决定一切。

小结

C语言最难的部分是设计到指针的部分，还有很多易错的细节问题。本文中的整理的内容都弄明白后，你可以在简历上自信的写上能熟练掌握和运用C语言了。结合原书会更好的理解，文章意在作知识点回顾和速查之用。

参考文献

[1] C语言深度剖析. 第2版. 陈正冲

[2] 深入理解计算机系统.