计算机二级C语言复习笔记

大家好，欢迎来到IT知识分享网。

考试内容

一.C语言程序的结构

#include<stdio.h> //导入包含一个头文件 .h是头文件 std标准库 i-input o-output(标准输入输出的头文件)

1.1 程序的构成：main函数和其他函数

1.1.1main函数

• 一个C语言程序有且只有一个main函数(必须有)
• main函数是C语言程序的入口，程序都是main开始执行

1.1.2其他函数

• 从函数定义来讲，函数分为系统函数和用户定义函数
• 系统函数即库函数，由编译系统提供，用户不必定义可以直接使用，如打印函数printf()
• 用户函数，可以解决用户的专门需求

1.2 源程序的书写格式

编写代码：hello.c

#include<stdio.h> int main(void) //int是一种数据类型 表示整型 存储整数 int是函数的返回值类型 //main是一个函数 是C语言的主入口 程序有且只有一个主函数 //void是一种数据类型 表示空类型 //{}大括号 括起来的称为函数代码体 括号是成对出现的 //printf是C语言库中的一个函数 在标准输入设备上打印一个字符串 //;表示一条语句的结束 //return表示函数的结束 0表示程序正确执行 {    printf("hello\n");    return 0; }

c语言的源代码文件是一个普通的文本文件，但拓展名必须是.c

1.3 头文件，数据说明，函数的开始和结束标志以及程序中的注释

1.3.1include头文件包含

• #include<>和#include””的区别：
• <>表示系统直接按照系统指定的目录检索
• “”表示系统先在””系统指定的路径(没写路径代表当前路径)查找头文件，如果找不到，再按照系统指定的目录检索

1.3.2程序体和代码块

• 所有#开头的行，都代表预编译指令，预编译指令行结尾是没有;的
• 所有可执行语句必须是在代码块里

1.3.3注释

• //叫行注释
• //叫块注释

  /*这是一个块注释 块注释可以注释多行*/

• 块注释是C语言标准的注释方法

1.3.4printf函数

• printf数C语言库函数，功能是向标准输出设备输出一个字符串
• printf（”hello\n”）;

  //\n的意思是回车换行

1.3.5return语句

• return代表函数执行完毕，返回return代表函数的终止
• main函数后面是int，return后面要加整数；main函数后面是void，return后面是什么也不需要写
• return 0表示执行成功，return -1表示执行失败
• int main()和void main()在C语言中是一样的，但C++只接受int main()这种定义方法

1.4 C语言的风格

1.4.1缩进

• +Tabs(制表符)是8个字符的大小，因此缩进符也是8个字符的大小
• 缩进背后的思想是：清楚地定义一个被控制块是从哪里开始到哪里结束

1.4.2放置花括号

• 关于如何放置花括号没有任何技术上的理由
• 另一种情况是函数：函数把左右花括号都放在行首
• 这种花括号的放置减少了空行的数目，没有损害可读性。因此，当屏幕上不可以有很多空行时，就有更多的空行可以安插注释

1.4.3标识符命题规则

#include<stdio.h> int main(void) {    //定义变量    //数据类型 变量名(标识符)    //标识符命名一般要见名知义    int weight=5;    int price=2;    int sum=weight*price;    printf("%d\n",sum);//占位符 %d表示输出一个整型数据 }

• 标识符不能是关键字
• 标识符只能由字母、数字和下划线组成
• 第一个字符必须为字母或下划线
• 标识符中的字母区分大小写

1.4.4注释

只写必须不写过多

二.数据类型及其运算

2.1 c的数据类型

2.1.1C语言关键字

C语言的关键字共有32个：

• 数据类型关键字（12个）

  char(字符型), short,int,long(整型), float,double(浮点型)

  unsigned(无符号),signed(有符号)在操作中可以不写,

  struct(定义结构体),union(定义联合体),enum(枚举),void(空类型)

• 控制语句关键字（12个）

  if,else,switch,case,default

  for,do,while,break(跳出循环),continue(结束本次循环)，goto(无条件跳转语句)，return(函数的结束)

• 存储类关键字（5个）

  auto(局部/自动变量),extern(声明)一般不用写,register(寄存器变量)建议性指令,

  static(修饰变量、常量或函数),const(定义常量)

• 其他关键字（3个）

  sizeof(定义数据类型长度),typedef(定义函数指针),volatile(防止编译器优化)

• 注：signed,goto,auto,extern,register,volatile用的较少

2.1.2数据类型

