C语言知识点总结(正式版)

第一篇：C语言知识点总结(正式版)

C语言知识点总结

C语言知识点总结............................................................................................................1一、二、三、四、五、六、七、八、常量....................................................................................................................2 标识符.................................................................................................................2 变量....................................................................................................................2 表达式.................................................................................................................3 输入输出函数......................................................................................................4 C语言的语句.......................................................................................................5 C程序的基本结构................................................................................................5 选择结构语句......................................................................................................5  if(表达式)语句1 else 语句2.............................................................................5  条件运算符 表达式1? 表达式2 : 表达式3.......................................................6  switch语句........................................................................................................6

九、循环结构.............................................................................................................6  for循环语句......................................................................................................6  while循环语句 do while循环语句.....................................................................6

十、数组....................................................................................................................7

十一、字符串函数..........................................................................................................7

十二、函数....................................................................................................................8

十三、指针....................................................................................................................9

十四、宏定义...............................................................................................................10

十五、结构体，共用体，枚举类型...............................................................................10

十六、Turbo C的使用..................................................................................................12 1

一、常量

 数字常量

i.普通数字：1，35，2.7 ii.指数形式：2.45e-2等价于2.45*10-2 注意e大小写皆可，e前面的数字不能省，就算是1也不能省，后面的数字一定要是整数

iii.长整型，单精度浮点型：3235L，32.5F 分别表示3235是长整型数据，32.5是单精度浮点型左，若不写上L，F则表示3235是整型，32.5是双精度浮点型，L，F大小写皆可

 字符常量

i.普通字符常量：用单引号把一个字符括起来，如‟A‟,‟@‟

ii.转义字符常量：一对单引号括起来并以“”开头的字符序列，如‟n‟(回车)、‟123‟(8进制123对应的字符), ‟x23‟(16进制23对应的字符) 字符串常量

用一对双引号把一个字符序列括起来，如“ABCef”，系统存放字符串常量，每个字符分配一个字节，各字符所占字节紧邻，并且字符串末尾会给再开一个字节里面放一个’’做为结束标志。

 符号常量

定义格式 #define 符号常量名 符号常量值，如#define N 20则定义了符号常量N，其值为20，注意符号常量名和符号常量值之间是用空格隔开，而不是写上=号，#define和符号常量名之间也有空格的。

二、标识符

 命名规则

以数字，字母，下划线这三类字符组成，但只能以字母或下划线开头，而不能也数字开头，另外不能将关键字做为标识符。32个关键字表在P365附录B  变量名，函数名，符号常量名全都是标识符

三、变量

 变量的定义格式

类型名 变量名;如 int a;定义了一个整型常量a。变量名是由人类随便定义的，符合命名规则的前提下，爱写啥就写啥。所以什么flag，cc，y1或者函数名fun,find等全部是自定的用来做为名字而已，没有更特别的意义。

 类型名

int 整型，long 长整型： 用于存放整数，只是数值范围不同

float 单精度浮点型 double 双精度浮点型：用于存放实数，数值范围，精度不同

char字符型：用于存放字符

 变量赋值，初始化

int a=3;定义的同时初始化 a=6*9;定义后在程序中进行赋值

 变量的值 只有在赋值操作时才会被改变，即将其放在等号左边时才会改变它的值，或自增自减操作：a=5,a++,a--，像a+3并未改变a的值，只是使用了a的值而已. 自增自减运算

变量++,++变量，变量--，--变量

使变量的值自增1或自减1 等价于 变量=变量+1 变量=变量-1 ++，--放于变量前后效果的区别：

当自增自减运算做为表达式的一部分时，++，--放在变量前面是先自增自减再使用变量的值，放在变量后面则是先使用变量的值，再自增自减。如x=3;printf(“%d”,++x);则相当于执行了++x;printf(“%d”,x);这样的操作所以打印出4 再如x=3;printf(“%d”,x++);则相当于执行了printf(“%d”,x);x++;这样的操作，则打印出3，当然最后x的值还是4。

四、表达式

 运算符和运算对象

一个运算符都有若干个运算对象，如 + 必然要跟两个运算对象才能进行加法运算：3+5。C语言里称需要跟n个运算对象的运算符为n元运算符。一元运算符有：!，（类型名）

二元运算符有：+,-,*,/,%(求余), =,+=，-=，*=，/=,%=,< , > , <=, >=, = =(等于),!=(不等于)，&&(且), ||(或)多元运算符有：， 运算符的优先级和结合性

i.优先级：同一个运算对象左右两边若同时有两个运算符，则这两个运算符优先级高的先进行运算。

ii.结合性：若同一个运算对象左右两边的两个运算符优先级相同，则根据结合性判断先进行哪个运算，自左自右结合性的先算左边的运算符，自右自左的先算右边的运算符。

iii.各运算符的优先级和结合性见P365附录C  强制类型转换

格式：(类型名)表达式。将后跟的表达式的值的数据类型转换为与圆括号内的类型名一致的类型。注意类型名一定要用（）括起来。

 算术表达式

i.算术运算符：+,-,*,/,%(求余)ii.由算术运算符加上运算对象构成算术表达式,如3+3*6-9/2 iii.值：跟我们小学时学的一样，就是表达式的计算结果 iv.整数除以整数结果取整数部分，故1/3得到的值是0 v.5%3 结果为2，想想小学除法，求余得到的是余数不是商。 赋值表达式

i.赋值运算符：=，+=，-=，*=，/=,%= ii.赋值表达式：变量=表达式，如x=3+6，x+=6-9，x+=x*=3+4 注意等号左边只能是变量

iii.复合赋值运算符的运算：以/=为例：x/=表达式 等价于 x=x/(表达式)iv.值：=号左边的变量最终的值  关系表达式

i.关系运算符：< , > , <=, >=, = =(等于),!=(不等于)ii.由关系运算符加上运算对象构成关系表达式,如3>=4, 2==a iii.值：满足相应运算符所指定的关系的值为1，否则为0  逻辑表达式

i.逻辑运算符：&&(且), ||(或),!(非)ii.由逻辑运算符加上运算对象构成逻辑表达式,如3&&4, x||!y iii.值：满足相应运算符所指定的关系的值为1，否则为0 iv.进行 ||或 运算时，若||左边的表达式值为1，则不再对右边的表达式v.进行运算。进行 &&且 运算时，若&&左边的表达式值为0，则不再对右边的表达式进行运算。 逗号表达式

i.逗号运算符：，ii.用逗号将各种表达式连续起来构成逗号表达式，如3+4,a=9,8*a iii.值：组成逗号表达式的各个表达式中的最后一个的值，如上例为8*a  题目：P7—11~17 P8—18~33

五、输入输出函数

 scanf(“格式控制串”，变量地址表列);如scanf(“%d%c%d”,&a,&ch,&b);

scanf(“%4f”,&x);注意：

i.格式控制串可控制截取用户输入的前几个字符给变量，但不能控制输入几位小数给变量，如不能写成scanf(“%4.2f”,&x);ii.第二个参数给的是地址，即要么是&+变量名或数组元素名的形式，要么就是一个数组名或指针变量名，如int *p,a;p=&a;scanf(“%d”,p);iii.考试时注意看题目给你写好的scanf的格式 1.若其格式控制串内各格式符用“，”隔开如scanf(“%d，%c，%d”,&a,&ch,&b);那输入时也要用逗号隔开，如此例输入时应：3,+,5 2.若是这种格式scanf(“%d %d”,&a,&b);则输入时应：3 5;3.若是这种格式scanf(“%d%c%d”,&a,&ch,&b);则输入时应3+5，若写成3 + 5则a=3,ch=‘ ’(空格)，b=任意值

(自己上机运行看看结果)

 printf(“格式控制串”，输出项表列);如float x=7.5;printf(“%8.2f”,x);此处的意思是将x打印出来，且占8列，保留两位小数。自己上机运行看看效果。

 常用格式符汇总：

i.%d：输入输出整型数据，%ld：输入输出长整型数据 ii.%c：输入输出字符型数据

iii.%f：输出单（双）精度浮点型数据，输入单精度型数据。

%lf：输入双精度型数据

iv.%s：输入输出一个字符串，用printf输出字符串时，输出项书写时可为字符串常量，或字符数组名。如printf(“%s”,”hello”);或char str[10]=”hello”;printf(“%s”,str);%u：输入输出无符号整型，%o：输入输出八进制数，%x:输入输出十六进制数

 getchar();函数调用后返回用户输入的一个字符，故需再定义一个变量来存放这个字符，即使用时应 char c;c=getchar()；意思就是接收用户输入的一个字符，并将其赋值给变量c。

 putchar(字符常量或字符变量名)；

如char c=‟A‟;putchar(c);或putchar(„A‟)；都会向屏幕输出字符A。v.六、C语言的语句

      表达式语句：由表达式末尾加上分号构成。

函数调用语句：由函数调用表达式加上分号构成。空语句： ；

选择结构语句：if语句 switch语句

循环语句：for语句 while语句 do while语句

复合语句：用花括号｛｝将以上任意语句括起来构成一条复合语句。

七、C程序的基本结构

void main(){

声明部分：用来定义变量和声明自定义函数的原型，需以“；”结尾，如int x;

执行语句部分：第六点里介绍的各种语句，如x=3；printf(“%d”,x);} main函数外可写自定义函数。如 int max(){

return 0;}

八、选择结构语句

 if(表达式)语句1 else 语句2

如果if语句的圆括号内的表达式值为非0，则执行语句1，值为0则执行语句2。

i.表达式可为任意表达式，if语句执行的实质是判断表达式的值是否为0来决定执行语句1还是语句2。另外请在此处表达严重关切，不管是高ii.手还是菜鸟经常会把判断两个数相等的符号“==”写成了一个等号“=”成为了赋值运算，这样的写法不会引发编译错误，但结果会与原意大大不同，所以考试前请再三提醒自己。

语句1和语句2都只能是一个语句，若要跟多条语句，切记用一对{}括起来，构成复合语句；也不要随便在圆括号后加“；”，因“ ；”构成一条空语句，这会使后面跟的语句1不再属于if语句的组成部分。if语句的三种结构

单边： if(表达式)语句

双边：if(表达式)语句1 else 语句2 多层(重点掌握)： iii.1.2.3.if(表达式1)语句1 else if(表达式2)语句2 else if(表达式3)语句3 …

else 语句n  条件运算符 表达式1? 表达式2 : 表达式3

