C语言基础知识复习资料
C语言的历史背景及特点
一、C语言的历史背景
1、 什么是C语言
C语言是国际上广泛流行的，很有发展的前途的计算机高级语言，它适合于作为系统描述语言，既可用来写系统软件，也可用来写应用软件的一种高级语言之一。
2、C语言的产生的历史背景
C语言是在1973年间，贝尔实验室的D.M.Ritchie在B语言的基础上发展起来的，它保持了BCPL和B语言的优点:精练、接近硬件，又克服了它们的缺点：过于简单，数据无类型等。
二、Ｃ语言的特点
1、语言简洁、紧凑、使用方便、灵活。
2、运算符丰富。
3、数据结构丰富，具有现代化语言的各种数据结构。
4、具有结构化的控制语句。
5、语法限制不太严格，程序设计自由度大。
6、C语言允许直接访问物理地址。
7、生成目标代码质量高，程序执行效率高。
8、用C语言写的程序可移植性好。
简单的C程序介绍及C程序的上机步骤
一、简单C程序介绍（学会读懂一个简单的C程序）
#include<stdio.h> à函数头
main( ) à主函数
{int a,b,sum; à定义变量
a=123；b=456; à以下3行为C语句
sum=a+b;
printf(“sum is %d\n”,sum);
}
二、C程序的上机步骤
补充概念:
1、程序:就是一组计算机能识别和执行的指令。
2、源程序:用高级语言编写的程序称为“源程序”。
3、目标程序:用“编译程序”将源程序编译成二进制形式，形成可执行的程序叫做目标程序。
C程序的上机步骤（实操讲述）
1、打开Turbo C程序，输入源程序
2、按Ctrl+F9进行调试，查看结果
3、保存源程序
打开源程序的方法:
1、打开Turbo C程序，单击File菜单，选择Open命令
2、在弹出的对话框中输入要打开的源程序路径，单击OK按钮即可。
保存源程序的方法：
1、单击File菜单，选择Save 命令,
2、在弹出的对话框中输入要保存的源程序路径，单击OK按钮即可。
C语言的数据类型（一）
一、一个C语言程序应包括的内容
1、对数据的描述：在程序中要指定数据的类型和数据的组成形式。
2、对操作的描述：即操作步骤，也就是算法。
故：数据结构+算法＝程序
若采用结构化的程序设计方法进行程序设计时，关且用某一种计算机语言来表示时：
程序＝算法+数据结构+程序设计方法+语言工具和环境
C语言的常量和变量
一、常量和符号常量：
1、什么是常量：
在程序运行过程中，其始终保持不变的量称为常量（整型、实型、字符常量）
2、什么是和符号常量：
用一个标识符代表一个常量的，称为和符号常量。即采用标识符形式的常量。
3、宏定义:用一个指定的标识符（即名字）来代表一个字符。
格式：#define 标识符 字符串
例如：#define PI 3.1415926
二、变量和标识符
1、什么是变量
在程序运行过程中，其值是可以改变的量称为变量．
2、什么是标识符:用来标识变量名、符号常量名、函数名。数组名等的有效字符序列称为标识符。简单地说，标识符就是一个名字。
3、标识符的命令方法：
C语言规定:标识符只能由字母、数字和下划线三种字符组成．且第一个字符必须为字母或下划线。关键字不能作为标识符。
整形数据
一、整形数据在内存中的存放形式
整形数据在内存中的存放形式：以二进制形式存放。
例如：int i;i=10;
整型常量的表式方法：
1、十进制：0、－111；2、八进制：－0111、021；3、十六进制：0x21、+015
二、整型数据的类型
三、整型数据的定义方法
数据类型符 变量名1，变量名2，…；
例如：int a,b,c;
实型数据
一、实型常量表示方法：实数又称为浮点数。实数的表示主要有两种形式
（1）：十进制小数形式。由数字和小数点组成（注意必须有小数点）。
例如:123.0；0.0
（2）：指数形式。
例如：123e3或123E3都代表123×103
注意：e（或E）前后必须有数字，且e（或E）之后的数必须为整数。
二、实型数据在内存中存放形式：一个实型数据在内存中占4个字节（32位）
三：实型变量的分类
三、实型变量的定义；
格式：数据类型符 变量名1，变量名2，…；
例如：float x,y,z；
注意：float只能保证6位有效数据
字符型数据
一、字符常量：
1、什么是字符常量：
C的字符常量是用单引号括起来的一个字符。
例如：’a’
2、常用转义字符及含义：
\nà 换行，将当前位置移到下一行开头；\tà水平制表（跳到下一个tab位置）
\bà退格，将当前位置移到前一列；\rà回车，将当前位置移到本行开头
\fà换页，将当前位置移到下页开头；\dddà1到3位8进制数所代表的字符
\xhhà1到2位16进制数所代表的字符
二、字符变量
1、字符变量的作用：用来存放字符常量
字符变量的定义形式：
例如：char c1,c2;
c1=’a’,c2=’b’;
注意：字符变量在内存中占一个字节
三、字符常量：
注意：1、字符串常量是一对双引号括起来的字符序列。
2、不能把一个字符串赋给一个字符变量
‘a’和”a”的区别：
1、每一个字符串的结尾加一个“字符串结束标志”，以便于系统判断字符串是否结束。
2、以字符’\0’（空操作字符）作为字符串结束标志。
变量的定义与赋值
一、变量的定义：变量的定义是由变量定义语句实现的。
1、变量定义语句的一般格式：
类型标识符 变量名1，变量名2，变量名3……；
例如：int I,j,k; float x1,y1; char w_1,w_2;
2、定义变量应注意以下几点：
（1）变量名应遵守标识符的命名规则。
（2）变量必须“先定义、后使用”。
（3）在同一种程序中变量名不允许被重复定义。
（4）凡未被定义的标识符，不得作为变量名全使用。
（5）每一个变量只能定义为一种类型，编译时编译时将据此为其分配相应长度的存储单元。
（6）变量的数据类型必须也将要进行的操作匹配。
二、变量赋值
变量使用“＝”赋值。变量在定义时可以赋初值，定义后可以连续赋值
1、给变量赋值时应注意以下几点
（1）赋值时“＝”右边的常量（或表达式结果）与左边的变量类型应当匹配。
（2）定义时不能连续赋值。
（3）字符串常量不能赋值给字符变量、整型变量或实型常量。
C语言运算符与表达式的分类
一、运算符：运算符是表明运算操作的符号。
1、C语言中常见的运算符。
（1）按运算类型和目的分：
①算术运算符：+ - * / % _ ++ --
②关系运算符：> < == >= <= !=
③逻辑运算符：！ && Ⅱ
④位运算符：<< >> & Ⅰ ~ ^
⑤赋值运算符：＝ += -= *= /= %= >>= <<= &= Ⅰ= ^=
⑥条件运算符：？ ：
⑦逗号运算符指：，
⑧指针与地址运算符：* &
⑨求字节数运算符：
（2）按要求运算对象的个数分：
①单目运算符：！~ - ++ -- (类型标识) * & sizeof
②双目运算符：* / % + - << >> < > <= >= == != & ^ Ⅰ && Ⅱ =
+= _= *= /= %= >>= <<= &= Ⅰ= ^=
③三运算符: ? :
:? =<<= &= < >> < > <= >= == !④其他： （） [] _> ,
二、表达式：表达式是由操作数（操作对象）和运算符组成的序列
例如:赋值表达式、算术表达式、逻辑表达式、关系表达式、条件表达式等。
C语言运算符优先等级口诀
一、运算符优先级等级口诀
圆方括号、箭头一句号，自增自减非反负、针强地址长度，
乘除，加减，再移位，
小等大等、等等不等，
八位与，七位异，六位或，五与，四或，三疑，二赋，一真逗。
其中“，”号为一个等级分段。
二、运算符优先级等级注释
“圆方括号、箭头一句号”指的是第15级的运算符。其中圆方括号很明显“（）、[]”，箭头 指的是指向结构体成员运算符“->”，句号 指的是结构体成员运算符“.” ；
“自增自减非反负、针强地址长度”指的是第14级的运算符。其中 非 指的是逻辑运算符“!”，反 指的是按位取反运算符“~”，负 指的是负号运算符“－”，针 指的是指针运算符“*”，强 指的是强制类型转换运算符，地址 指的是地址运算符“&”，长度 指的是长度运算符“sizeof ”；
“乘除，加减，再移位”移位指的是左移运算符“<<”和右移运算符“>>”，其中除法还包括了 取余运算符“%”；
“小等大等、等等不等” 指的是第10级到第9级的运算符：<、<=、>和>=，等等指的是等于运算符==，不等指的是不等于运算符!=
“八位与，七位异，六位或”其中 八位与 指的是第8级的 按位与 运算符“&”，七位异 指的是第7级的按位异或 运算符“^”，六位或 指的是第6级的按位或运算符“|”；
“五与，四或”指的是第5级、第4级的逻辑与运算符“&&”和逻辑或运算符“||”；
“三疑，二赋，一真逗”指的是第3级到第1级的运算符。其中，三疑指的是条件运算符“？：” （三有双重含义：即指优先级别是三，它的运算符类型也是三目，疑也取“?”之意），二赋 指的是赋值运算符=、+=、-=、*=、/=、%=、>>=、<<=、&=、^=和|= ，一真逗 指的是第1级的“，”运算符，真字只是为了语句需要罢了。
由于C语言的运算符优先级与C++的不完全一样(主要是增加了几个运算符)，所以这个口诀不能完全实用于C++.但是应该能够兼容，大家可以比较一下他们的区别应该就能够很快掌握C++的优先级的！
运算符
一、什么是运算符:用来表示各种运算的符号
二、单目运算符:只有一个运算对象的,称为单目运算符
例如:++a,--4
三、双目运算符:只有二个运算对象的,称为双目运算符.
例如:5+6 2+3
四、三目运算符: 只有三个运算对象的,称为三目运算符
例如:?表示式 x?45:12
五、什么表达式:用运算符把运算对象连接起来所组成的运算式称为表达式。
六、C语言中的运算符：基本运算符和专用运算符
1．基本运算符：
算术运算：+ - * / %（取模运算）
5%4=1
关系运算符： < <= > >= == !=(不等于)
逻辑运算符：！ && ||
赋值运算符：基本赋值运算符（=），算术自反赋值运算符（+=，-=，*=，/=，%=）
例如：a+=b等同于a=a+b;
逗号运算符：（，）
条件运算符：（？：）
数值长度运算符：sizeof()
位运算符：位逻辑运算符（~ — |）,位移位运算符（>> <<）,位自反赋值运算符（&= ||= ^= >>= <<=）
2．专用运算符：强制运算符：（），下标运算符[]，成员运算符:-> . 指针运算符（& * + -）
算术运算符
一、算术运算符
自增、减运算符
一、单目前缀：先计算(本身进行自增、自减)，再使用对象
例如：++a --b int a=5；++a+6 =12
二、单目后缀：先使用对象，本身再进行自增、自减。
例如：a-- b++
三、例题讲解
int a=6
a--+3=9
设变量定义如下：
int n=10,m=3;
float f=5.0,g=10.0;
double d=5.0,e=10.0;
则：
1、 n+m、n-m、n*m、n%m的结果分别是：
2、 f+g、f-g、f*g、f/g的结果分别是：
3、 d+e、d-e、d*e、d/e的结果分别是：
4、 n+m-f*g/d的结果分别是：
10+3－5.0*10.0/5.0
5、 n%m*f*d的结果分别是：
设变量定义如下：
int a=3,b=3;
char c1=’b’=98,c2=’B’=66;
则：
1、表达式：++a-1的值是 3 ，运算结束后变量a的值是4
2、表达式：b--+1的值是 4 ，运算结束后变量b的值是2
3、表达式：++c1-1的值是 98 ，运算结束后变量c1的值是
4、表达式：c2--+1的值是 67或C ，运算结束后变量c2的值是
5、表达式：(a++)+(a++)的值是 6 ，运算结束后变量a的值是
6、表达式：(b--)-(b--)的值是 0 ，运算结束后变量b的值是
7、表达式：（a++）+b的值是 6 ，运算结束后变量a的值是
b的值是
8、表达式：（a--）-b的值是 ，运算结束后变量a的值是
b的值是 3
9、表达式：（a++）+（b++）的值是 ，运算结束后变量a的值是
b的值是
关系运算符和逻辑运算符
一、关系运算符：
1、关系运算符的运算方法：
（1）关系运算符用来比较两个数据的大小，
（2）如果运算结果是逻辑值“真”（即关系式成立）用数“1”表示：
（3）如果运算结果是逻辑值“假”（即关系式不成立）用数“0”表示
二、关系运算符种类
1、小于（<）、小于或等于（<=）、大于或等于(>=)、等于(==)、不等于(!=)
2、关系运算符的优先级:
（1）算术运算符优先于关系运算符
（2）小于（<）、小于或等于（<=）、大于或等于(>=)优先于等于(==)、不等于(!=)。
例题：
设定义变量如下：
char c1=’a’,c2=’A’
int n1=65,n2=97;
float f1=0.3E1,f2=3.0001;
1、表达式c1>c2、n1==n2、f1>f2的值依次是：
2、表达式c1>=n1、c2>==n2、c1==n2的值依次是：
3、表达式f1>c1、f1<c2、f1!=n1-60的值依次是：
三、逻辑运算符
1、逻辑运算符种类及运算方法：
（1）！à逻辑非：“！”是单目运算符，其运算规则是：若操作数的值为0，则其“！”运算结果为1（逻辑真）；若操作数值为非0，则其“!”运算结果为0。
注意：!1＝0； !0＝1
（2）“&&” à逻辑与：是双目运算符。其运算规则是：当参加“&&”运算的2个操作数值均为非0（逻辑真）时，结果才为真：否则为0（逻辑假）。
注意：1&&1=1 1&&0=0 0&&0=0
（3）“||” à逻辑或：“||”是双目运算符：其运算规则是：参加“||”运算的两个操作数中，只要有一个操作数值为非0（逻辑真），结果就为1（逻辑真）；否则为0（逻辑假）。
注意：1||1=1 1||0=1 0||1=1 0||0=1.
位运算符和强制类型转换
一、位运算符的种类
1、&à位与； 2、|à位或； 3、^à位异或；
4、~à位取反； 5、<<à位左移； 6、>>à位右移；
二、位运算符的运算规则：
特别注意：位运算符一般都是以整数按补码形式存储的，位运算都双目运算符。
1、&à位与的运算规则：将参加运算的两个数按位进行“与”运算。
2、|à位或的运算规则：将参加运算的两个按位进行“或”运算。
3、^à位异或的运算规则：将参加运算的两个按位进行“异或”运算。
4、~à位取反的运算规则：将参加运算的两个按位进行“取反”运算。
5、<<à位左移的运算规则：将操作数的各二进位全部左移若干位。
6、>>à位右移的运算规则：将操作数的各二进位全部右移若干位。
三、强制类型转换
1、含义与实现
强制类型转换是指使用强制类型转换运算对一个表达式进行的数据类型转换。主要用于将表达式的结果类型转换为类型说明符所指定的类型。
一般格形式：
（类型名）（表达式）
例如：
（1）、（double）aà将a的值转换成double型。
（2）、（int）（a+b）à将a+b的值转换成整int型。
（3）、（float）(10%3)à将10%3的值转换成float型。
条件运算符和逗号运算符
一、？号表达式：
1、符号、作用与一般格式
（1）：条件运算符由符号“？”和“：”组成而成，它们与3个操作数组成三目运算。主要用于完成简单的二分支选择操作（例如给同一个变量时时行二分支选择赋值）
格式：<表达式1>？<表达式2>：<表达式3>
例如：c=a<b?a-1:b；z=a>b?’A’:’B’；a>b?printf(“a>b”):(d=a+b)
（2）：?号表达式的执行过程：
先求解表达式1，如果表达1的结果为真（非0）则求解表达式2，并将表达式2的结果作为整个表达式的值；否则求解表达式3，并以表达式3的结果作为整个表达式的值。
二、逗号运算符
1、符号、作用与一般格式
（1）：逗号运算符“，” ，又称顺序求值运算符。主要用于将两个或多个表达式连接起来并从左到右求解。
格式：表达式1，表达式2、……，表达式n
例如：A+b，a+c、a=1，b=2，c=3，(a+b)*c
（2）：?号表达式的执行过程：
先求解表达式1，从左到右分别计算各表达式的值，即先求解表达式1，再求表达式2，…，最后求解表达式n。逗号表达式以最后个表达式n的值作为整个表达式的值。
例如：a=1,b=2,c=3,(a+b)*c的值为9
三、求字节长度运算符
1、符号、作用与一般格形式
（1）求字节长度运算符“sizeof”是一个单目运算符，主要用于求得其后变量或括号中的数据类型或括号中的表达式结果在内存中所占的字节数。
一般格式：
sizeof(变量名)
sizeof(类型名)
sizeof(表达式)
例如：sizeof(char)
sizeof(i)
sizeof(‘a’+’b’)
C语句概述
一、Ｃ语言中常用的Ｃ语句：
（1）控制语句：
作用：完成一定的定义控制功能。
例如：
1、if() elseà条件语句。 2、for（）à循环语句 3、while()à循环语句
4、do while()à循环语句 5、continueà结束本循环语句
6、breakà中止执行switch或循环语句 7、switchà多分支选择语句
8、gotoà转向语句 9、returnà从函数返回语句
（2）函数调用语句
（3）表达式语句
例如：a=3；
（4）空语句
即只有一个分号的语句，它什么也不做。有时用来做被转向点，或循环体。
（5）可以用{}把一些语句括起来成为复合语句又称分程序。
程序的三种基本结构及赋值语句
一、顺序结构
顺序结构执行的原理：见书本45页图3.2.先执行A操作，再执行B操作，两者是顺序执行的关系。
二、选择结构：
选择结构执行原理：见书本45页图3.3.P代表一个条件，当P条件成立（或称为“真”）时执行A，否则执行B。
注意：只能执行A或B之一。两条路径汇合在一起然后出口。
三、循环结构
（1）当型循环语句：见书本46页图3.4当条件成立（“真”）时，反复执行A操作。直到P为“假”时才停止循环。
（2）直到型循环语句：见书本46页图3.5先执行A操作，再判断P是否为“假”，若P为“假”，再执行A，如此反复，直到P为“真” 为止。
1、含义与实现
强制类型转换是指使用强制类型转换运算对一个表达式进行的数据类型转换。主要用于将表达式的结果类型转换为类型说明符所指定的类型。
（3）多分支选择结构语句：见书本46页图3.6，根据K的值(K1,K2,…，Kn)不同而决定执行A1，A2，…，An
四、赋值语句：
（1）赋值语句的构成：由赋值表达式加上一个分号构成。
例如：if((a=b)>0) t=a
数据输入与输出
一、C语言中输入与输出的概念：
所谓输入输出是以计算机主机为主体而言的。从计算机向外部输出设备输出数据称为“输出”，从外部向输入设备输入数据称为“输入”。
二、字符数据输入与输出：
1、字符输出函数putchar();
功能：putchar（）函数是字符输出函数，其功能是在显示器上输出单个字符。
一般格式为：putchar(整形变量)
2、字符输入函数getchar
功能：getchar（）函数是字符输入函数，其功能是从键盘上输入一个字符，它的返回值为整型。
一般格式为：getchar();
例如：int c;
c=getchar();
表示：从键盘读入一个字符，并且它只能接受单个字符。
（1）：逗号运算符“，” ，又称顺序求值运算符。主要用于将两个或多个表达式连接起来并从左到右求解。
格式：表达式1，表达式2、……，表达式n
三、格式输入与输出：
1：printf函数（格式输出函数）
一般格式：printf(格式控制,输出表列)
（1）“格式控制”是用双引号括起来的字符串，也称“转换”控制字符串，它包括两种信息。
第一：格式说明，“%”和格式字符组成，如%d,%f等。它的作用是将输出的数据转换成指定格式输出。格式说明总是由“%”字符开始的。
第二：普通字符：即需要原样输出的字符。例如：逗号，空格等。
（2）“输出表列”是需要输出的一些数据。可以是表达式
2、格式字符：
（1）d格式符。用来输出十进制整数。
%dà按整型数据的实际长度输出。
%mdàm为指定的输出字段的宽度。如果数据的位数小于m，则左端补以空格，若大于m，则按实际位数输出。
（2）o格式符，以八进制数形式输出整数。
（3）x格式符，以十六进制数形式输出整数。
（4）u格式符，用来输出 unsigned型数据，即无符号数，以十进制形式输出。
（5）c格式符，用来输出一个字符。 （6）s格式符，用来输出一个字符串，
（7）f格式符，用来输出实数，以小数形式输出。
%m.nfà指定输出的数据占m列，其中有n位小数。如果数值长度小于m,则左端补空格。
（8）e格式符，以指数形式输出实数。
（9）g格式符，用来输出实数，它根据数值的大小，自动选f格式或e格式，且不输出无意义的零。
数据输入与输出（二）
一、scanf函数（格式输入函数）
1、一般格式：
scanf(格式控制，地址表列)
格式控制的含义同 printf函数；地址表列是由若干个地址组成的表列，可以是变量的地址，或字符串的首地址。
2、格式说明
%dà用来输入有符号十进制整数。 %oà用来输入无符号的八进制整数。
%cà用来输入单个字符。 %sà用来输入字符串。
%fà用来输入实数，可以用小数形式或指数形式输入。
2、使用scanf函数时应注意的问题
（1）scanf函数中的“格式控制”后面应当是变量地址，而不应是变量名。
（2）如果在“格式控制”字符串中除了格式说明以外还有其他字符，则在输入数据时应输入这些字符相同的字符。
（3）在用“%c”格式输入字符时，空格字符和“转义字符”都作为有效字符输入。
（4）在输入数据时，遇（空格，回车、跳格（Tab）,按指定的宽度结束、遇非法输入）情况进该数据认为结束。
顺序结构程序设计举例
一、例3.10 输入三角形的三边长，求三角形的面积
#include<math.h>
main()
{float a,b,c,s,mj;
scanf(“%f,%f,%”f,&a,&b,&c);
s=1.0/2*(a+b+c);
s=sart(s*(s-a)*(s-b)*(s-c));
printf(“a=%7.2f,b=%7.2f,c=%7.2f,s=%7.2\n”,a,b,c,s);
printf(“mj=%7.2f\n”,mj);
}
二、例3.11 从键盘输入一个大写字母，要求改用小写字母输出
#include<stdio.h>
main()
{char c1,c2;
c1=getchar();
printf(“%c\t%d\n”,c1,c2);
c2=c1+32;
printrf(“%c\n%d\n”,c2,c2);
}
if语句
一、单分支if选择语句：
格式：if (表达式) 语句；
功能：计算机表达式的值
执行方法:如果表达式为真（非0），则执行“语句” ，否则不执行语句。
例如：输入一个字符，是字母则输出“YES！” ，否则无输出。
#include<stdio.h>
main()
{char c;
scanf(“%c”,&c);
if (c>=’a’&&c<=’z’||c>=’A’&&c<=’Z’)
printf(“YES!\n”);
}
二、双分支if选择语句：
格式：if (表达式) 语句1；
else 语句2；
功能：计算机表达式的值
执行方法:如果表达式为真（非0），则执行“语句1” ，否则执行“语句2” 。
例如：输入一个字符，是字母，则输出“YES!” ；否则输出“NO！” 。
#include<stdio.h>
main()
{char c;
scanf(“%c”,&c);
if (c>=’a’&&c<=’z’||c>=’A’&&c<=’Z’)
printf(“YES!\n”);
else
printf(“NO!\n”);
}
三、第三种if语句：
一般形式：
if(表达式1) 语句1；
else if(表达式2) 语句2；
else if(表达式3) 语句3；
……
else if(表达式m) 语句m；
else 语句n；
执行方法：从上到下逐个对条件进行判断，满足条件就执行，不满足就跳过。如果都不满足，则执行最后一个else
例如：见书本69页。
if嵌套语句
一、if嵌套语句：
基本格式：
if ()
if() 语句1
else 语句2
else
if() 语句3
else 语句4
注意：if与else的配对关系。else总是与它上面的最近的if配对。
例如：有一函数：
-1 (x<0)
y= 0 (x=0)
1 (x>0)
编一程序，输入一个x的值，输出y值。
#include<stdio.h>
main()
{int x,y;
scanf(“%d”,&x);
if(x<0) y=-1;
else if(x==0) y=0
else y=1;
printf(“x=%d,y=%d\n”,x,y);
}
用switch语句实现选择
一、switch语句的一般形式：
switch语句是从多种可能的情况中选择满足条件的一种情况执行的多分支选择结构。程序中实现从两种以上情况中选一执行可以用多重嵌套的if语句，但不如用switch语句逻辑简单、结构清楚。
switch语句的一般形式为：
switch（表达式）
{ case 常量表达式1：语句组1；break:
case 常量表达式2：语句组2；break:
……
case 常量表达式n：语句组n；break:
default：语句组n+1：
}
功能：计算表达式的值，如果该值和常量表达式对应的值相同，则执行相应的语句组后结束。如果和每一个常量表达式的值都不相同，则执行语句组n+1后结束。
二、switch语句的使用要点：
1、表达式常用的是字符型或整型表达式。
2、常量表达式是由常量或符号常量组成的表达式，所有常量表达式的值必须互不相同。
3、语句组是由若干个语句组成的，其中的语句可以是任何C语言语句（除定义语句），当然驰可以是另一个switch语句。
4、break 是C语言的一种语句，其功能是中断正在执行的语句，在switch语句中的作用是：执行完某一个语句组后，将退出switch语句，如果省略了break语句，则执行完某个语句组后，将连续执行其后的所有语句组。
5、default及其后的语句组可以省略。省略时，若表达式的值和n个常量表达式值均不相同，则该语句什么也不做。
例题：
main ( )
{int k=5,i=1;
switch(k)
{ case 1:i++;
case 3:i+=3;
case 5:i+=5;break;
default:i+=7;}
printf(“i=%d”,i);
}
while语句
一、循环结构的含义：
循环结构的含义是：重复执行某段程序，直到某个程序条件成为止的一种控制结构。循环结构有三种形式；当型循环结构、直到型循环结构、次数型结构。
二、while语句基础知识：
1、一般形式：
while(表达式)
循环语句体；
2、执行过程：
首先计算表达式，如果表达式值为非0（真）时，则执行其后面的循环语句体，然后再计算表达式的值，由表达式的值决定是否重复执行语句，直至表达式的值为0（假）时，才结束循环，如果进入循环前表达式值为0，则循环一次也不执行。
3、特点：先判断表达式，后执行语句。
三、使用while循环时就注意以下两点：
1、循环体如果包含一个以上的语句，应该用花括弧括起来，以复合语句形式出现。否则，循环只到while后面第一个分号处。
2、语句中应有使用表达式为假的语句。否则会出现无限循环即“死”循环。
1、main()
{ int x=1,y=5,s=0；
while(x<y)
{ x++；
s=s+x;
}
printf(“s=%d”,s)；
}
do…while语句
一、do…while语句基础知识：
1、一般形式：
do
循环体语句
while（表达式）；
2、执行过程：
先执行一次循环语句，再判断表达式的值，若表达式为非0（真），再重复执行一次循环体语句。重复上述过程，直至表达式的值为0（假）时，结束循环。
3、特点：不管表达式的值是否为0（假），循环体语句至少执行一次。
二、do…while语句与while语句区别：
while语句先测试循环条件，后执行循环体，所以循环体可能一次都不执行；do…while语句则相反，它先执行循环体，后测试循环条件，因此do…while总是至少执行一循环体。do…while语句循环与标准的直到型略不同，标准的直到型循环当条件成立时退出循环，而do…while语句循环是当条件为假时退出。
main()
{ int a=2,i=1;
do{
a=a+i;i+=3}while(i<13);
printf(“%d”,a);}
main()
{ int a=6,i=2;
do{
a=a+i;i+=4}while(i<17);
printf(“%d”,a);}
for语句
一、for语句的基础知识:
1、for语句的一般形式：
for（表达式1；表达式2；表达式3）
循环体语句
注意：其中，3个表达式可以是C语言中任何有效的表达式，用于控制循环的执行，一般依次表示循环控制变量的实始值、循环条件和循环变量增量。for语句中表达式必须用“；”隔开。
2、执行过程：
（1）先求解表达式1.
（2）求解表达式2，若其值为真，则执行for语句中指定的内嵌语句，然后执行下面第（3）步。若为假，则结束循环。转到第（5）步。
（3）求解表达式3.
（4）转回上面第（2）步骤继续执行。
（5）循环结束，执行for语句的执行过程。
二、for语句的变化形式：
1、表达式为空。for循环的3个表达式都可以省略，但格式中的两个分号不能省。
2、使用逗号表达式。表达式1和3可以使用逗号表达式。
3、使用其他表达式。表达式一般是关系表达式或逻辑表达式，但也可以是数值表达式或字符表达式，只要其值为非零，就执行循环体。
main()
{int m,n;
for(m=n=1;m<=10;m++)
{if(n>=10)break;
if(n%3==1){n+=3;continue;}
}
printf(“%d\n”,m)
}
#include<stdio.h>
main()
{int i;
float f,sum=0.0;
for(i=1;i<11;i++;)
{scanf(“%f”,&f);sum+=f;}
printf(“average=%f\n”,sum/10);
}
一、编一个程序输出下列图形:
**
****
******
********
算法分析：
用次数为4的循环控制输出图形的4行（外层循环）；
外层循环的循环体如下：用次数型循环输出该行的前导空格（内层循环）；
用次数型循环输出该行的字符（内层循环）；
输出回车换行键。
上述算法实现的关键是计算出每行的前导空格数和字符数，可以使用下列方法：
行数 1 2 3 4 i（行）
前导空格数 0 1 2 3 i-1
符号“*”数 2 4 6 8 2i
#include<stdio.h>
main()
{int i,j;
for(i=1;i<＝4;i++;)
{for(j=1;j<=i-1;j++) printf(“ ”);
for(j=1;j<=2*i;j++) printf(“*”);
printf(“\n”);
}}
break语句
一、break语句的基础知识:
1、一般形式：
break；
2、功能：
强制结束当前的循环，不再执行循环体中break后面的语句。
二、break语句使用要点：
1、break语句只能用在三条循环语句的循环体中或switch语句中。
2、在循环体中单独使用本语句是无意义的。。
3、通常break语句是和单分支语句配合使用，从面构成第二个结束循环条件。
例如：从键盘上输入若干个字符（以回车换行符作为结束），统计其中有效字符个数，有效字符是指第一个空格符前面的字符。若输入的字符中没有空格字符，则除回车换行符外的所有字符均为有效字符。
#include<stdio.h>
main()
{int n=0;
char c;
while((c=getchar())!=’\n’)
{if(c==’ ’)break;
n++;
}
printf(“number of charter=%d\n”,n);
}
continue语句
一、continue语句的基础知识:
1、一般形式：
continue；
2、功能：
路过continue之后的语句，重新判断循环控制条件，决定是否继续循环。
二、continue语句使用要点：
1、continue语句只能用在三条循环语句的循环体中。
2、在循环体中单独使用本语句是无意义的。。
3、通常continue语句是和单分支语句配合使用，从而构成其后的部分循环体是否执行的单分支结构。。
例如：从键盘上输入不多于10个实数，求这些数的总和及其中正数的总和。若不足10个实数，则以输入0作为结束。
#include<math.h>
main()
{float sum,psum,x;
int i;
for(sum=psum=0.0,i=0;i<10;i++)
{scanf(“%f”,&x);
if(fabs(x)<1E-5)
break;
sum+=x;
if(x<0)
continue;
psum+=x;
}
printf(“sum=%f\npsum=%f\n”,sum,psum);}
一维数组的定义
一、数组的概念：
数组是由多个数据成员组成的构造类型（基本类型的每一个数据只停含有一个数据成员）。数组是具有相应类型分量的有序数据的有穷集合，数据中的成员分量称为数组元素，数据元素是一些数目固定、类型相同、存储单元连续的变量。数组元素的类型称为数组的类型。数组可以分为一维数组、二维和多维数组。
二、一维数组的定义
数据类型符 数组名，[长度1]，数组名，[长度2]…；
例如：
int a[8],a1à定义一个有8个元素的整型数组a和一个整型变量a1。
float d[10],d1à定义一个有10个元素的单精度实型数组d和一个单精度实型变量。
三、定义数组应注意：
1、类型说明符是指数组元素的数据类型。
2、数组名不能与其他变量名相同。
3、数组名后是用方括号括起来的常量表达式，不能用圆括号。
4、常量表达式指的是数组元素的个数。
5、数组元素的下标是元素相对于数据起始地址的偏移量，所以从0开始顺序编号。
一维数组的初始化与引用
一、一维数组初始化：
1、一维数组初始化的一般格式：
数据类型 数组名[常量表达式]＝{初值表}
2、一维数组初始化应注意以下几点：
（1）可以在定义数组时对所有元素赋初值。
例如：int a[5]={1,3,5,7,9};
(2)如果对数组的全部元素赋以初值，定义时可以不指定数组长度
例如：int b[]={1,2,3,4,5,6}
(3)“初值表”中的初值个数，可以少于元素个数，即允许只给部分元素赋初值，这时必须指定数组长度
例如：int y[5]={1,2,3}
二、一维数组的引用
1、数组同变量一样，必须先定义，后使用。引用数组中的任意一个元素的形式：
数组名[下标表达式]
2、一维数组的引用要点
（1）下标表达式可以是任何非负整型数据。
（2）一个数据元素，实质上就是一个变量，它具有和相同类型单个变量一样的属性。
（3）在C语言中，数组作为一个整体，不能参加数据运算，只能对单个元素进行处理。
例如：int a[10]={1,2,3,4,5,6,7,8,9,10}à定义一个有10个元素的整型数组a.并给其元素赋初值如下：a[0]＝1,a[1]＝2,…a[9]=10。
例如：从键盘上输入10个字符，然后按相反次序输出。
#include<stdio.h>
main()
{char a[10];
int i;
for(i=0;i<10;i++)scanf(“%c”,&a[i]);
for(i=9;i>=0;i--)printf(”%c”,a[i]);
}
二维数组的定义与数组元素的引用
一、二维数组的定义：
格式：数据类型 数组名[行长度][列长度]，……；
功能：定义指定“数据类型”的二维数组，其中有“行长度×列长度”个数组元素。
例如：int a[3][5],i;
二、二维数据定义应注意：
1、数据类型可以是任何基本类型，也可以是后面将要介绍的其它数据类型是，如如指针、结构型等。
2、数组名是按照“标识符”的规则构成的。
3、行长度和列长度都是一个“整型常量表达式”，表示该二维数组有“行长度”行、“列长度”列个数组元素。
4、一个数组定义语句中可以只定义一个二维数组，也可以定义多个二维数组，可以在一个定义语句中同时定义一维和二维数组，还可以同时定义变量。
三、二维数组元素的引用：
1、引用方法：数组名[行下标][列下标]
例如：int a[3][5]
à该语句定义一个3行5列共15个元素的整型二维数组a，其元素为：
a[0][0],a[0][1],a[0][2],a[0][3],a[0][4],
a[1][0],a[1][1],a[1][2],a[1][3],a[1][4]
a[2][0],a[2][1],a[2][2],a[2][3],a[2][4]
四、二维数组的初始化：
1、分行给二维数组所有元素赋初值。
例如：int a[2][3]={{1,2,3},{4,5,6}};
2、不分行给多维数组所有元素赋初值。
例如：int a[2][3]={1,2,3,4,5,6};
3、只对每行的前若干个元素赋初值，此时所有未赋初值的数组元素均获得零值。整型为0，实型为0.0,对字符型为‘\0’;
例如：int a[2][3]={{1},{4,5}}
4、若给所有元素赋初值，行长度可以省略
例如：int a[2][3]={{1,2,3},{4,5,6}}; int a[2][3]={1,2,3,4,5,6}
指针和指针变量
一、基本概念：
1、什么叫指针：指针就是地址，地址是一种数据类型。指针变量也是变量，但只能存放地址类型的数据，可以称为“地址型”变量。
2、什么叫内存单元和地址：运行一个程序时，程序本身和程序中用到的数据都要保存在计算机的内部存储器中，内部存储器是由很多个内存单元（字节）组成的，每个单元都有自己独有、相互不同的地址，称内存单元地址。
3、什么叫指针变量：就是先把要存取的变量的地址存入一个“特殊变量”，然后通过这个其值为地址的“特殊变量”来存取变量的值，就是指针变量。
二、指针变量的定义和初始化：
1、一般形式：数据类型 *指针变量名[＝初值]，…；
2、功能：定义指向“数据类型”的变量或数组的指针变量，同时给其初初值。
例如：int a;
int *p=&a;
à先定义了整型变量a，然后定义一个指向整型数据的指针变量p，并赋值为变量a的地址，即整型的指针变量p指向整型变量a。
例如：float f1,f[10],*p1=&f1,*p2=f;
à在同一个定义语句中，先定义单精度型变量f1和一维数组f，后定义2个指向单精度型的指针变量p1、p2，通过曹值傅指针变量p1、p2分别指向变量f1和一维数组f。
三、指针变量的一般使用方法：
1、给指针变量赋值
使用格式：指针变量＝地址型表达式。
例如：int i,*p_i;
p_i=&i;à使指针变量p_i指向变量i，这儿的&i就是地址型表达式。
2、直接使用指针变量名：
使用格式：指针变量名。
例如：int i,j,*p=*i,*q;
q=p;à将指针变量p有值（i的地址）赋予指针变量q。
3、通过指针变量来引用它所指向的变量
使用格式：*指针变量名。
例如：int i=1,j=2,k,*p=&i;
k=*p+j;à由于p指向i,所以*p就你表i,结果k等于3
指针变量的使用
一、指向变量的指针变量的使用
1、给指针变量赋值
一般形式：指针变量＝地址表达式
例如：int a,*pa;
pa=&a;
2、引用所指向的变量
一般形式：*指针变量
例如： int a=5,*p1=&a;
a=*p1+3;
二、用指向一维数组的指针变量处理数组元素
1. 用指向一维数组的指针变量处理数组元素
当指针变量已指向数组后，就可以用指针变量来处理数组中的每个元素。处理数组元素的关键是引用数组元素，引用数组元素的方法与指针指向数组的方式有关：当指针变量指向数组首地址时，引用数组元素方法如下：
引用“数组元素[0]” *(指针变量+0) 或 *指针变量
引用“数组元素[i]” *(指针变量+i)
当指针变量指向下标为i的数组元素时，引用数组元素的方法如下：
引用“数组元素[i]” *(指针变量+0) 或 *指针变量
引用“数组元素[i-k] *(指针变量-k)
引用“数组元素[i+k] *(指针变量+k)
比较上述两种方式可以看出，采用指针变量指向数组首地址的方式比较简单，是通常采用的方式。
当指针变量指向数组首地址后，对下标为i的数组元素引用一共有下列四种方法：
*(指针变量+i) *(数组名+i) 指针变量[i] 数组名[i]
前两种引用数组元素的方法使用了“指针运算符”，称为“指针法”；后两种引用数组元素的方法使用了“下标运算符([])”，称为“下标法”。
虽然从书写格式来看，指向数组首地址的指针变量和数组名可以互换，但是它们是完全不同的概念。指针变量是存放地址这种数据类型的变量，可以按照变量的处理方式对其进行运算；而数组名仅仅是一个地址常量，只能按照常量的方式进行处理。
2. 指向一维数组的指针变量的运算
当指针变量已指向数组后，对指针变量可以进行算术和关系运算。
(1)指针变量和整数的算术运算。
对指针变量进行算术运算的规则如下：
指针变量+整数 à“指针变量中的地址+整数*指针变量类型占用单元数”对应的地址
指针变量-整数 à “指针变量中的地址-整数*指针变量类型占用单元数”对应的地址
++指针变量 à “指针变量中的地址+指针变量类型占用单元数”对应的地址.此后，指针变量将指向下一个数组元素
--指针变量 à “指针变量中的地址-指针变量类型占用单元数”对应的地址此后，指针变量将指向上一个数组元素
指针变量++ à “指针变量中的地址”对应的地址(因为是后缀减1运算符)此后，指针变量将指向下一个数组元素
指针变量- - à“指针变量中的地址”对应的地址(因为是后缀减1运算符)此后，指针变量将指向上一个数组元素
从运算结果来看，值仍为地址型数据，我们也把上述运算规则组成的式子称为表达式，这种表达式的类型是“地址型”，所以上述规则组成的表达式常称为“地址型表达式”或“指针型表达式”，简称为“指针表达式”。
要特别注意对指向数组的指针进行算术运算时，所加减的整数不是指绝对的地址整数值，而是该指针变量向后或向前跳过的同类型数据的数目。
例如，设定义了整型数组a[10]，整型指针变量pa，切执行了pa=a。假定数组a的首地址为2000。请看下列的表达式及运算结果：
执行pa=pa+5后 pa指向数组元素a[5]，pa的地址值将为2000+5*2=2010， 其中的“2”是整型 数据占用的单元数；
再执行pa--后 pa将指向数组元素a[4]，pa的地址值将为20##-1*2=2008。
还要注意指针变量和地址常量的区别。当某指针已指向某数组首地址后，对指针变量可以进行增1减1的算术运算，也可以对其进行加减整数的算术运算并可以存回指针变量。但是对代表地址常量的数组名不能进行增1减1的算术运算，虽然可以对其进行加减整数的运算，但是不能存回数组名。例如，指针变量pa指向数组a的首地址，++pa,pa++,--pa,pa--,pa=pa+5.pa=pa-5都是正确的；而 ++a,a++--a,a--,a=a+5,a=a-5都是错误的。但其中a+5和a-5是正确的，因为它们是地址常量组成的表达式。
(2)指针变量和指针变量的减法运算。
指针变量和指针变量的减法运算规则如下：
指针变量1-指针变量2
要求这两个指针变量必须指向同一个数组，否则不能进行减法运算。运算结果为它们所指向的是数组元素下标相差的整数。
(3)指针变量的关系运算。
对指针变量进行关系运算的规则如下：
指针变量1 关系运算符 指针变量2
当两个指针变量的值(地址值)满足关系运算时，结果为1(真)；否则为0(假)。所以来年各个指针变量进行关系运算的结果也是逻辑值。
关系运算符还可以用于两个地址常量之间的比较，或一个地址常量和一个地址变量之间的比较。更为一般的是用于两个地址型表达式之间的比较。例如，定义了数组a和同类型的指针变量p1,p2;使p1指向数组元素a[2]；p2指向数组元素a[3]。请看下列的关系表达式及其运算结果：
p1<p2 结果为1
p1++==p2 结果为0， 注意++是后缀
--p2==p1 结果为1， 注意--是前缀
p1<a 结果为0， a是地址常量
p1<&a[9] 结果为1， &a[9]上地址常量。
p2<=a+3 结果为1， a+3是地址表达式，代表a[3]的地址
三、指向字符串常量的指针变量的使用
当一个字符型指针变量已指向某个字符串常量，就可以利用指针变量来处理这个字符串。处理方式有主要有两种：
(1)处理整个字符串。
输出字符串 prinf("%s".指针变量);
输出新的字符串代替原字符串 scanf("%s",指针变量);
(2)处理字符串中的单个字符
第i个字符的表示方法 *(指针变量+i)
3.指向存放字符串的字符数组的指针变量的使用
当一个字符串已经存放一个字符型数组中，并且用指针变量指向这个字符数组，处理字符串中的单个字符就是处理一维数组的元素，处理方法和前面介绍的处理一维数组完全相同，唯一需要注意的是，数组元素的类型是字符型。
下面通过一个例子，说明如何用指针变量来处理字符串常量和存放在字符数组中的字符串。
四、指向二维数组的指针变量的使用
当定义了二维数组和同类型的指针变量后，可以使这个指针变量指向二维数组的首地址，也可以使这个指针变量指向二维数组中的某个一维数组(前面提到过，二维数组可以看承若干个一维数组)，还可以使这个指针变量指向二维数组的某个数组元素。
由于二维数组的地址表达方式比一维数组复杂，所以，使用指向二维数组的指针变量来处理二维数组元素比处理一维数组要复杂一些。下面我们就分几种情况来讨论。
1. 指针变量指向二维数组的某个元素
当指针变量指向二维数组的某个元素时，利用指针变量来处理该数组元素和处理一维数组元素的方法相同。
(1) 让指针变量指向二维数组的某个元素的方法。
使用赋初值或赋值都可以使指针变量指向二维数组繁荣某个元素。
用赋初值方式的格式为： *指针变量=&数组名[下标1][下标2]
用赋值方式的格式为：指针变量=&数组名[下标1][下标2]
(2) 二维数组元素的引用方法。
当指针边来年感已指向二维数组元素后，引用该数组元素的方法是：*指针变量。
2. 指针变量指向二维数组的首地址
当指针变量指向二维数组的首地址时，也可以处理数组中的任何一个元素。其关键在于如何让指针变量指向某个具体的数组元素。
(1) 让指针变量指向二维数组首地址的方法。
使用赋初值或赋值方式都可以使指针变量指向二维数组的首地址。
用赋初值方式的格式有两种：
*指针变量=二维数组名
*指针变量=&二维数组名[0][0] (0行0列元素的地址就是二维数组首地址)
用赋值方式的格式也有两种：
指针变量=二维数组名
指针变量=&二维数组名[0][0]
(2) 二维数组元素的引用方法
当指针变量已指向二维数组的首地址后，引用该数组第i行第j列的元素的方法是：
*(指针变量+i*列数+j)
3. 指针变量指向二维数组中某个一维数组
在数组一章中曾介绍过二维数组可以看成若干个一维数组。因此，我们可以定义一个指针变量，专门用来指向二维数组中的一维数组，然后利用这样的指针变量来处理对应二维数组中的某个一维数组元素。
(1) 让指针变量指向二维数组中某个一维数组的方法。
如果你希望将指针变量指向二维数组中的某个一维数组，首先要按下列格式定义一个指针变量：
(*指针变量)[m] 其中的m是对应二维数组的列长度。
然后再用赋初值或赋值方式将该指针变量指向二维数组的首地址，方法和前面介绍的方法完全相同：
(*指针变量)[m]=二维数组名 赋初值
指针变量=二维数组名 赋值
完成上述两项工作后，二维数组中第i行对应的一维数组首地址可以用下列表达式来
获得：
*(指针变量+i)
使用这种指针变量，需要注意以下几点：
a.定义这种指针变量时，圆括号不能丢。
b.定义这种指针变量时，m必须是整型常量表达式，并且其值要等于希望指向的二维数组的列长度。
c.定义这种指针变量后，赋初值或赋值时应该赋予列长度为m的二维数组首地址，然后用表达方式来获 得二维数组中某个一维数组的首地址。
(2) 二维数组元素的引用方法
当某个指向一维数组的指针变量已指向对应二维数组的首地址后，就可以用像处理一维数组元素的方式来处理这个二维数组中已指向的一维数组元素。具体格式如下：
数组元素地址 *(指针变量+行下标)+列下标
数组元素引用 *(*(指针边来年感+行下标)+列下标)
其中“*(指针变量+行下标)”是行下标对应的一维数组首地址。
例如语句“int a[2][5],(*p)[5];”定义了二维数组a[2][5]和指向具有5个元素的一维数组指针变量p，并且使p指向二维数组a的首地址。则对应二维数组中2个一维数组的首地址如下：
二维数组中的一维数组 用指针变量表示对应一维数组的首地址
a[0] *(p+0) a[1] *(p+1)
二维数组元素的引用格式如下：
数组元素 a[0][0] a[0][1] a[0][3] a[0][4]
引用格式 *(*(p+0)+0) *(*(p+0)+2) *(*(p+0)+3) *(*(p+0)+4)
数组元素 a[1][0] a[1][1 a[1][2] a[1][3] a[1][4]
引用格式*(*(p+1)+0) *(*(p+1)+1) *(*(p+1)+2) *(*(p+1)+3) *(*(p+1)+4)
第七章 函数
一、函数的概念：函数是一个可以反复使用的程序段，从其它程序段中均可以通过函数调用语句来执行这段程序，完成既定的功能。
二、函数的分类：
1、从定义角度来分:用户函数和系统函数。
2、从形式上来分：有参函数和无参函数。
3、众返回值角度来分：有返回值函数和无返回值函数。
二、函数的定义
1、函数的一般定义格式
存储类型符 数据类型符 函数名（形式参数表）
{数据定义语句序列；
执行语句序列；
}
注意：
1、函数头：
存储类型符à可以是extern（外部函数）或static（内部函数）两种。
数据类型符à它规定了本函数返回值的数据类型。
函数名à是一个标识符，在同一个编译单位中函数是不能重名的。
形式参数表à是用逗号分隔的若干个形式参数及其数据类型的说，格式如下：数据类型符 形式参数1，数据类型符 形式参数2.…
2、函数体：
数据定义语句序列à由若干条数据定义语句组成，用来定义本函数中使用的变量、数组、指针变量等。
执行语句序列à由本函数中完成函数功能的程序函数功能的程序组成。
例如：编一个函数，对三个整型参数求最大值，并返回这个最大值。
int max3(int x1,int x2,int x3)
{int max;
if(x1>x2)max=x1
else max=x2;
if(max<x3)max=x3;
return(max);
}
三、函数的调用
1、函数调用的一般格式
（1）以表达式方式来调用函数。格式：函数名（实际参数表）；
注意：使用这种调用格式的结果是获得一个返回值，就是函数的返回值。
（2）以语句方式表调用函数，具体调用格式：函数名（实际参数表）；
注意：使用这种调用格式组成了一条“函数调用语句”
2、函数调用的过程
1、首先暂停函数调用所在的语句执行，转向被调用函数继续执行。
2、为函数的所有参数分配内存；再将所有实际参数（简称实参）的值计算出来，依次赋予对的形式参数（注意，如果形参是数组则不给形参分配内存）。如果是“无参函数”，则本项操作不执行。
3、进入函数体，先执行数控语句，为函数体中定义的变量、数组等分配内存。
4、再执行函数体中的可执行语句。
5、收回分配给本函数体中定义的变量、数组、形式参数等内存单元。
6、返回主调函数继续执行。
例如：编一个程序调用函数max3（）,求四个整数(x、y、z、w)之间差值的最大值。四个整数由键盘输入。（程序为例1）
例1：
int max3(int x1,int x2,int x3) 例2：
{int max;
if(x1>x2)max=x1
else max=x2;
if(max<x3)max=x3;
return(max);
}
main()
{int x,y,z,w,m;
scanf(“%d,%d,%d,%d”,&x,&y,&z,&w);
m=max3(x-y,y-z,z-w);
printf(“max=%d\n”,m);
}
第八章 结构型与共用体
一、结构型的一般形式：
1、含义：结构型和前面介绍的基本数据类型不同，基本数据类型是系统提供的数据类型，而结构型是用户在程序中自己定义的一种数据类型。这种结构型必须先定义，然后才能用已经定义的结构型来定义相应的变量、数组、指针等。
2、结构体变量的定义：
一般形式：
struct 结构体名
{类型标识符1 成员名1； /*成员表列*/
类型标识符2 成员名2；
…
类型标识符3 成员名；3
}；
注意：（1）、结构型定义语句的右括号后面有一介分号。
(2)、结构型名à用户取标识符。
(3)、数据类型符à可以是基本类型说明符，也可以是已定义过的某种结构型。
(4)、成员名à可以是标识符、标识符[长度]、*标识符等。
例如：为了存放一个人的姓名、性别、年龄、工资、可以定义如下结构型：
struct person à定义名为“person”的结构型，共含有4个成员。
{char name[10]; à姓名
char sex; à性别
int age; à年龄
float wage; à工资
};
2、结构体变量的引用：
（1）结构型变量的成员引用方法如下：
结构型变量名.成员名
(2)如果某个结构型变量的成员数据类型又是一个结构型，则引用方法如下：
外层结构型变量.外层结构型成员名.内层成员名
（3）结构型变量成员地址的引用方法：
成员是变量形式的变量地址： &结构型为题名.成员名
成员是数据组形式的数组首地址： 结构型变量名.成员名
成员是数组，其数组元素的地址： &结构型变量名.成员数组[下标]
（4）结构型变量地址的引用方法： &结构型变量名
二、共用体的基础知识：
1、一般形式：
union 共用类型名
{
成员列表;
}；
例如：
union data
{int i;
char ch;
float f;
};
2、共用体变量的引用方法（同结构体）
（1）共用型变量的成员引用方法如下：
共用型变量名.成员名
(2)如果某个共用型变量的成员数据类型又是一个共用型，则引用方法如下：
外层共用型变量.外层共用型成员名.内层成员名
（3）共用型变量成员地址的引用方法：
成员是变量形式的变量地址： &共用型变量名.成员名
成员是数据组形式的数组首地址： 共用型变量名.成员名
成员是数组，其数组元素的地址： &共用型变量名.成员数组[下标]
（4）共用型变量地址的引用方法： &共用型变量名