• 数据类型的作用：编译器预算对象(变量)分配的内存空间大小

1)整型 int

考试会有两分左右

&为取地址符- –

2)字符型：char

一.字符变量的定义与输出

• 字符型变量 用于储存一个单一字符，在C语言中用char表示，其中每一个字符变量都会占用1个字节
• 在给字符型变量赋值时，需要用一对英文半角格式单引号(‘ ‘)把字符括起来
• 字符变量实际上并不是把该字符本身放到变量的内存单元中去，而是将该字符对应的ASCII编码放到变量的储存单元中。
• char的本质就是一个1字节大小的整型

二.字符变量的输入

#include<stdio.h> int main(void) {    char ch='a';    //定义字符型变量    printf("%c\n",ch);    //%c是一个占位符 输出一个字符型变量    return 0; } int main01(void) {    char ch;    scanf("%c",&ch);    //char类型可以和整数进行运算操作    ch=ch-32;    printf("%c\n",ch);    return 0; } //输入小写输出大写

三.ASCII对照表

3)实型(浮点型)：float、double

• 浮点型变量是用来存储小数数值的
• double型变量所表示的浮点数比float型变量更准确

#include<stdio.h> int main(void) {    float pi=3.14159;    //%f是一个占位符 表示输出一个浮点型数据    //printf("%f",pi);    //浮点型默认保留小数6位 保留两位小数.2f 数据会四舍五入    printf("%.2f",pi);    //结果位3,15    return 0; }   int main01(void) {    float pi;    scanf("%f",&pi);    printf("%.3f",pi);    //输入数字取小数三位 四舍五入    return 0; } int main02(void) {    double a=123.456;    printf("%lf",a);    return 0; }

#include<stdio.h> int main(void); {    float pi=3.14159;    //圆的面积和周长    //面积pi*r*r    //周长2*pi*r    float r;    float s;    float c;    scanf("%f",&r);    s=pi*r*r;    c=2*pi*r;    printf("面积为：%.2f\n"，s);    printf("周长为：%.2f\n"，c);    //计算结果保留两位小数    return 0; }

• 注：由于浮点型变量是由有限的存储单元组成的，因此只能提供有限的有效数字，在有效位以外的数字将被舍去，这样可能会产生一些误差

2.1.3常量

• 在运行过程中，其值不能被改变的量
• 常量一般出现在表达式或赋值语句中

• 如何定义常量(两种方式)

#include<stdio.h> int mian(void) {   //const float pi=3.14159;   //定义一个常量 const修饰的变量成为常量 不能被赋值操作   float pi=3.14159;   pi=3.14;   //赋值   printf("%f\n",pi);   return 0; }

#include<stdio.h> #define PI=3.14159 int mian(void) { printf("%f\n",pi); return 0; }

2.1.4变量

• 程序运行过程中其值可以改变

#include<stdio.h> int mian(void) { auto float pi=3.14; //auto可以省略 printf("%f\n",pi); return 0; }

2.2 C运算符的种类、运算优先级和

2.2.1常用运算符分类

• 真值用1表示，假值用0表示
• 逻辑运算符：与：相同为真，或 ：有一个真为真，非：非真为假 非假为真

2.2.2算数运算符

• 注：除数不能为0
• 后自增和前自增

#include<stdio.h> int main(void) { int a=10; a=a++*10; //a++让变量a自增，即在当前值基础上加1 printf("%d\n",a); return 0; } //结果为101:先计算a*10,再自增

#include<stdio.h> int main(void) { int a=10; a=++a*10; //++a在变量前先计算a的值再计算表达式的值 printf("%d\n",a); return 0; } //结果为110：现将a自增，再*10

2.2.3赋值运算符

2.2.4比较运算符

2.2.5逻辑运算符

• 非：非真为假，非假为真
• 与：同真为真，其余为假
• 或：同假为假，其余为真

2.2.6运算符优先级

• 2 3 4算数运算符，6 7比较运算符，11 12逻辑运算符，14赋值运算符，15逗号运算符
• 13条件运算符(三目运算符)

  #include<stdio.h> int main(void) { int a; scanf("%d%d",&a,&b); if(a>b) { printf("最大值为：%d\n",a); } else { printf("最大值为：%d\n",b); } return 0; }

  #include<stdio.h> int main(void) { int a,b; scanf("%d%d",&a,&b); printf("最大值为：%d\n",a>b?a:b); //表达式？值1:值2 //表达式为真选择值1，表达式为假选择值2 return 0; } //if语句可以判断一个区间，但执行效率比较低 //Switch语句的执行效率比较快，但不可以进行区间判断 //三目/条件运算符结构清晰，担不适于嵌套