若表达式1的值非0，则取表达式2的值做为整个表达式的值，否则取表达式3的值为整个表达式的值。如 3>4? 1:2 该表达式的值为2  switch语句

switch(表达式){ case 表达式1：语句

case 表达式2：语句

…

case 表达式n：语句

default: 语句 } 语句执行过程：先计算表达式的值，然后判断该值与表达式1到表达式n中的哪个相等，若与表达式i的值相等，则执行表达式i后的所有语句，当遇到break；语句时结束整个switch语句的执行。表达式1到表达式n的值都不相等的情况下执行default后跟的语句。每个case后可跟多条语句。

九、循环结构

 for循环语句

for(表达式1；表达式2；表达式3)循环体语句 语句执行过程： 1.计算表达式1 2.判断表达式2的值是否为0，若为0，语句执行结束，若不为0，进入步骤3 3.执行循环体语句（需注意的是循环体语句只能有一个语句，若要包含多个语句要用一对{}括起来，构成一条复合语句，此处也不要随便加上 “;”，因一个“；”可构成一条空语句，这会使得后面真正的循环体语句不属于for循环语句的部分）。进入步骤4 4.计算表达式3，然后重新进入步骤2  while循环语句 do while循环语句

i.while(表达式)循环体语句 执行过程：

1.判断表达式的值是否为非0，若是进入步骤2，否则结束语句执行。2.执行循环体语句，重新回到步骤1。ii.do 循环体语句

while(表达式)； 执行过程：

1.执行循环体语句，进入步骤2 2.判断表达式的值是否为非0，若是重新回到步骤1，否则结束语句执行。这里要注意的地方跟for语句一样，即循环体语句只能有一个语句，若要包含多个语句要用一对{}括起来，构成一条复合语句，此处也不要随便加上 “;”，因一个“；”可构成一条空语句，这会使得后面真正的循环体语句不属于while循环语句的部分，另外do while循环的while(表达式)后是要加“；”的。 break语句：放在循环体内实现的功能是结束其所在的那层循环的执行。

十、数组

 定义格式：数据类型

数组名[整型常量]；如 int a[10];定义了一个整型数组，数组名为a，这个数组含有10个元素。

 引用数组元素： 格式：数组名[下标]

切记下标值从0开始。下标可为常量，表达式，变量等，如int i=3； a[0]=5；a[3*2]=9； a[i]=7；

 初始化：数据类型

数组名[整型常量]={数据表列}；将数据表列的各个值依次赋值给数组的各个元素。如int a[5]={0,1,2,3,4}；则数组a各元素a[0]到a[4]的值分别为0，1，2，3，4  遍历数组元素

数组定义后，我们不能对数组进行整体的操作，如int a[10];不能用a=3这样的操作将数组的各元素都赋值为3；而只能一个一个元素的进行赋值，如a[0]=3;a[1]=3;a[2]=3…a[9]=3； 当然此时我们就可以借助于一个for循环来控制下标的变化从而对数组的各个元素进行赋值 for(i=0;i<10;i++)a[i]=3;

当然这只是用for循环遍历数组各元素的最简单的例子，一般考试考的是找出数组元素的某种特性的极值，比如最大值，最小值，或对数组各元素进行排序，这时我们就可以使用for循环来遍历数组的各元素，然后在当前循环中得到一个元素再对其进行处理。如i=2时访问到的元素是a[2]，你就可以问问它，你是不是最小值啊。 整型数组

int a[10];整型数组里的各个元素存放的是整数。a[3]=3; 字符型数组

char str[20]；字符型数组里的各个元素存放的是字符。

str[3]=‟A‟;

十一、字符串函数

 gets(字符数组名或字符指针变量)；

如char str[10],* str2;str2=str;则gets(str)；或gets(str2)；都是接收用户输入的字符串如“ABC”存入到字符数组str中

 puts(字符数组名或字符指针变量或字符串常量)；

如char str[10]=”china”;char *str2;str=str2;则puts(str);或puts(str2);或 puts(“china”);都会在屏幕上打印出 china  strlen(字符数组名或字符指针变量);字符串测长函数

char str[20]=”hello world!”;

int len;len=strlen(str);得出的结果是len的值为12  strcat(字符串1的地址，字符串2的地址)；

将字符串2的内容连接到字符串1的尾部。char str1[20]=”ABC”,str2[20]=”xyz”;strcat(str1,str2);

则程序运行的结果是str1内存放的字符串变为ABCxyz，当然str2存放的字符串还是xyz。

 strcmp(字符串1的地址，字符串2的地址)；

比较串1和串2哪个比较大。比较大小的依据是，两个字符串从左往右相应位置上第一个不相等的字符ASCII码值之差。char str1[20]=”ABCE”,str2[20]=”ABDE”;int i;i=strcmp(str1,str2);第一个不相等的字符为str1的‘C’和str2的‘D’，而二者相差-1，故-1做为strcmp函数执行的结果返回到被调用的位置，该位置位于赋值表达式内，故将其值赋值给i，即此时i的值就是-1. strcpy(字符串1的地址，字符串2的地址)；

将字符串2的内容复制到字符串1内。char str1[20]=”ABC”,str2[20]=”xyz”;strcpy(str1,str2);此时str1的内容为”xyz”，当然str2的内容没变 strcpy(str1,”uvw”);此时str1的内容又变成了“uvw“。

十二、函数

 函数定义

函数类型

函数名(形式参数列表){

内部变量定义和声明部分

执行语句

} 如：

int max(int x , int y){ int z;

z= x > y ? x : y;

return(z);} 注意点：

1.函数类型是指返回值的类型，即要与return语句后跟的表达式的值的类型一致。若函数类型为void则说明该函数无返回值，即函数体里不能出现return 语句。2.形式参数列表里定义的变量要记得给它们指定类型，而且如果同时要定义多个，应在每个前面都分别指定类型名，而不能写成int x,y;3.函数体里能写的语句跟main函数一样，在开头可定义所需要的变量，后面跟上一堆执行语句。 函数调用流程

以上面的函数为例，在main函数进行调用： void main(){ int a,b,c;scanf(“%d%d”,&a,&b);printf(“%d”,max(a,b));或 c=max(a,b);printf(“%d”,c)以上两种方法 都会在屏幕中打印出a，b间的较大值。

调用函数的格式 函数名(实际参数列表)；调用的时候像什么函数类型，形式参数的类型就不要加上去了。max(a,b)中max就是函数名，写上变量名a,b是实际参数列表，执行这个调用语句时，会先把a,b的值给相应位置的形式参数即执行了x=a,y=b这样的操作，然后开始执行max函数的函数体的语句。当max函数体里执行到一个return语句时，则max函数结束执行，将return后的表达式的值返回给main函数调用max函数的那个位置，即若上面a=3,b=5则max(a,b)return后的表达式的值应该是5也就是说执行完max后把5返回到调用max的位置可看成printf(“%d”，5)；或另一种解法的c=5。}

十三、指针

 指针变量的声明： 类型名 * 指针变量名；  通过指针变量访问它所指向的普通变量的值

先将普通变量的地址赋值给指针变量，再通过指针运算符* 得到普通变量的值。int *p,x,y;x=3;p=&x;则printf(“%d”,*p);会打印出3即x的值 y=*p；则y的值变为3 *p=5；则x的值变为5  指针变量加上（减去）一个位移的效果

若指针变量存入的是数组元素的地址，则其加一减一得到的是那个数组元素下一个或前一个元素的地址。int a[10];p=&a[3];*p得到的是a[3]的值。

若p++；此时p存放的是a[4]的地址&a[4];*p得到的就是a[4]的值。或p--；此时p存放的是a[2]的地址&a[2]，*p得到的就是a[2]的值。

 行指针

i.主要是对于二维数组来说的，二维数组每行都有自己的地址，第0行地址用 数组名 表示，第i行地址为 数组名+i；而想要得到二维数组里一个元素的地址，必需先得到其所在行的地址，然后再由那个地址得到元素的地址，比如说 int a[3][4]；定义了一个二维数组，该二维数组第0行的地址为a，第1行的地址为a+1，第2行的地址为a+2，想从行的地址得到元素的地址，需在行地址前加上指针运算符“*”，即*a就是第0行首个元素的地址即a[0][0]的地址，而a[0][2]的地址就是在a[0][0]的地址基础上加上位移量2，即*a+2，然后想得到a[0][2]这个元素的值呢就再加上一个指针运算符“*”，即*(*a+2)，类似地，想得到a[2][2]这个元素的值呢就是*(*(a+2)+2)ii.定义行指针变量： 类型名

（*变量名）[数组长度]；

如int(*p)[4],a[3][4];p=a;此时就可把p当成a来用，用法同上所述。

 判断是否合法访问数组元素：若是指针法访问，判断指针后跟的是否地址；若是下标法访问，判断下标有无越界。 函数指针：函数名即为函数的地址（指针）

i.函数指针变量的定义： 类型名(*变量名)(形参列表);如 int(*p)();ii.赋值：指针变量=函数名；设有个函数其函数名为max,则要将该函数的地址给p的话只要执行如下语句即可 p = max;

 指针数组：指针数组的数组元素都是指针变量，是用来存放变量的地址的，定义格式为 类型名 * 变量名[数组长度];如int * p[10]; 指向指针的指针：指针变量也是一种变量，故在内存中也有对应的一个地址，而要存放指针变量的地址，就要求助于用来存放指针变量的地址的指针变量，定义格式

类型名 ** 变量名；如 int *p1;int **p2;int a=3;可进行赋值p1=&a;p2=&p1;则a、*p1和 **p2的值都是3.十四、宏定义

 无参宏定义 #define 标识符

值

定义后，出现所定义的标识符的地方都将以定义时指定的值来代替。

#define M 2+3 main(){ int x;

x=M*M;则x的值为2+3*2+3=11若想得到的结果是(2+3)*(2+3)则定义时也写成这样 #define M(2+3)} 注意#define、标识符、值之间都要用空格隔开，且宏定义结尾不需加分号。 带参宏定义

#define 标识符(参数表)值

#define S(x,y)x*y main(){ int a=3,b=4,c=5,d=6;

printf(“a*b=%dn”, S(a,b));此时会打印出 a*b=12

printf(“a+b*c+d=%dn” , S(a+b,c+d));此时会打印出a+b*c+d=29，带参宏定义执行时是将a+b这样一个表达式代替x，c+d这样一个表达式代替y，所以S(a+b,c+d)进行的是a+b*c+d的运算，而不是将a+b的值给x，c+d的值给y然后再做x*y，这点跟函数调用传递参数是不一样的。}

 自定义类型名typedef：对已存在的类型名取一个外号。