2.3 不同数据间的转换与运算

数据有不同的类型，不同类型数据间进行混合运算是必然涉及到类型的转换问题

转换的方法有两种：

• 自动转换(隐式转换)：遵循一定的规则，由编译系统自动完成
• 强制转换：把表达式的运算结果强制转换成所需的数据类型

类型转换的原则：占用内存字节数少(值域小)的类型，向占用内存字节数多(值域大)的类型转换，以保证精度不降低

2.3.1隐式转换

#include<stdio.h> int main(void) { int a=10; float b=1.234; double sun; sum=a*b; //隐式转换 printf("%lf",sum); return 0; }

2.3.2强制转换

#include<stdio.h> int main(void) { float a=1.234; int b; b=(int)a; //强制转换 不会四舍五入 printf("%d\n",b); return 0; }

2.4 C表达式类型

三.基本语句

3.1 表达式语句、空语句、复合语句

3.1.1表达式语句

• C程序设计的表达式语句由表达式加上“；”组成
• 分-为以下几类：算术表达式、赋值表达式、逗号表达式、关系表达式、逻辑表达式等
• 其一般形式为：执行表达式语句就是计算表达式的值

3.1.2空语句

• 空语句是什么也不执行的语句，一般由封号“；”或大括号“{}”组成(一般用大括号)
• 在程序中空语句可用来作空循环体

3.1.3复合语句

• 把多个语句用括号{}括起来的一个语句叫复合语句。在程序中把复合语句看作是单条语句。
• 复合语句中的各条语句都必须以封号；结尾；此外，在括号}外不能加封号

3.2 输入输出函数的调用

3.2.1 printf函数

• printf是输出一个字符串
• printf格式字符

3.2.2scanf函数

• scanf通过%转义的方式可以得到用户通过标准输入设备输入的数据
• &为取地址符

四.选择结构程序设计

4.1 if语句

#include<stdio.h> int main(void) { int score; scanf("%d",&score); if(score>700) { printf("qinhua\n"); } else { print("lanxiang\n"); } return 0; }

#include<stdio.h> int main(void) {    int score;    scanf("%d",&score);    if(score>700)   {        printf("qinhua\n");   }    else if(score>680)   {        print("beida\n");   }    else   {        print("lanxiang\n");   }    return 0; }

4.2 Switch语句

#include<stdio.h> int main(void) {    int a;    scanf("%d",&a);    switch(a);    //当Switch遇到break表示Switch结束   {        case 1:        printf("输入1\n");        break;        case1:        printf("输入2\n");        break;        default:        //默认选项：如果输入的值没有就走入default选项(相当于else)        printf("输入未知\n");        break;   }    return 0; }

4.3嵌套条件判断语句

#include<stdio.h> int main(void) {    int score;    scanf("%d",&score);        //条件判断语句嵌套    //else不能单独拿来使用，必须和同级别的尚未配对的if组合使用    if(score>700)   {        printf("qh\n");        if(score>720)       {            printf("wjj\n");       }        else if(score>710)       {            printf("cs\n");       }        else            printf("jsj\n");   }    else   {        printf("lanxiang\n");   }    return 0; }

• if语句可以判断一个区间，但执行效率比较低
• Switch语句的执行效率比较快，但不可以进行区间判断
• 三目/条件运算符结构清晰，担不适于嵌套

五.循环结构程序设计

5.1 for循环结构

#include<stdio.h> int main(void) { int i; for(i=1;i<10;i++) //初始化；判断；执行 { printf(“%d\n",i)； } return 0; }

#include<stdio.h> int main(void) { int i; int sun=0; fou(i=1;i<=100;i++) { sum+=i; } printf("1-100的和为：%d\n",sum); return 0; }

//敲7:凡是个位或十位带7，或7的倍数需要敲桌子 #include<stdio.h> int main(void) { int i; for(i=0;i<=100;i++) { if(i%7==0||i%10==7||i/10==7) //||为或者 //7的倍数,个位带7，十位带7 { printf("敲桌子%d\n"); } else { printf("%d\n",i); } } return 0; }

5.2 while和do while循环结构

5.2.1while循环

• 先判断再执行

#include<stdio.h> int main(void) { int i; while(i<10) //while(表达式)如果表达式为真 执行{}内的代码 //死循环：程序在执行循环时没有循环的出口(永真) { printf("%d\n",i); i++; } return 0; }

#include<stdio> int main(void) { int i=0; int sum=0; while(i<=100) { sum+=i; //sum=i+i i++; } printf("%d\n",sum); return 0; }

//水仙花数 从100到999直接是各个位数(个位 十位 百位)的立方和等于本身的数称为水仙花数 #include<stdio.h> int main(void) { int i=100; while(i<=999) { //拆解个位十位百位 a=i/100;//百位 b=i/10%10;//十位 c=i%10;//个位 if(a*a*a+b*b*b+c*c*c=i) { printf("水仙花数：%d\n",i); } i++; } return 0; }

5.2.2do while循环

• 先执行语句，无论条件成不成立，再进行循环条件的判断

#include<stdio.h> int main(void) { int i=0; do { printf("%d\n",i); i++; } while(i<10); //如果while条件不成立，会打印出一个0 return 0; }

#include<stdio.h> int main(void) { int i=100; int a,b,c; do { a=i/100; b=i/10%10; c=i%10; if(a*a*a+b*b*b+c*c*c=i) //导入头文件<math.h>，可以调用函数pow(a.3)表示a的3次幂 { printf("水仙花：%d\n",i); } i++； } while(i<=999); return 0; }

5.3 continue语句和break语句

5.3.1break语句

在Switch条件语句和循环语句中都可以使用break语句

• 当它出现在Switch条件语句中时，作用是终止某个case并跳出Switch结构
• 当他出现在循环语句中，作业时跳出当前内循环语句，执行后面的代码
• 当他出现在嵌套循环语句中，跳出最近的内循环语句-，执行后面的代码

#include<stdio.h> int main(void) { int i=0; //死循环 while(1) { printf("%d\n".i); } return 0; }

#include<stdio.h> int main(void) {    while   {        printf("%d\n".i);        i++;        it(i==0)       {            //如果满足条件跳出循环            break;       }   }    return 0; }

5.3.2continue语句

在循环中，如果希望立即终止本次循环，并执行下次循环，此时需要使用continue语句

#include<stdio.h> int main(void) {    int i=0;    while(i<=100)   {        //打印所有偶数        if(i%2!=0)       {            i++;            continue;       }        printf("%d\n",i);        i++;//不会执行这一部分   }    return 0; }

5.4 循环的嵌套

#include<stdio.h> int main(void) { int i,j; //外层执行一次，内层执行一次 //总体的循环次数即为外层循环次数乘以内层循环次数 for(i=0;i<10;i++) { for(j=0;j<10;j++) { printf("i=%d j=%d\n",i,j); } } return 0; }

#include<stdio.h> #include<Windows.h> #include<stblib.h> int main(void) { int i,j,k; for(i=0;i<24;i++) //时针 { for(j=0;j<60;j++) //分针 { for(k=0;k<60;k++) //秒针 { printf("%d:%d:%d\n",i,j,k); sleep(960);//系统延迟960秒 system("cls");//清屏 } } } return 0; }

#include<stdio.h> int main(void) { //九九乘法口诀 /* 1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 ... */ int i; int j; for(i=1;i<=9;i++) { for(j=1;j<=i;i++) { printf("%d*%d=%d",j,i,i*j); } printf("\n"); } return 0; }

六.数组的定义和引用

6.1 一维数组和二维数组的定义、初始化

在程序设计中，为了方便处理数据把具有相同类型的若干变量按有序形式组织起来–称为数组

数组就是在内存中连续的相同类型的变量空间。同一个数组的所以成员都是相同的数据类型，同时所有的成员在内层中的地址是连续的

数组属于构造数组类型：

这些数组元素可以是基本数据类型或构造类型

//数组的简单定义和使用 #include<stdio.h> int main(void) { //定义变量：数据类型 变量名=值 //定义数组：数据类型 数组名[元素个数] //都符合标识符的命名规则 int arr[10];//相当于定义10个整型变量 //使用数组下标，找到数组元素，为元素赋值 //数组下标是由0开始的 到数组元素个数-1为最大值9 arr[0]=123; arr[1]=234; arr[2]=345; arr[9]=8910; printf("%d\n",arr[0]); printf("%d\n",arr[1]); printf("%d\n",arr[2]); printf("%d\n",arr[9]); return 0; }