i.基本格式：typedef 原类型名

新类型名;ii.typedef int INTEGER;则int a,b;等价于INTEGER a,b;iii.typedef int NUM[10];则 int a[10];等价于 NUM a;a即为一个有10个元素的数组的数组名。

iv.typedef int * INTEGER;则int *a,*b;等价于INTEGER a,b;

十五、结构体，共用体，枚举类型

 结构体

i.结构体类型的定义及变量的定义

struct 结构体名

{类型 成员1；

类型 成员2；

……

类型 成员n；

}变量名;如

struct student { long num;char name[10];int score[4];}st1;定义类型时同时定义变量

struct student st2;定义类型后，用类型名定义变量 还有一种 struct

{ long num;char name[10];int score[4];}st3;不给类型名，直接定义变量

ii.结构体变量所占字节数：各成员各占字节数之和，如以上st1,st2,st3的字节数皆为10+20+2*4=38 iii.结构体变量初始化：struct student a={20030001, “张三”, 70,75,80,85};iv.结构体数组定义及初始化：

struct student a[3]={{20030001,“zhang”,89,90,91,92}，{20030002,“liu”,68,69,70,71}，{20030003,“li”,57,58,59,60} };v.结构体变量成员的访问

1.结构体变量名.成员名 如st1.num 2.使用结构体类型的指针：

(*结构体指针名).成员

或

结构体指针名–>成员名 struct student *st;st=&st1;st->num 或(*st).num  共用体

i.共用体类型的定义及变量的定义

union 共用体名 { 类型

成员名1；

…

类型

成员名n；

}；

变量的定义与结构体类似，也有三种方法。union data {

int i;char ch;float f;}d1;定义类型时同时定义变量

union data d2;定义类型后，用类型名定义变量 union {

int i;char ch;float f;}d3;不给类型名，直接定义变量

ii.共用体变量所占字节数：各成员所占字节数的最大值,如上d1,d2,d3所占字节数皆为4.（单精度浮点型变量所占字节数最多为4）.iii.共用体变量成员的访问

1.共用体变量名.成员名 如d1.i 2.使用共用体类型的指针：

(*共用体指针名).成员

或

共用体指针名–>成员名 union data *dd;dd=&d1;dd->i 或(*dd).i iv.共用体成员的值：由于共用体各成员共用同一段内存区，故同一时刻只有一个成员的值是正确的。如d1.i=5;d1.ch=’a’;则此时d1.i的值就不是5了，而是其他值了，d1.ch的值是’a’

 枚举类型

i.枚举类型的定义：

enum 枚举名{枚举元素名1，枚举元素名2，…，枚举元素名n}； ii.枚举元素的值：

默认值分别为0、1、…、n-1。枚举元素的值也可在定义时重指定，对于没有指定值的元素，按顺序加1

如enum weekday{sun=7,mon=1,tue,wend,thur,fri,sat};则sun值为7，mon值为1，tue值为2，wend值为3，thur值为4，fri值为5，sat值为6

十六、Turbo C的使用

 菜单激活： F10

 菜单切换：左右方向键在不同菜单间切换，上下方向键在同一个菜单不同选项间切换。

 载入文件：两种方法：1.找到源文件所在位置，直接将其拉到Turbo C快捷方式上；2.F3  运行程序： ctrl+F9

 看程序运行结果：alt+F5  进入编辑状态：菜单Edit  保存： F2

 插入状态切换： Insert键

第二篇：C语言知识点总结

C语言知识点总结资料I 总体上必须清楚的：

程序结构是三种：顺序结构，循环结构(三个循环结构)，选择结构(if和switch)读程序都要从main()入口，然后从最上面顺序往下读(碰到循环做循环，碰到选择做选择)。

计算机的数据在电脑中保存是以二进制的形式。数据存放的位置就是它的地址。bit是位是指为0或者1。byte是指字节。一个字节=八个位。—定要记住二进制如何转换成十进制。概念常考到的：

1、编译预处理不是C语言的一部分，不占运行时间，不要加分号。C语言编译的程序称 为源程序，它以ASCII数值存放在文本文件中。

2、每个C语言程序中main函数是有且只有一个。

3、在函数定义中不可以再定义函数。

4、算法的是一定要有输出的，他可以没输入。

5、break可用于循环结构和switch语句。

6、逗号运算符的级别最低。

第3章

1）合法的用户标识符考查：

合法的要求是由字母，数字，下划线组成。有其它元素就错了。并且第一个必须为字母或则是下划线。第一个为数字就错了。

关键字不可以作为用户标识符号。main define scanf printf都不是关键字。迷惑你 的地方If是可以做为用户标识符。因为If中的第一个字母大写了，所以不是关键字。2）实型数据的合法形式：

2.333e-1就是合法的，且数据是2.333X10' 考试口诀：e前e后必有数，e后必为整数。3）字符数据的合法形式:：

'1'是字符占一个字节，“1”是字符串占两个字节(含有一个结束符号)。'0'的ASCII数值表示为48，'a'的ASCII数值是97，'A'的ASCII数值是65。一般考试表示单个字符错误的形式：' 65' 字符是可以进行算术运算的，记住：'0'-0=48 大写字母和小写字母转换的方法：' A'+32='a'相互之间一般是相差32。4）int型TC中是2个字节，VC中是4个字节。字符型是1个字节。5）转义字符的考查：

在程序中int a = 0x6d，是把一个十六进制的数给变量a注意这里的0x必须存在。在程序中int a = 06d 是一个八进制的形式。

在转义字符中，‟x6d‟才是合法的，0不能写，并且x是小写。‟141‟是合法的，0是不能写的。‟108‟是非法的，因为不可以出现8。6）强制类型转换：

一定是（int)a不是int(a)，注意类型上一定有括号的。

“1” 注意（int)(a+b)和(int)a+b的区别。前是把a+b转型，后是把a转型再加b。7）表达式的考查：

是表达式就一定有数值。

赋值表达式：表达式数值是最左边的数值，a=b=5;该表达式为5，常量不可以赋值。自加、自减表达式：假设a=5，++a(是为6)，a++(为5)；

运行的机理：++a是先把变量的数值加上1，然后把得到的数值放到变量a中，然后再用这 个++a表达式的数值为6，而a++是先用该表达式的数值为5，然后再把a的数值加上1为6，再放到变量a中。进行了++a和a++后在下面的程序中再用到a的话都是变量a中的6 了。

考试口诀：++在前先加后用，++在后先用后加。

逗号表达式：优先级别最低；表达式的数值逗号最右边的那个表达式的数值。(2，3，4)的表达式的数值就是4。

8）018的数值是非法的，八进制是没有8的，逢8进1。9）%符号两边要求是整数。不是整数就错了。10）三种取整丢小数的情况：

1、int

2、(int)a;3、1/2;3/2;11）字符型和整数是近亲： char a = 65;printf(“％c”, a);得到的输出结果：a prmtf(“％d”, a);得到的输出结果：65 12）printf函数的格式考查：

%d对应整型；％c对应字符；％f对应单精度等等。宽度的，左对齐等修饰。%ld 对应 long int;%lf 对应 double。13）scanf函数的格式考察：

注意该函数的第二个部分是&a这样的地址，不是a;scanf(“%d%d%*d%d”,&a,&b,&c);跳过输入的第三个数据。14）putchar ,getchar 函数的考查：

char a = getchar()是没有参数的，从键盘得到你输入的一个字符给变量a。putchar(„y‟)把字符y输出到屏幕中。

15）如何实现两个变量x，y中数值的互换（要求背下来）

不可以把x=y ,y=x;要用中间变量t=x;x=y； y=t。

16）如何实现保留三位小数，第四位四舍五入的程序，（要求背下来）

这个有推广的意义，注意x =(int)x这样是把小数部分去掉。

第4章

特别要注意：e语言中是用非0表示逻辑真的，用0表示逻辑假的。1）关系表达式：

表达式的数值只能为1(表示为真)，或0(表示假）

当关系的表达是为真的时候得到1。如9>8这个是真的，所以表达式的数值就是1;2）逻辑表达式： a =1.6;只能为1(表示为真)，或0(表示假）a)共有&& ||!三种逻辑运算符号。

b)!>&&>||优先的级别。

c)注意短路现象。考试比较喜欢考到。

d)要表示x是比0大，比10小的方法。0

else是与最接近的if且没有else的相组合的。4)条件表达式：

表达式1 ?表达式2 :表达式3 注意是当非0时候是表达式2的数值，当为0是就是表达式2的数值。考试口诀：真前假后。5）switch 语句：

a)—定要注意有break和没有break的差别，书上（34页）的两个例子，没有break 时候，只要有一个case匹配了，剩下的都要执行，有break则是直接跳出了 switch语句。b)switch只可以和break —起用，不可以和continue用。C)switch(x)x:是整型常量，字符型常量，枚举型数据。{case 1:....不可以是变量。case 2:...}

第5章

1）三种循环结构：

a)for()； while();do-while()三种。

b)for循环当中必须是两个分号，千万不要忘记。

c)写程序的时候一定要注意，循环一定要有结束的条件，否则成了死循环。

d)do-while()循环的最后一个while();的分号一定不能够丢。（当心上机改错），do—while 循环是至少执行一次循环。2)break 和 continue 的差别 记忆方法：

break:是打破的意思，（破了整个循环）所以看见break就退出真个一层循环。continue：是继续的意思，（继续循环运算)，但是要结束本次循环，就是循环体内剩下 的语句不再执行，跳到循环开始，然后判断循环条件，进行新一轮的循环。3)嵌套循环

就是有循环里面还有循环，这种比较复杂，要一层一层一步一步耐心的计算，一般记住 两层是处理二维数组的。

while((c=getchar())!=‟n‟)和 while(c=getchar()!=‟n‟）的差别 先看a = 3!= 2和(a=3)=2的区别：

(!=号的级别髙于=号所以第一个先计算3!=2)第一个a的数值是得到的1；第二个a的数值是3。考试注意点：括号在这里的重要性。

第6章

1）一维数组的重要概念： 对a[10]这个数组的讨论。

1、a表示数组名，是第一个元素的地址，也就是元素a[0]的地址。

2、a是地址常量，所以只要出现a++，或者是a=a+2赋值的都是错误的。

3、a是一维数组名，所以它是列指针，也就是说a+1是跳一列。对a[3][3]的讨论。

1、a表示数组名，是第一个元素的地址，也就是元素a[0]的地址。

2、a是地址常量，所以只要出现a++，或者是a=a+2赋值的都是错误的。

3、a是二维数组名，所以它是行指针，也就是说a+1是跳一行。

4、a[0]、a[1]、a[2]也都是地址常量，不可以对它进行赋值操作，同时它们都是列指针，a[0]+1，a[1]+1，a[2]+1 都是跳一列。

5、注意a和a[0]、a[1]、a[2]是不同的，它们的基类型是不同的。前者是一行元素，后 三者是一列元素。

2)两种重要的数组长度：