//在定义数组时直接为数组赋值 #include<stdio.h> int main(void) { int arr[10]={1,2,3,4,5,6,7,8,9,10}; printf("%d\n",arrr[0]); printf("%d\n",arrr[1]); printf("%d\n",arrr[2]); printf("%d\n",arrr[3]); printf("%d\n",arrr[4]); return 0; }

#include<stdio.h> int main(void) { int arr[10]={1,2,3,4,5,6,7,8,9,10}; int arr[10]={1,2,3,4,5};//只赋值一部分，其余部分值为0 int arr[10]={1};//第一个值为1，其余都为0 int arr[10]={0};//打印出来全为0 int arr[]={1,2,3,4,5,6,7,8,9,10};//根据有几个元素，[]里的值就为多少 int i; for(i=0;i<10;i++) { printf("%d\n",arr[i]); } return 0; }

6.1.1一维数组的定义和使用

定义和使用

• 数组名字符合标识符的书写规定(数组，英文字母，下划线)
• 数组名不能与其他变量名相同，同一作用域内是唯一的
• 方括号[]中常量表达式表示数组元素的个数，下标从0开始计算，第一个元素为arr[0]
• arr为数组名，不能为数组名赋值
• 定义数组[]内最好是常量，使用数组时[]内即可是常量，也可以是变量
• c语言不支持动态数组(数组必须在编译时定义长度，不可由键盘输入，因为必须定义其长度才可操作)

冒泡排序

//题目：十只小猪称体重，找到最大的小猪体重 #include<stdio.h> int main(void) {    int arr[10];    int i;    int temp=0;//临时变量，记录小猪最大体重    for(i=0;i<10;i++)   {        scanf("%d",&arr[i]);   }    for(i=0;i<10;i++)   {        if(temp<arr[i])       {            //记录最大小猪体重            temp=arr[i];       }   }    printf("最重的小猪体重：%d\n"，temp);    return 0; }

//冒泡排序 #include<stdio.h> int main(void) { int arr[10]={9,1,2,8,4,5,10,7,3,6}; int i,j; int temp; for(i=0;i<10-1;i++) { //每次内层循环可以确定一个有效的值 for(j=0;j<10-i-1;j++) { //在判断条件中如果是<号输出结果是降序 //如果是>号输出结果是升序 if(arr[j]<arr[i]) { temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } for(i=0;i<10;i++) { printf("%d\n",arr[i]); } return 0; }

6.1.2一维数组的初始化

二维数组的定义和使用

#include<stdio.h> int main(void) { //一维数组定义 //数据类型 数组名[元素个数] //二维数组定义 //数据类型 数组名[行][列] 行*列=数组元素个数 //外层控制行，内层控制列 int arr[4][3]= { {88,99,100}, {36,42,59}, {60,60,60}, {88,88,88} }; int i,j; for(i=0;i<4;i++) { for(j=0;j<3;j++) { printf("%d\n",arr[i][j]); } printf("\n"); } return 0; }

#include<stdio.h> int main(void) {        //要求：求出四名学生三门功课的总成绩和各个学科的总成绩    int arr[4][3]=   {       {88,99,100},       {36,42,59},       {60,60,60},       {88,88,88}   };    //求出每名学生的总成绩    int sum=0;    int i,j;    for(i=0;i<4;i++)   {        for(j=0;j<3;j++)       {            sum+=arr[i][j];       }        printf("第%d名学生的总成绩为：%d\n",i+1,sum);        sum=0;//重新初始化   }    //求出每个学科的总成绩    //将行和列颠倒    for(i=0;i<3;i++)   {        for(j=0;j<4;j++)       {            sum+=arr[j][i];       }        printf("第%d门学科的总成绩为：%d\n",i+1,sum);        sum=0;   }    return 0; }

6.1.3数组名

6.2 字符串与字符数组

• C语言中没有字符串这种数据类型，可以通过char的数组来替代
• 字符串一定是一个char的数组，但char的数组未必是字符串
• 数字0(和字符\0等价)结尾的char数组就是一个字符串。
• 但如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组，所以字符串是一种特殊的char的数组

6.2.1字符数组与字符串区别

6.2.2字符串的初始化

6.2.3字符串的输入输出

#include<stdio.h> int main(void) { //定义字符数组 char arr[10]={'h','e','l','l','o','w','o','r','l','d'}; int i; for(i=0;i<10;i++) { //打印字符 printf("%c",arr[i]); } printf("\n"); return 0; } int main01(void) { //定义字符串 字符串是用双引号""引起来的 char arr[12]="hello world"; char arr[10]={'h','e','l','l','o','w','o','r','l','d','\n'};//字符串 //在定义字符串时末尾会添加字符串结束标志\0，表示字符串的结束 char ch='a';//字符 char ch1[2]="a";//字符串，a后面其实还有一个省略的\0 //%s是一个占位符，表示输出一个字符，遇到\0是输出停止 printf("%s\n",arr); return 0; } //字符串的初始化 int main02(void) { //char arr[]={"helloworld"}; char arr[100]={0}; scanf("%s\n",arr);//scanf在接受数据时遇到空格或者换行表示结束 printf("%s\n",arr); return 0; }

6.2.4字符串比较

#include<stdio.h> int main(void) { char arr1[]={"hello world"}; char arr2[]={"hello world"}; int i=0; while(arr1[i]==arr2[i]) { //判断是否到字符串结尾，如果到字符串结尾之前的内容都相同，打印相同 if(arr[i]=='\0') { printf("两个字符串相同\n"); return 0; } i++; } printf("两个字符串不相同\n"); return 0; }

七.函数

C程序是由函数组成的。我们写的代码都是由主函数main()开始执行的。函数是C程序的基本模块，是用于完成特定任务的程序代码单元。

从函数的定义的角度看，函数可分为系统函数和用户定义函数两种：

• 系统函数，即库函数：这是由编译系统提供的，用户不必自己定义这些函数，可以直接使用他们，如打印函数printf()
• 用户定义函数：用以解决用户的专门需要

7.1 库函数的正确调用

• 导入头文件
• 使用库函数，例如printf,scanf

7.1.1函数的调用：随机数的产生

当调用函数时，需要关心5要素

• 头文件：包含指定的头文件
• 函数名字：函数名字必须和头文件声明的名字一样
• 功能：需要知道此函数等干嘛后才调用
• 参数：参数类型要匹配
• 返回值：根据需要接受返回值

#include<time.h> time_t time(time_t*t) 功能：获取当前系统时间 参数：常设置为null 返回值：当前系统时间，time_t相当于long类型，单位为毫秒 #include<stdlib.h> void srand(unsigned int seed); 功能：用来设置rand()产生随机数时的种子 参数：如果每次seed相等，rand()产生随机数相等 返回值：无 #include<stdlib.h> int rand(void); 功能：返回一个随机数值 参数：无 返回值：随机数

#include<stdio.h> //1.导入两个头文件 #include<stdlib.h> #include<time.h> int main(void) {    int i;    //2.创建随机数种子 time获取当前系统时间 让当前时间作为随机数种子    stand((unsigned int)time(NULL));    //3.生成随机数    //0-9之内的随机数    for(i=0;i<100;i++)   {        printf("%d",rand()%10);//0-9之内的随机数   }    return 0; }

#include<stdio.h> #include<stdlib.h> #include<time.h> //小游戏：猜数字，随机一个1-100之间的数，通过键盘输入数据，根据数据输入进行提示 int main(void) {    int value;//用户输入的数值    int num;//随机数    srand((unsigned int)time(NULL));    num=rand()%100+1;//0-99    while(1)   {        scanf("%d",&value);        if(num>value)       {            printf("您输入的数太小了\n");       }        else if(num<value)       {            printf("您输入的数太大了\n");       }        else       {            printf("恭喜你，猜对了\n");            break;       }   }    return 0; }

7.2 函数的定义方法

7.2.1函数定义格式

函数定义的一般形式：

返回类型 函数名(形式参数列表) { 数据定义部分; 执行语句部分; }

#include<stdio.h> //pow(x,y) //使用函数的优点：提高代码阅读性 减少代码冗余 //函数格式 //返回值类型 函数名(函数参数列表) //{ // 代码题 // 返回值 //} //函数定义 如果有多个函数参数 需要使用，逗号隔开 //在函数定义时，函数的参数没有具体赋值 只有一个数据类型 是一个形式上的参数 简称形参 int add(int a,int b) { int sum=a+b; return sum; } int main(void) { int a=10; int b=20; //函数调用(函数的使用过程) int sum; sum=add(a,b); printf("%d\n",sum); return 0; }

7.2.2函数名、形参列表、函数体

1.函数名

• 理论上可以随便取，最好见名知意
• 函数名后面的圆括号()，代表这个为函数，不是普通的变量名

2.形参列表

• 在函数定义时指定的形参，在未出现函数调用时，它们不占内存中的存储单元，因此称它们是形式参数或虚拟参数，简称形参
• 它们并不是实际存在的数据，所以，形参里的变量不能赋值，用来接受函数调用时产生的实际参数