char a={„a‟,‟b‟,‟c‟};数组长度为3，字符串长度不定。sizeof(a)为3。char a[5]={ „a‟,‟b‟,‟c‟} 数组长度为 5，字符串长度 3。sizeof(a)为 5。3)scanf 和 gets 的数据

如果输入的是 good good study！那么scanf(“％s”,a);只会接收good.考点：不可以接收空格。gets(a);会接收good good study!考点：可以接收空格。

4)字符串的strlen()和strcat()和strcmp()和strcpy()的使用方法一定要记住。他 们的参数都是地址。其中strcat()和strcmp()有两个参数。5）二维数组做题目的技巧：

如果有 a[3][3]={1,2,3,4,5,6,7,8,9}这样的题目。步骤一：把他们写成: 第0列 第1列 第2列

a[0]—> 1 2 3 —> 第0行 a[1]—> 4 5 6 —> 第1行 a[2]—> 7 8 9 —> 第2行

步骤二：这样作题目间很简单：

*(a[0]+1)我们就知道是第一行的第一个元素往后面跳一列，那么这里就是a[0][1]元素，所以是1。

*(a[1]+2)我们就知道是第二行的第一个元素往后面跳二列。那么这里就是a[1][2]元素，所以是 6。

一定记住：只要是二维数组的题目，一定是写成如上的格式，再去做题目，这样会比较简单。6）数组的初始化，一维和二维的，一维可以不写，二维第二个一定要写 int a[]={1，2}合法。int a[][4]={2，3，4}合法。但 int a[4][]={2，3，4}非法。7）二维数组中的行指针 int a[1][2];其中a现在就是一个行指针，a+1跳一行数组元素。搭配(*)p[2]指针。

a[0]，a[1]现在就是一个列指针。a[0]+1跳一个数组元素。搭配*p[2]指针数组使用。8)还有记住脱帽子法则： a[2]变成 *(a+2)a[2][3]变成 *(a+2)[3]，再可以变成 *(*(a+2)+3)这个思想很重要！

第7章

函数：是具有一定功能的一个程序块；是c语言的基本组成单位。,/ 1）函数的参数，返回数值（示意图）：

2）—定要注意参数之间的传递

实参和形参之间传数值，和传地址的差别。(考试的重点）传数值的话，形参的变化不会改变实参的变化。传地址的话，形参的变化就会有可能改变实参的变化。3）函数声明的考查：

一定要有：函数名，函数的返回类型，函数的参数类型。不一定要有：形参的名称。4）要求掌握的库函数：

sqrt()fabs()pow()sin()其中 pow(a，b)是重点。23 是由 pow(2，3)表示的。5）“文件包含”的考查点: no1.c #include”no2.c” main(){ add(29, 33)}

no2.c int add(int a,int b){ return a+b;}

这里一个C语言程序是有两个文件组成，分别是no1.c，no2.c。那么no1.c中最开始有 个#include”no2.c‟‟他表示把第二个文件的内容给包含过来，那么no1.c中调用add()函数的时 候就可以了把数值传到no2.c中的被调用函数add()了。

一个文件必须要有main函数。这句话错了。例如：no2.c就没有。

头文件一定是以.h结束的。这句话错了。例如：no1.c中就是#mclude”no2.c”以.c结尾的。

第8章 1）指针变量的本质是用来放地址，而一般的变量是放数值的。2）int *p中 *p和p的差别：

*p可以当做变量来用；*的作用是取后面地址p里面的数值 p是当作地址来使用。

3）*p++和(*p)++的之间的差别——改错题目中很重要 *p++是地址会变化。

(*p)++是数值会要变化。(考试的重点）4）三名主义：

数组名：表示第一个元素的地址。|数组名不可以自加，他是地址常量名。（考了很多次)函数名：表示该函数的入口地址。字符串常量名：表示第一个字符的地址。5）考试重要的话语：

指针变量是存放地址的。并且指向哪个就等价哪个，所有出现*p的地方都可以用它等价的代替。

例如：int a=2，*p=&a； *p=*p+2;(由于*p指向变量a，所以指向哪个就等价哪个，这里*p等价于a，可以相当于是a=a+2)指针变量两种初始化

方法一：int a=2，*p=&a;(定义的同时初始化)..方法二：int a=2，*p;(定义之后初始化p=&a;

文件的复习方法：

把上课时候讲的文件这一章的题目要做一i

strlen和sizeof的区别也是考试的重点；

上考试的都会在练习当中。

define f(x)(x*x)和define f(x)x*x之间的差别。一定要好好的注意这写 容易错的地方，替换的时候有括号和没有括号是很大的区别。int *p;p =(int *)malloc(2);p =(int *)malloc(sizeof(int));以上两个等价 当心填空题目，malloc的返回类型是void * 还有main(int argc，char **argv){}这种含有参数的题目，是很呆板的题目。第 一个参数是表示输入的字符串的数目，第二个参数是指向存放的字符串。

函数的递归调用一定要记得有结束的条件，并且要会算简单的递归题目。要会作递归的 题目 结构体和共用体以及链表要掌握最简单的。typedef考的很多，而且一定要知道如何引用 结构体中的各个变量，链表中如何填加和删除节点，以及何如构成一个简单的链表，一定记 住链表中的节点是有两个域，一个放数值，一个放指针。函数指针的用法（*f)()记住一个例子： int add(int x, int y){ } main(){ int(*f)()f=add;} 赋值之后：合法的调用形式为

1、add(2，3);

2、f(2，3);

3、(*f)(2，3)9)

11)共用体的考查: union TT { int a;char ch[2];} 考点一：sizeof(struct TT)= 2;考点二： TT t1;t1=0x1234;那么 ch[0]=0x 34;ch[1]=0x12

第三篇：C语言知识点总结

C语言总结

第一章 概述

1． C语言的特点

①语言简洁、紧凑，使用方便、灵活。共有３２个关键字，９种控制语句。②运算符丰富，公有３４种运算符。

③数据结构丰富，数据类型有：整型、实型、字符型、数组、指针、结构体、共用体等。④具有结构化的控制语句（如if…else、while、do…while、switch、for）⑤语法限制不太严格，程序设计自由度大。

⑥允许直接访问物理地址，能进行位（bit）操作，可以直接对硬件操作。⑦生成目标代码质量高，程序执行效率高。⑧可移植性好。2． C语言的用途

C虽不擅长科学计算和管理领域，但对操作系统和系统实用程序以及对硬件进行操作方面，C有明显的优势。现在很多大型应用软件也用Ｃ编写。

第二章 数据类型、运算符与表达式

1． C的数据类型

C的数据类型包括：整型、字符型、实型或浮点型（单精度和双精度）、枚举类型、数组类型、结构体类型、共用体类型、指针类型和空类型。2． 常量与变量

常量其值不可改变，符号常量名通常用大写。变量其值可以改变，变量名只能由字母、数字和下划线组成，且第一个字符必须为字母或下划线。否则为不合法的变量名。变量在编译时为其分配相应存储单元。3． 整型数据

整型常量的表示方法：十进制不用说了，八进制以0开头，如0123，十六进制以0x开头，如0x1e。

整型变量分为：基本型（int）、短整型（short int）、长整型（long int）和无符号型。不同机器上各类数据所占内存字节数不同，一般int型为２个字节，long型为4个字节。4． 实型数据

实型常量表示形式：十进制形式由数字和小数点组成（必须有小数点），如：0.12、.123、123.、0.0等。指数形式如123e3代表123×10的三次方。

实型变量分为单精度（float）和双精度（double）两类。在一般系统中float型占4字节，7位有效数字，double型占8字节，15~16位有效数字。5． 字符型数据 字符变量用单引号括起来，如'a','b'等。还有一些是特殊的字符常量，如'n','t'等。分别代表换行和横向跳格。

字符变量以char 来定义，一个变量只能存放一个字符常量。

字符串常量是由双引号括起来的字符序列。这里一定要注意'a'和“a”的不同，前者为字符常量，后者为字符串常量，c规定：每个字符串的结尾加一个结束标志''，实际上“a”包含两个字符：'a'和''。

6． 数值型数据间的混合运算

整型、字符型、实型数据间可以混合运算，运算时不同类型数据要转换成同一类型再运算，转换规则：

char,short-> int-> unsigned-> long-> double <-float 7． 运算符和表达式

c运算符包括：

算数运算符（+-* / %）关系运算符（> < == >= <=!=）逻辑运算符（!&& ||）

位运算符（<< >> ~ | ^ &）赋值运算符（=）条件运算符（? :）逗号运算符（,）指针运算符（* &）求字节数（sizeof）强制类型转换（类型）分量运算符（.->）下标运算符（[ ]）

其它运算符（如函数调用运算符()）自增自减运算符（++--）注意：++i和i++的不同之处，++i使用i之前先使i加１，i++使用i之后，使i加１。

逗号表达式的求解过程：先求解表达式１，再求解表达式２，整个表达式的值是表达式２的值。

第三章 最简单的ｃ程序设计 １．c的９种控制语句： if()~ else~ for()~ while()~ do~while()continue break switch goto return 程序的三种基本结构：顺序结构，选择结构，循环结构

２．数据输出

c语言不提供输入输出语句，输入输出操作是由c的库函数完成。但要包含头文件stdio.h。putchar()向终端输出一个字符 printf()的格式字符：

① d格式符 用来输出十进制整数 %d 按整型数据的实际长度输出

%md 使输出长度为m，如果数据长度小于m，则左补空格，如果大于m，则输出实际长度

%ld 输出长整型数据

② o格式符 以八进制形式输出整数 ③ x格式符 以十六进制形式输出整数

④ u格式符 用来输出unsigned型数据，以十进制形式输出 ⑤ c格式符 用来输出一个字符 ⑥ s格式符 输出一个字符串 %s 输出实际长度字符串