3.函数体

• 花括号{}里的内容即为函数体的内容，这里为函数功能实现的过程
• 这个main()道理一样

7.3 函数的类型和返回值

7.3.1无参函数调用

#include<stdio.h> //无参函数 void_printf() { printf("daddy\n"); //没有返回值可以不写return } int main(void) { //函数调用 _printf(); return 0; } 

7.3.2有参函数调用

#include<stdio.h> void pintf_int(int value) { printf("d\n",value); return; } int main(void) { printf_int(100); return 0; }

7.3.3返回值

• 函数的返回值是通过return语句获得的，return后面的值也可以是一个表达式
• 尽量保障return语句中表达式的值和函数返回类型是同一类型
• 如果函数返回的类型和return语句中表达式的值不同，则以函数返回值为准，即函数返回类型决定返回值类类型。对数值型数据，可自动进行类型转换
• 注：如果函数返回的类型和return语句中表达式的值不一致，而它又无法自动进行类型转换，程序则会报错
• return语句的另一个作用为中断return所在的执行函数，类似于break中断循环、Switch语句一样
• 一个函数中可以出现多个return
• 如果函数带返回值，return后必须跟一个值，如果函数没有返回值，函数名字的前面必须写一个void关键字，这时候，我们写代码时也可以通过return中断函数(也可以不用)，只是这时。return后不带内容(;除外)

7.4 形式参数与实在参数,参数值的传递

7.4.1函数的形参和实参

• 形参出现在函数体定义中，在整个函数体内都可以使用，离开函数体则不能使用
• 实参出现在主调函数中，进入被调函数后，实参也不能使用
• 实参变量对形参变量的数据传递时”值传递”，即单向传递，只由实参传给形参，而不能由形参传回来给实参
• 在调用函数时，编译系统临时给形参分配存储单元。调用结束后，形参单元被释放
• 实参单元与形参单元是不同的单元。调用结束后，形参单元被释放，函数调用结束返回主调函数后则不能再使用该形参变量。实参单元仍保留并维持原值。因此，在执行一个被调用函数时，形参的值如果发生改变，并不会改变主函数中实参的值。

#include<stdio.h> //在函数中实现两个变量的交换 void swap(int a,int b) {    int temp=a;    a=b;    b=temp;    printf("交换后数据：\n");    printf("a=%d\n",a);    printf("b=%d\n",b); } //值传递 形参不能改变实参的值 //地址传递 形参不能改变实参的值 int main(void) {    int a=10;    int b=20;    printf("交换前数据：\n");    printf("a=%d\n",a);    printf("b=%d\n",b);    swap(a,b);    //在函数调用结束后 实参变量的值会不会改变    return 0; }

7.4.2函数的执行流程

栈区的内存维护过程

7.5 函数的正确调用、嵌套与递归

7.5.1函数的调用

#include<stdio.h> //函数执行过程： //1.函数声明 //2.函数定义 //函数声明 告诉编译器该函数存在 //extern int max(int a,int b); //extern声明，可以忽略不写 //int max(int a.int b); int main(void) {    int a;    int b;    int value;    value=max(a,b);    printf("输出最大值为：%d\n",value);    return 0; } int max(int a,int b) {   return a>b?a:b; } //命名 //1.int bubble_sort() void BubbleSort(int arr[],int len) {    int i,j;    for(i=o;i<len;i++)   {        for(j=0;j<len-i-1;j++)       {            if(arr[j]>arr[j+1])           {                temparr[j];                arr[j]=arr[j+1];                arr[j+1]=temp;           }       }   }    return; } int main(void) {    int i;    int arr[]={8,1,9,5,2,7,10,6,4,3};    BubbleSort(arr,10);    for(i=0;i<10;i++)   {        printf("%d\n",arr[]);   }    return 0; }

7.5.2函数嵌套和递归

#include<stdio.h> int testB(int a,int b) { return a+b; } int testA(int a,int b) { return testB(a,b); } int main(void) { int a=10; int b=20; int sum; sum=testA(a,b); printf("%d\n",sum); return 0; }

//函数递归调用 //函数的递归调用指的是调用函数本身 //正在函数递归调用时需要有函数的出口 //递归函数在栈区内存中占有资源比较多 //栈是先进后出 //再考式中没有特殊要求一般不用 #incude<stdio.h> void fun(int a) {    //函数的出口    if(a==0)       return;    fun(a-1);    printf("%d\n",a); } int main(void) {    int a=10;    fun(a);    return 0; }