%ms 输出的串占m列，如果串长度小于m，左补空格，如果大于m，实际输出 %-ms输出的串占m列，如果串长度小于m，右补空格，%m.ns 输出占m列，但只取字符串中左端n个字符并靠右对齐 %-m.ns m、n含义同上，靠左对齐，如果n>m，则m自动取n值 ⑦ f格式符 以小数形式输出实数

%f 整数部分全部输出，小数部分输出6位

%m.nf 输出数据共占m列，其中有n位小数。如果数值长度小于m，左补空格 %-m.nf 同上，右补空格

⑧ e格式符 以指数形式输出实数

%e 系统指定６位小数，5位指数（e+002)⑨ g格式符 输出实数，根据数值大小，自动选f格式或e格式

3．数据输入

getchar()从终端输入一个字符

scanf(格式控制,地址列表)标准C scanf中不使用%u，对于unsigned型数据，以%d或%o或%x输入。％后的*，用来跳过它相应的数据。输入数据时不能规定精度如scanf(“%7.2f”, &a);是不合法的。

第四章逻辑运算和判断选取控制

1． 关系运算符：

c提供６种关系运算符（> < <= >= ==!=）前四种优先级高于后两种。2． If语句

C提供了三种形式的if语句 If(表达式)语句

If(表达式)语句1 else 语句2 If(表达式1)语句1 Else if(表达式2)语句2 …

else 语句n 3． 条件运算符

(a>b)?a:b 条件为真，表达式取值a，否则取值b 4． Switch语句 Switch(表达式){ case 常量表达式１：语句１;break;case 常量表达式２：语句2;break;

…

case 常量表达式n：语句ｎ;break;

default ：语句ｎ＋１;}

第五章 循环控制

1． 几种循环语句

goto语句（现已很少使用）

while语句 先判断表达式后执行语句 do-while语句 先执行语句后判断表达式 for语句

2． Break语句和continue语句

Break语句用于跳出循环，continue用于结束本次循环。

第六章 数组

1． 一维数组

c规定只有静态存储（static）和外部存储（extern）数组才能初始化。给数组初始化时可以不指定数组长度。2． 二维数组 3． 字符数组 部分字符串处理函数

puts(字符数组)将一个字符串输出到终端。

gets(字符数组)从终端输入一个字符串到字符数组，并且得到一个函数值，为该字符数组的首地址

strcat(字符数组１,字符数组2)连接两个字符数组中的字符串，数组1必须足够大。Strcpy(字符数组１,字符串2)

将字符串２拷贝到字符数组１中。

Strcmp(字符串1,字符串2)比较字符串，相等返回0，字符串１>字符串2，返回正数，小于返回负数。

Strlen(字符数组)求字符串长度。

Strlwr(字符串)将字符串中的大写字母转换成小写 Strupr(字符串)将字符串中的小写字母转换成大写 以上是一些比较常用的字符串处理函数。

第七章 函数

1． 关于形参和实参的说明

① 在函数被调用之前，形参不占内存 ② 实参可以是常量、变量或表达式 ③ 必须指定形参的类型 ④ 实参与形参类型应一致

⑤ 实参对形参的数据传递是“值传递”，即单向传递 2． 函数返回值

如果想让函数返回一个值，在函数中就要用return语句来获得，在定义函数时也要对函数值指定类型，如果不指定，默认返回整型。3． 函数调用

1)注意在函数调用时实参和形参的个数、类型应一一对应。对实参表求值的顺序是不确定的，有的系统按自左至右，有的系统则按自右至左的顺序。这一点要注意。2)函数调用的方式：函数语句，函数表达式，函数参数

3)如果主调函数和被调函数在同一文件中，并且主调函数在前，那么一般要在主调函数中对被调函数进行说明。除非：(1)被调函数的返回值类型为整型或字符型(2)被调函数出现在主调函数之前。

4)对函数的说明和定义是不同的，定义是指对函数功能的确立，包括指定函数名，函数值类型，形参及其类型、函数体等。说明则只是对已定义的函数返回值类型进行说明，只包括函数名、函数类型以及一个空的括弧，不包括形参和函数体。

5)c语言允许函数的递归调用（在调用一个函数的过程中又出现直接或间接的调用该函数本身）。4． 数组作为函数参数

1)数组元素作为函数参数 和一般变量相同

2)数组名作参数应该在主调和被调函数分别定义数组，形参数组的大小可以不定义。注意：数组名作参数，不是单向传递。3)多维数组作参数，在被调函数中对形参数组定义时可以省略第一维的大小说明，但不能省略第二维或更高维的说明。5． 局部变量和全局变量

从变量作用域角度分，变量可分为局部变量和全局变量。1)内部变量（局部变量）

在一个函数内定义，只在函数范围内有效的变量。

2)外部变量（全局变量）

在函数外定义，可以为本文件其它函数所共用，有效范围从定义变量的位置开始

到本文件结束。建议尽量少使用全局变量，因为它在程序全部执行过程中都占用

资源，而且使函数的通用性降低了。如果在定义外部变量之前的函数要想使用该

外部变量，则应在该函数中用extern作外部变量说明。6． 动态存储变量与静态存储变量

从变量值存在的时间（生存期）角度来分，可分为静态存储变量和动态存储变量。静态存储指在程序运行期间给变量分配固定的存储空间，动态存储指程序运行期间根据需要动态的给变量分配存储空间。C语言中，变量的存储方法分为两大类：静态存储类和动态存储类，具体包括：自动的（auto），静态的(static)，寄存器的(register)，外部的(extern)。1)局部变量的存储方式

函数中的局部变量如不作专门说明，都之auto的，即动态存储的，auto可以省略。局部变量也可以定义为static的，这时它在函数内值是不变的。静态局部变量如不赋初值，编译时系统自动赋值为０，动态局部变量如不赋初值，则它的值是个不确定的值。C规定，只有在定义全局变量和局部静态变量时才能对数组赋初值。为提高执行效率，c允许将局部变量值放在寄存器中，这种变量叫register变量，要用register说明。但只有局部动态变量和形式参数可以作为register变量，其它不行。2)全局变量的存储方式

全局变量在函数外部定义，编译时分配在静态存储区，可以在程序中各个函数所引用。多个文件的情况如何引用全局变量呢？假如在一个文件定义全局变量，在别的文件引用，就要在此文件中用extern对全局变量说明，但如果全局变量定义时用static的话，此全局变量就只能在本文件中引用了，而不能被其它文件引用。3)存储类别小结

从作用域角度分，有局部变量和全局变量

局部变量：自动变量，即动态局部变量（离开函数，值就消失）

静态局部变量（离开函数，值仍保留）

寄存器变量（离开函数，值就消失）

（形参可定义为自动变量和寄存器变量）全局变量：静态全局变量（只限本文件引用）

全局变量（允许其它文件引用）

从存在的时间分，有静态存储和动态存储 动态存储：自动变量（本函数内有效）

寄存器变量（本函数内有效）

形参

静态存储：静态局部变量（函数内有效）静态全局变量（本文件内有效）

全局变量（其它文件可引用）从变量值存放的位置分 静态存储区：静态局部变量

静态全局变量 全局变量

动态存储区：自动变量和形参 寄存器内：寄存器变量 7． 内部函数和外部函数

内部函数：只能被本文件中的其它函数调用，定义时前加static，内部函数又称静态函数。外部函数：可以被其它文件调用，定义时前加extern，如果省略，则隐含为外部函数，在需要调用此函数的文件中，一般要用extern说明。

第八章 预编译处理

c编译系统在对程序进行通常的编译之前，先进行预处理。c提供的预处理功能主要有以下三种：1）宏定义 2）文件包含 3）条件编译 1． 宏定义

不带参数的宏定义

用一个指定的标识符来代表一个字符串，形式：#define 标识符 字符串 几点说明：

１）宏名一般用大写

２）宏定义不作语法检查，只有在编译被宏展开后的源程序时才会报错 ３）宏定义不是c语句，不在行末加分号 ４）宏名有效范围为定义到本源文件结束 ５）可以用#undef命令终止宏定义的作用域 ６）在宏定义时，可以引用已定义的宏名

带参数的宏定义

定义形式：#define 宏名（参数表）字符串 这和函数有些类似，但他们是不同的：

１）函数调用时，先求实参表达式值，再代入形参，而宏只是简单替换，并不求值

２）函数调用是在程序运行时分配内存的，而宏展开时并不分配内存，也没有返回值的概念 ３）对函数中的实参和形参都要定义类型，而且要求一致，宏名无类型，其参数也没有类型。４）函数只有一个返回值，而宏可以得到几个结果

５）宏替换不占运行时间，只占编译时间，而函数调用占运行时间 2． 文件包含处理

#include “文件1” 就是将文件1的全部内容复制插入到#include位置，作为一个源文件进行编译。在#include 命令中，文件名可以用“ ”也可以用< >，假如现在file1.c中包含file2.h文件，“ ”表示系统先在file1.c所在目录中找file2.h，如果找不到，再按系统指定的标准方式检索目录，< >表示系统直接按指定的标准方式检索目录。所以用“ ”保险一点。3． 条件编译

条件编译指不对整个程序都编译，而是编译满足条件的那部分。条件编译有以下几种形式： 1）#ifdef 标识符

程序段１

#else 程序段２

#endif 它的作用：当标识符在前面已经被定义过（一般用#define），则对程序段１编译，否则对程序段２编译。

２）#ifndef 标识符 程序段１ #else 程序段２

#endif 它的作用和#ifdef相反，当标识符没被定义过，对程序段１编译，否则对程序段２编译。３）#if 表达式 程序段１

#else 程序段２

#endif 它的作用：当表达式值为真（非０）时，对程序段１编译，否则对程序段２编译。

Top of Page

第九章 指针

指针说白了就是地址。指针变量就是用来存放指针（地址）的变量。1． 变量的指针和指向变量的指针变量

读起来很拗口，说白了就是变量的地址和用来存放变量地址的地址变量。因为一个变量在编译的时候系统要为它分配一个地址，假如再用一个变量来存放这个地址，那么这个变量就叫做指向变量的指针变量，也就是用来存放变量地址的这么一个变量。所谓“指向”就是指存放××的地址，如指向变量的指针变量，“指向”就是指用来存放变量的地址，再如指向数组的指针变量，“指向”就是指存放数组的地址。只要理解了这个，指针也就不难了。另外，还有指向字符串的指针变量，指向函数的指针变量，指向指针的指针变量等。

1)指针变量的定义

形式：类型标识符 *标识符 如：int *pointer;要注意两点：*表示pointer是个指针变量，在用这个变量的时候不能写成*pointer，*pointer是pointer指向的变量。一个指针变量只能指向同一个类型的变量。如上面 pointer只能指向int型变量。2)指针变量的引用 两个有关的运算符：