7.6 局部变量与全局变量

7.6.1局部变量

局部变量也叫auto自动变量(auto可写可不写)，一般情况下代码块{}内部定义的变量都是自动变量，它有如下特定：

• 在一个函数内定义，只在函数范围内有效
• 在复合语句中定义，只在复合语句中有效
• 随着函数调用的结束或复合语句的结束局部变量的声明声明周期也结束
• 如果没有赋初值，内容为随机

#include<stdio.h> //在不同函数内局部变量名可以相同 void test() {    int a=123;    printf("%d\n",a); } int main(void) {    //局部变量    //作用域：在函数内部，从变量定义到函数结束    //auto int a=10;    int a=10;    test();    return 0; }

7.6.2全局变量

• 全局变量名可以和局部变量名重名
• 如果在函数内部定义了局部变量，全局变量不起作用，编译器会采用就近原则

#include<stdio.h> //在函数外部定义变量称为全局变量 //全局变量作用域是整个项目中所有文件，如果在其他文件中使用需要加入声明 extern int a; int a=; void test() {    int a=123;    printf("%d\n",a); } int main(void) {    //在函数中改变全局变量的值会影响    printf("%d\n",a);    test();    return 0; }

八.编译预处理

8.1 宏定义和调用(不带参数的宏,带参数的宏)

8.1.1无参数的宏定义(宏常量)

如果在程序中大量使用到了100这个值，那么为了方便管理，我们可以将其定义为：

const int num=100;

但是我们如果使用num定义一个数组，在不支持C99标准的编译器上是不支持的，因为num不是一个编译器常量，如果想得到了一个编译器常量，那么可以使用：

#define num=100;

在编译器预处理时，将程序中在该语句以后出现的所有的num都用100代替。这种方法使用户能以一个简单的名字代替一个长的字符串，在预编译时将宏名替换成字符串的过程称为”宏展开”。宏定义，只在宏定义的文件中起作用。

#include<stdio.h> #define NUM 100 #define SUM NUM+10 //常量习惯于用大写 //在编译时，会将NUM替换为100 int main(void) {    //const int NUM=100    printf("%d\n",NUM);    printf("%d\n",NUM*10);    printf("%d\n",SUM);    //NUM不能被赋值    return 0; }

说明：

• 宏名一般用大写，以便于与变量区别
• 宏定义可以是常熟、表达式等
• 宏定义不作语法检查，只有在编译被宏展开后的源程序才会报错
• 宏定义不是C语言，不在行末加封号
• 宏名有效范围为从定义到本源文件结束
• 可以用#undef命令终止宏定义的作用域
• 在宏定义中，可以引用已定义的宏名

8.1.2带参数的宏定义(宏函数)

在项目中，经常把一些短小而又频繁使用的函数写成宏函数，这是由于宏函数没有普通函数参数压栈、跳转、返回等的开销，可以调高程序的效率。

宏通过参数，可以创建外形和作用都与函数类似的类函数宏，宏的参数也用圆括号括起来。

#include<stdio.h> #define SUM(x,y) (x+y) //带参数的宏定义一般加上圆括号,防止运算符的优先级别导致代码出错 //因为宏定义展开是将内容原封不动的替换 //加与不加括号结果不同 int main(void) {    int a=10;    int b=20;    int sum;    //sum=SUM(a,b)*30;    //sum=(10+20)*30    //sum=SUM(a,b);    sum=SUM(a,b)*30;    //把上面的括号去掉结果为610    //sum=10+20*30    printf("%d\n"sum);    return 0; }

#include<stdio.h> #define MAX(x,y) ((x>y)?(x):(y)) int main(void) {    int a=10;    int b=20;    int value;    value=MAX(a,b);    printf("%d\n",value);    return 0; }

8.2 文件包含处理

8.2.1文件包含处理

8.2.2#include<>和#include””

• “”表示系统先在filel.c所在的当前目录找filel.h，如果找不到，再按系统指定的目录检索
• <>表示系统直接按系统指定的目录检索
• 注：1.#include<>常用于包含函数的头文件

  2.#include””常用于包含自定义的头文件

  3.理论上#include可以包含任意格式的文件(.c.h等)，但一般用于头文件的包含

#include<stdio.h> #include"head.h" //表示导入系统的头文件 //""表示导入用户自定义头文件 int main(void) {    printf("%d\n",a);    return 0; }