& 取地址运算符 &a 就代表变量a的地址 * 指针运算符

*a 就代表变量a的值 2． 数组的指针和指向数组的指针变量

数组的指针指数组的起始地址，数组元素的指针指数组元素的地址。1)指向数组元素的指针变量的定义与赋值

定义和指向变量的指针变量定义相同，c规定数组名代表数组的首地址，即第一个数组元素地址。

2)通过指针引用数组元素

我们通常引用数组元素的形式是a[i]，如果用指针可以这样引用，*(a+i)，或定义一个指针变量p，将数组a的首地址赋给p，p=a;然后用*(p+i)引用。

注意：指针变量ｐ指向数组a首地址，则p++指向数组ａ的下一元素地址，即a[1]的地址。3)数组名作函数参数

形参数组和实参数组之间并不是值传递，而是共用同一段地址，所以在函数调用过程中如果形参的值发生变化，则实参的值也跟着变化。4)指向多维数组的指针和指针变量

以二维数组为居多。假设定义了一个二维数组a[3][4]，那么

a代表整个二维数组的首地址，也代表第0行的首地址，同时也是第0行第0列的元素的首地址。a +0和a[0]代表第0行首地址，a+1和a[1]代表第一行的首地址。

假设a是一个数组的首地址，那么如果a是一维的，a+I代表第I个元素的地址，如果a是二维的，则a+I代表第I行的首地址。

那么第一行第二列的元素地址如何表示呢？a[1]+2或&a[1][2]或*(a+1)+2。

我们只要记住：在二维数组中a代表整个数组的首地址，a[I]代表第I行的首地址，a[I]与*(a+I)等价就行了。只要运用熟练了就没什么复杂的了。5)指向由m个整数组成的一维数组的指针变量

如：int(*p)[4]，p是一个指向包含4个元素的一维数组，如果p先指向a[0]，则p+1指向a[1]，即p的增值是以一维数组的长度为单位的，这里是4，举个例子：

假设a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23}，p先指向a[0]也就是数组a的首地址，那么p+1就是a[1] 的首地址即元素9的地址，因为在定义p时int(*p)[4]，定义一维数组长度为4，所以p+1就等于加了一个一维数组的长度4。3． 字符串的指针和指向字符串的指针变量

1)字符串的表示形式

c中字符串有两种表示形式：一种是数组，一种是字符指针

char string[]=“I love c!”;char *str=“I love c!”;其实指针形式也是在内存中开辟了一个数组，只不过数组的首地址存放在字符指针变量str中，千万不要认为str是一个字符串变量。2)字符串指针作函数参数

实际上字符串指针就是数组的首地址。3)字符指针变量与字符数组的区别

① 字符数组由若干元素组成，每个元素存放一个字符，而字符指针变量只存放字符串的首地址，不是整个字符串

② 对数组初始化要用static，对指针变量不用。

③ 对字符数组赋值，只能对各个元素赋值，不能象下面这样： char str[14];str=“I love c!”;对指针变量可以，char *str;str=“I love c!”;注意：此时赋给str的不是字符，而是字符串首地址。

④ 数组在定义和编译时分配内存单元，而指针变量定义后最好将其初始化，否则指针变量的值会指向一个不确定的内存段，将会破坏程序。如： char *a;scanf(“%s”, a);这种方法是很危险的，应该这样：

char *a, str[10];a = str;scanf(“%s”, a);这样字符指针就指向了一个确定的内存段。

⑤ 指针变量的值是可以改变的，而字符数组名所代表的字符串首地址却是不能改变的。4． 函数的指针和指向函数的指针变量

一个函数在编译时被分配一个入口地址，这个入口地址就称为函数的指针。函数名代表函数的入口地址，这一点和数组一样。我们可以用一个指针变量来存放这个入口地址，然后通过该指针变量调用函数。如：假设有一个求两者较大的函数如下：int max(int x, int y);当我们调用这个函数时可以这样：

int c;c=max(a, b);这是通常调用方法，其实我们可以定义一个函数指针，通过指针来调用，如： int(*p)();//注意指向函数指针变量的定义形式

p=max;//此句就是将函数的入口地址赋给函数指针变量p c=(*p)(a, b);有些朋友可能对(*p)()不大理解，其实它的意思就是定义一个指向函数的指针变量p，p不是固定指向哪个函数的，而是专门用来存放函数入口地址的变量。在程序中把哪个函数的入口地址赋给它，它就指向哪个函数。但要注意，p不能象指向变量的指针变量一样进行p++,p-等无意义的操作。

既然p是一个指针变量，那么就可以作为函数的参数进行传递。其实函数的指针变量最常用的用途之一就是作为函数参数传递到其它函数。这也是c语言中应用的比较深入的部分了。

5． 返回指针值的函数

我们知道，一个函数可以带回一个整型值、字符值、实型值等，函数还可以带回一个指针型的数据，即地址。这种函数的定义形式如下：

类型标识符 *函数名(参数表)如：int *a(x,y)返回一个指向整型的指针 使用这种函数的时候要注意：在调用时要先定义一个适当的指针来接收函数的返回值。这个适当的指针其类型应为函数返回指针所指向的类型。这样的函数比较难于理解，其实只要把它当做一般的函数来处理就容易了。当我们觉得指针难于理解的时候，就把它暂时当做整型来看，就好理解多了。6． 指针数组

指针数组无疑就是数组元素为指针，定义形式为：类型标识 *数组名[数组长度] 如:int *p[4]，千万不要写成int(*p)[4]，这是指向一维数组的指针变量。指针数组多用于存放若干个字符串的首地址，注意一点，在定义指针数组时初始化，如下： static char *name[]={“Li jing”,“Wang mi”,“Xu shang”};不要以为数组中存放的是字符串，它存放的是字符串首地址，这一点一定要注意。7． 指向指针的指针

说的明白一点，将一个指针再用一个变量来存放，那么这个变量就是指向指针的指针。定义如：char * *p;8． 指针数组作main()函数的参数 函数形式为

main(int argc, char *argv[]){} main函数的参数是从命令行得到的，argc指命令行参数个数，注意命令名也算一个参数，命令行参数都是字符串，他们的首地址构成一个指针数组argv。Main函数的形参用argc和argv只是一个习惯，也可以定义成别的名字。9． 指针小结 1)有关指针的数据类型

定

义 含

义 Int I;定义一个整型变量I Int *p;P为指向整型数据的指针变量 Int a[n];定义整型数组a，它有n个元素

Int *p[n];定义指针数组p，它有n个指向整型的指针元素 Int(*p)[n];P为指向含有n个元素的一维数组的指针变量 Int f();F为返回整型值的函数

Int *p();P为返回值为指针的函数，该指针指向整型数据 Int(*p)();P为指向函数的指针，该函数返回一个整型值 Int **p;定义一个指向指针的指针变量

2)ANSI新增了一种void *指针类型，即定义一个指针变量，但不指向任何数据类型，等用到的时候再强制转换类型。如： char *p1;void *p2;p1 =(char *)p2;也可以将一个函数定义成void *型，如：

void *fun(ch1, ch2)表示函数fun返回一个地址，它指向空类型，如果需要用到此地址，也要对其强制转换。如（假设p1为char型）： p1=(char *)fun(c1,c2);指针应该说是c语言中比较重要的概念，也是c语言的精华，它有很多优点，但用不好也会带来严重性的错误，这就需要我们多用，多练，慢慢的积累经验。

第十章结构体与共用体

1． 定义

结构体定义的一般形式： struct 结构体名{ 成员列表

};定义一个结构体变量可以这样定义：struct 结构体名结构体变量名;2． 结构体变量的引用

在引用结构体变量时应注意以下规则：

1)不能将结构体变量作为一个整体输入输出，只能对变量当中的各个成员输入输出。新标准C允许将一个结构体变量直接赋值给另一个具有相同结构的结构体变量。3． 结构体变量的初始化 如：

struct student {long int num;char name[20];char sex;char addr[20];}a={89031,“Li Lin”,'M',“123 Beijing Road” };4． 结构体数组

struct student stu[4];定义了一个数组stu，其元素为struct student类型，数组有4个元素。注意数组各元素在内存中是连续存放的。

在定义结构体数组时，数组元素个数可以不指定。编译时，系统会根据给出初值的结构体常量的个数来确定数组元素的个数。5． 指向结构体变量的指针

因为结构体变量在内存中是连续存放各成员的，因此我们可以将结构体变量在内存中的起始地址存放到一个变量中，那么这个变量就是指向结构体变量的指针。注意将结构体变量的首地址赋给指针变量的形式：

struct student stu_1;struct student *p;p=&stu_1;//要加取地址符 而指向函数和指向字符串的指针不用 在对引用结构体变量中的成员时，有三种方式：

以上面的结构体为例：设p为指向此结构体变量的指针，即p=&a;1)a.num 2)(*p).num 3)p->num 6． 指向结构体数组的指针

struct student *p;struct student stu[4];p=stu;则p为指向结构体数组的指针变量。这里应注意p++，p指向stu[0],p++则指向stu[1]。P指向的是数组中一个元素的首地址，而不能让p指向元素中的某一成员，如p=&stu[I].name是不对的。

7． 用指向结构体的指针作函数参数

虽然ANSI C允许用整个结构体作为函数参数，但要将全部成员值一个一个传递，开销大。所以用指针作参数，能提高运行效率。Struct student stu;用整个结构体作为参数调用形式：

fun(stu);而且被调函数fun中也要定义成结构体变量,struct student stu;用指针作参数调用形式：

fun(&stu);被调函数fun中定义成指针变量，struct student *p;8． 用指针处理链表

链表是一种重要的数据结构，原因就在于它可以动态的进行存储分配。链表都有一个头指针，用来存放整个链表的首地址。链表的定义形式如下： struct node{ int num;…

struct node *next;};next用来存放下一节点的地址。

如何进行动态的开辟和释放存储单元呢？c提供了以下有关函数：

1)malloc(size)在内存的动态存储区开辟一个长度为size的连续空间。成功返回空间首地址，失败返回0;2)calloc(n,size)在内存的动态存储区开辟n个长度为size的连续空间。成功返回空间首地址，失败返回0;3)free(ptr)释放由ptr指向的内存区。Ptr是最近调用一次调用malloc和calloc时返回的值。上面函数中，n和size为整型，ptr为字符指针。

9． 共用体 定义形式： union 共用体名 { 成员列表 }变量列表;共用体和结构体类似，只是有一点不同，结构体中个成员的起始地址不同，结构体变量在内存中的长度为各成员长度之和；而共用体中个成员的起始地址相同，共用体变量所占的内存长度为最长的成员的长度。共用体类型数据的特点：

1)同一个内存段可以存放几种不同类型的成员

2)共用体变量中起作用的成员是最后一次存放的成员 3)不能对共用体变量名赋值，不能在定义时初始化。4)不能把共用体变量作为函数参数

5)共用体类型可以出现在结构体定义中，反之也可，也可以定义共用体数组。另外，结构体名可以作为参数，而共用体名不可以。这两中数据结构在不同场合中各有所用。10． 枚举类型

定义形式如下：举个例子

enum weekday{sun,mon,tue,wed,thu,fri,sat};enum weekday workday,week_end;//定义枚举变量

workday和week_end被定义成枚举类型，他们的值只能为sun到sat之一。也可以直接定义枚举变量，这一点与结构体相同

enum weekday{sun,mon,tue,wed,thu,fri,sat}wordday,week_end;注意：枚举元素是作为常量存在的，他们是有值的，c在编译时使他们的值按顺序为0,1,2… 如：上面的定义中，sun的值为0，mon的值为1 另外：虽然枚举元素有值，但不能将一个整数直接赋给一个枚举变量。应进行强制类型转换，如：

workday=(enum weekday)2;它相当于把tue赋给了workday。11． 用typedef定义类型

typedef的作用就是能够让你定义一个自己喜欢的数据类型名来代替已有的数据类型名。如： typedef int INT;那么我就可以用INT来定义整型变量了。作用和int一样。Typedef用于结构体定义，如： Typedef struct{ Int day;Int month;Int year;}DATE;DATE birthday;DATE *p;等等

用typedef有利于程序的通用与移植。

第十一章 位运算

1)概述 所谓位运算是指进行二进制位的运算。在系统软件中，常要处理二进制位的问题。c提供的位运算符有： & 按位与 | 按位或 ^ 按位异或 ~ 取反 << 左移 >> 右移

&对于将一个单元清零、取一个数中的某些指定位以及保留指定位有很大用途。|常被用来将一个数的某些位置1。

^判断两个位值，不同为1，相同为0。常用来使特定位翻转等。~常用来配合其它位运算符使用的，常用来设置屏蔽字。

<<将一个数的各二进制位全部左移，高位左移后溢出，舍弃不起作用。左移一位相当于该数乘2，左移n位相当于乘2n。左移比乘法运算要快的多。

>>右移时，要注意符号问题。对无符号数，右移时左边高位移入0，对于有符号数，如果原来符号位为0（正数），则左边移入0；如果符号位为1（负数），则左边移入０还是１要取决于系统。移入０的称为“逻辑右移”，移入１的称为“算数右移”。2)位段

将一个字节分为几段来存放几个信息。所谓位段是以位为单位定义长度的结构体类型中的成员。如：

struct packed-data{ unsigned a:2;unsigned b:6;unsigned c:4;unsigned d:4;int I;}data;其中a,b,c,d分别占2位,6位,4位,4位。I为整型，占4 个字节。对于位段成员的引用如下：

data.a = 2;等，但要注意赋值时，不要超出位段定义的范围。如位段成员a定义为2位，最大值为3，即(11)2，所以data.a=5;就会取5的两个低位进行赋值，就得不到想要的值了。关于位段的定义和引用，有几点重要说明：

①若某一个段要从另一个字开始存放，可以定义：

unsigned a:1;unsigned b:2;unsigned :0;unsigned c:3;(另一单元)使用长度为0的位段，作用就是使下一个位段从下一个存储单元开始存放。②一个位段必须存放在用一个存储单元中，不能跨两个单元。③可以定义无名位段。如： unsigned a:1;unsigned :2;(这两位空间不用)unsigned b:3;④位段的长度不能大于存储单元的长度，也不能定义位段数组。

第十二章 文件

1)概述

c语言将文件看成一个字符的序列，分为ASCII文件（文本文件）和二进制文件。即一个c文件就是一个字节流或二进制流。

ASCII 文件每一个字节放一个ASCII码，代表一个字符，输出与字符一一对应，便于逐个处理字符，但占用空间较多。二进制文件按内存中的存储形式原样输出到磁盘上，节省空间，由于输出与字符不对应，不能直接输出字符形式，一般用于保存中间结果。目前c对文件的处理只有缓冲文件系统一种方法，即无论是从程序到磁盘文件还是从磁盘文件到程序，数据都要先经过缓冲区，待缓冲区充满后，才集中发送。2)文件夹类型指针

在缓冲文件系统中，关键的概念是文件指针。因为每个被使用的文件都在内存中开辟一个缓冲区，来存放文件有关信息。这些信息保存在一个结构体变量中，该结构体类型是由系统定义的，取名为FILE，在stdio.h中定义。

FILE *fp;定义了一个文件指针变量fp，以后对文件的操作都是通过fp进行的。3)文件的打开与关闭

在对文件读写之前，要先打开文件。

打开文件的函数为：fopen()，调用方式为：

FILE *fp;fp=fopen(filename,使用文件方式);fopen()失败返回一个空指针NULL，成功则返回一个指向“filename”的文件指针，赋给fp，这样fp就和打开的文件联系在一起了。或者说，fp指向了“filename”。

文件使用方式：r,w,a,rb,wb,ab,r+,w+,a+,rb+,wb+,ab+，具体含义要记住。4)文件的关闭

为了防止数据丢失，程序结束前，务必将打开的文件关闭，即将文件指针与文件脱钩。用fclose(文件指针)函数关闭文件，执行函数后，先将缓冲区中的数据送到磁盘文件，然后释放文件指针。成功返回0，失败返回非0。5)文件的读写

文件打开后，就可以对其读写了，常用的文件读写函数有： ①fputc和fgetc fputc将一个字符写到文件，形式为fputc(ch, fp);将字符ch写入fp所指向的文件。成功返回该字符，失败返回EOF，EOF在stdio.h中定义为符号常量-1。

fgetc 从指定文件读入一个字符，该文件必须是以读或读写方式打开的。调用形式为ch=fgetc(fp);从fp指向的文件读入一个字符赋给ch，当文件结束时，fgetc返回一个EOF，我们可以用函数feof(fp)来判断是否已到文件尾，返回1表示已到文件尾，否则返回0。这个函数适用于文本文件和二进制文件。②fread和fwrite函数

可以读写一组数据。调用形式如下：

fread(buffer, size, count, fp);fwrite(buffer, size, count, fp);buffer为一个指针，对fread来讲，是指从文件读出数据的存放地址，对fwrite来讲，是要写入文件的数据的地址。size 要读写的字节数

count 要进行读写多少个size字节的数据项（书上这么说）其实就是读写的次数 fp 文件指针

这两个函数返回值成功为1，失败为非1，一般用于二进制文件的读写。注意：有些c编译系统不具备这两个函数。③fprintf()和fscanf()函数

格式化输出和输入函数，与printf()和scanf()作用相似，只有一点不同，fprintf()和fscanf()的读写对象不是终端而是磁盘文件。调用方式： fprintf(文件指针,格式字符串,输出列表);fscanf(文件指针,格式字符串,输出列表);④fgets()和fputs()函数

作用是读写一个字符串，如：

fgets(str,n,fp);意为从fp指向的文件读出n-1个字符，存放到str中，成功返回str的首地址。fputs(“China”, fp);把字符串China写入fp指向的文件。成功返回0，失败为非0。6)文件的定位

文件中有一个位置指针，指向当前读写的位置，如果要强制改变位置指针的位置，可以用有关函数：

①rewind 使位置指针重新返回文件的开头 ②fseek()fseek()函数可以任意改变位置指针的位置，以实现随机读写文件。调用形式： fseek(文件指针类型,位移量,起始点);起始点有以下三个值： SEEK_SET或0 文件开始

SEEK_CUR或1 文件当前位置 SEEK_END或2 文件末尾

位移量指以起始点为基点，移动的字节数（正数向文件尾移动，负数向文件头移动），一般位移量用long型数据，以避免大于64K的文件出错。Fseek()函数一般用于二进制文件，因为文本文件要进行字符转换，计算时会发生混乱。

Fseek(fp, 100L, 0);将位置指针从文件头向文件尾移动100个字节处。Fseek(fp, 50L, 1);将指针从当前位置向文件尾移动50个字节处。Fseek(fp,-10L, 2);将指针从文件尾向文件头移动10个字节处。③ftell()到流式文件位置指针的当前位置，成功返回相对于文件头的位移量，失败返回-1L。

第四篇：C语言函数知识点总结

函数

本章重点：

本章难点：

//函数相关内容：

*语法：包括定义，声明，调用，*语义

语句包括：表达式语句，空语句，控制语句，复合语句，函数调形参与实参的意义、作用与区别； 参数的两种传递方式； 对递归函数调用过程的理解； 全局变量和局部变量的作用。函数的定义和调用； 函数间的数据传递方式； 嵌套调用和递归调用； 变量的作用域和存储类别； 模块化程序设计方法。用语句

函数：*函数首部：包括返回值类型，函数名，形参

*函数体

*函数调用的过程：*开辟空间（形参，函数的局部变量）

1.函数其实就是一段可以重复调用的、功能相对独立完整的程序段。

2.主函数可以调用其他函数，其他函数也可以互相调用。

3.一个C程序必须有一个且只能有一个main函数，无论main函数位于程序 的什么位置，运行时都是从main函数开始执行的。

4.函数不能嵌套定义，也就是说一个函数不能从属于另一个函数。函数之

*把实参送给形参

*执行函数

*释放空间

间可以互相调用，但是任何函数不能调用main函数，main函数是被操作系

统调用的。

5.函数的分类：

（1）从用户角度看：库函数、用户自定义的函数（2）从形式：无参函数、有参函数

6.函数定义即函数的实现，是对所要完成功能的操作进行描述的过程，包

括函数命名和返回值类型声明、形式参数的类型说明、变量说明和一系

列操作语句等。

函数和变量一样，必须“先定义，后使用”

7.函数定义应包括以下内容：

函数的名字、返回值的类型。函数参数的类型和名字，无参函数不需要

指定。指定函数的功能

8.在函数体中，声明部分是对函数内部所用到的变量的类型说明，并对要

调用的函数进行声明。

9。定义有参函数的一般形式为: 类型标识符 函数名（形式参数表列）｛

声明部分;

｝ 语句；

10.在C语言中，可以用以下几种方式调用函数(1)函数表达式

函数作为表达式中的一项出现在表达式中，以函数返回值参与表达式

的运算。这时要求函数是有返回值的。

例如：y=sin(x);(2)函数语句

函数调用的一般形式加上分号即构成函数语句。

例如：printf(“%d”,a);

这种方式通常只要求函数完成一定的操作，不要求函数带回值。(3)函数实参

这种方式是函数作为另一个函数调用的实际参数出现，也就是把该函

数的返回值作为实参进行数据传送，所以要求该函数必须是有返回值

的。

例如：printf(“%d”,max(a,b));

11.实参:可以是常量、变量和表达式。

12.只有在发生函数调用时，才给形参分配单元，并且赋值，一旦函数调

用结束后，形参所占的内存单元又被释放掉。

13.在调用函数过程中发生的实参与形参间的数据传递是“值传递”，只

能由实参向形参传递数据，是单向传递，不能由形参传给实参。

14.声明的作用是把函数的返回值类型、函数名、函数参数的个数和类型

等信息通知编译系统，以便在遇到函数调用时，编译系统能识别该函

数并检查调用是否合法

15.函数的声明方法：

(1)只说明函数的类型，这称为简单声明。int min();(2)不仅说明函数的类型还要说明参数的个数和类型，这称为原型声明。

int min(int x,int y);

16.数组名作函数参数时,形参数组和实参数组为同一数组，共同拥有一段

内存空间。

17.数组元素不能用作形参，因为形参是在函数调用时临时分配内存存储

单元的，不能为一个数组元素单独分配存储单元。

18.变量的有效范围（作用域）

19.局部变量也称为内部变量，是在函数内或函数的复合语句内定义说明的。

20.全局变量也称为外部变量，它是在函数外部定义的变量，位置在所有

函数前、各个函数之间或所有函数后。

*其作用域是从定义变量的位置开始到本源文件结束。

*设置全局变量的作用是可以增加各个函数之间的数据传输渠道。21.变量的完整说明为：

存储类型 数据类型 变量名表列； 例如： auto int x,y;

22.C语言变量的存储方式可以分为动态存储方式和静态存储方式。

23.动态存储方式：(1)自动变量(auto变量)(2)寄存器变量（register变量）(3)形式参数

24.静态存储方式：

(1)静态局部变量（static局部变量）

其语法格式为：

static 类型标识符 变量名;

例如：static int f;

(2)全局变量(全局变量赋初值也是在编译时完成的，且仅执行一次赋初值的操作。)

不能用extern来初始化外部变量。

(3)静态外部变量

25.一般为了叙述方便，把建立存储空间的变量声明称定义，而把不需要

建立存储空间的声明称为声明

26.在函数中出现的对变量的声明(除了用extern声明的以外)都是定义。

例如：extern int x=25;

//错误

*外部变量

第五篇：C语言二级知识点总结

C语言二级考试知识点总结

1.在数据流图中，用标有名字的箭头表示数据流。在程序流程图中，用标有名字的箭头表示控制流。2.可行性分析阶段产生可行性分析报告。概要设计说明书是总体设计阶段产生的文档。集成测试计划是在概要设计阶段编写的文档。

需求规格说明书是后续工作如设计、编码等需要的重要参考文档。3.除了堆排序算法的比较次数是，其他的都是n(n－1)/2。4.E－R图转换成关系模型数据则是把图形分析出来的联系反映到数据库中，即设计出表，所以属于逻辑设计阶段。

5.C语言中的非执行语句不会被编译，不会生成二进制的机器指令，所以A)错误。由C语言构成的指令序列称C源程序，C源程序经过C语言编译程序编译之后生成一个后缀为.OBJ的二进制文件(称为目标文件)；最后要由“连接程序”把此.OBJ文件与C语言提供的各种库函数连接起来生成一个后缀为.EXE的可执行文件。

6.C语言中八进制整型常量的开头是数字0，十六进制整型常量的开头数字是0x。C语言中的实型常量有两种表示形式：小数形式，小数形式表示的实型常量必须要有小数点；指数形式，以“e”或“E”后跟一个整数来表示以10为底数的幂数，且规定字母e或E之前必须要有数字，且e或E后面的指数必须为整数。

7.循环队列有队头和队尾两个指针，但是循环队列仍是线性结构的；在循环队列中只需要队头指针与队尾两个指针来共同反映队列中元素的动态变化情况

8.链式存储结构既可以针对线性结构也可以针对非线性结构。链式存储结构中每个结点都由数据域与指针域两部分组成，增加了存储空间。9.在需求分析阶段可以使用的工具有数据流图DFD图，数据字典DD，判定树与判定表

10.对象有如下一些基本特点：标识唯一性、分类性、多态性、封装性、模块独立性好。

11.栈支持子程序调用。栈是一种只能在一端进行插入或删除的线性表，在主程序调用子函数时要首先保存主程序当前的状态，然后转去执行子程序，最终把子程序的执行结果返回到主程序中调用子程序的位置，继续向下执行，这种调用符合栈的特点

12.冒泡排序与简单插入排序与简单选择排序法在最坏情况下均需要比较n(n－1)/2次，而堆排序在最坏情况下需要比较的次数是 13.编译软件、操作系统、汇编程序都属于系统软件，只有C)教务管理系统才是应用软件。

14.耦合性是模块间互相连接的紧密程度的度量而内聚性是指一个模块内部各个元素间彼此结合的紧密程度

15.循环队列的队头指针与队尾指针都不是固定的，随着入队与出队操作要进行变化。因为是循环利用的队列结构所以对头指针有时可能大于队尾指针有时也可能小于队尾指针。

16.在E－R图中实体集用矩形，属性用椭圆，联系用菱形。17.算法是指解题方案的准确而完整的描述，算法不等于程序，也不等于计算方法，设计算法时不仅要考虑对数据对象的运算和操作，还要考虑算法的控制结构。

18.数据库系统的三级模式是概念模式、外模式和内模式

19.关于数据库设计的叙述:数据字典是在需求分析阶段建立，在数据库设计过程中不断修改、充实和完善的。

20.面向对象基本方法的基本概念有对象、类和实例、消息、继承与多态性

21.一般来说，在线性表的链式存储结构中，各数据结点的存储序号是不连续的，并且各结点在存储空间中的位置关系与逻辑关系也不一致。线性链表中数据的插入和删除都不需要移动表中的元素，只需改变结点的指针域即可。

22.实体完整性约束要求关系的主键中属性值不能为空值。所以一个关系中应该有一个或多个候选关键字

23.软件危机主要表现在：软件需求的增长得不到满足；软件开发成本和进度无法控制；软件质量难以保证；软件不可维护或维护程度非常低；软件的成本不断提高；软件开发生产率的提高赶不上硬件的发展和应用需求的增长。

24.需求分析阶段的工作有：需求获取；需求分析；编写需求规格说明书；需求评审

25.黑盒测试是对软件已经实现的功能是否满足需求进行测试和验证，黑盒测试完全不考虑程序内部的逻辑结构和内部特性，只根据程序的需求和功能规格说明，检查程序的功能是否符合它的功能说明，26.系统结构图是对软件系统结构的总体设计的图形显示。在需求分析阶段，已经从系统开发的角度出发，把系统按功能逐次分割成层次结构，是在概要设计阶段用到的。PAD图是在详细设计阶段用到的。程序流程图是对程序流程的图形表示，在详细设计过程中用到。数据流图是结构化分析方法中使用的工具，它以图形的方式描绘数据在系统中流动和处理的过程，由于它只反映系统必须完成的逻辑功能，所以它是一种功能模型，是在可行性研究阶段用到的而非软件设计时用到

27.栈是先进后出的数据结构，在整个过程中，栈底指针不变，入栈与出栈操作均由栈顶指针的变化来操作

28.数据定义语言：负责数据的模式定义与数据的物理存取构建；数据操纵语言：负责数据的操纵，包括查询及增、删、改等操作；数据控制语言：负责数据完整性、安全性的定义与检查以及并发控制、故障恢复等功能。

29.C程序经过编译、连接步骤之后才能形成一个真正可执行的二进制机器指令文件。。

并不是源程序中的所有行都参加编译。在条件编译形式下，相关内容只在满足一定条件时才进行编译。。用C语言编写的程序称为源程序，它以ASCII代码形式存放在一个文本文件中 30.不能将一个整数直接赋给指针变量作为地址 31.函数调用中形参值的变化不会传递给实参。

32.auto：函数中的局部变量，动态地分配存储空间，数据存储在动态存储区中，在调用该函数时系统会给它们分配存储空间，在函数调用结束时就自动释放这些存储空间。register：为了提高效率，C语言允许将局部变量的值放在CPU中的寄存器中，这种变量叫“寄存器变量”，只有局部自动变量和形式参数可以作为寄存器变量。extern：外部变量(即全局变量)是在函数的外部定义的，它的作用域为从变量定义处开始，到本程序文件的末尾。如果外部变量不在文件的开头定义，其有效的作用范围只限于定义处到文件终了。static：静态局部变量属于静态存储类别，在静态存储区内分配存储单元。在程序整个运行期间都不释放。

33.取模运算符%的左右两个操作数均应为整数

34.条件表达式：x＝表达式1？表达式2：表达式3 的含义是：先求解表达式1，若为非0(真)，则求解表达式2，将表达式2的值赋给x。若表达式1的值为0(假)，则求解表达式3，将表达式3的值赋给x。35.在任意一棵二叉树中，度为0的叶子节点总是比度为2的节点多一个

36.数据库应用系统中的核心问题是数据库的设计

37.因为x，y都是double型数据，所以输入时的格式字符应为%lf 38.char s[7]；s＝{“Olympic”}；中字符数组s的大小至少为8，才能存放下字符串。(字符串的末尾都有结束标志“”)。

39.数据字典是在需求分析阶段建立，在数据库设计过程中不断修改、充实和完善的。

40.详细设计的任务是为软件结构图中而非总体结构图中的每一个模块确定实现算法和局部数据结构，用某种选定的表达工具表示算法和数据结构的细节

41.数据定义语言：负责数据的模式定义与数据的物理存取构建；数据操纵语言：负责数据的操纵，包括查询及增、删、改等操作；数据控制语言：负责数据完整性、安全性的定义与检查以及并发控制、故障恢复等功能。

42.C语言中整型变量分为4种，基本型int，短整型short int，长整型long int和无符号型(unsigned int、unsigned short、unsigned long)