C程序设计思维导图模板_ProcessOn思维导图、流程图

循环结构

概述：
反复执行某段程序，知道某种条件不满足才结束

while语句

一般形式：
while(表达式)
语句；

注意

在循环体中，应有使循环趋于结束的语句

程序陷入死循环，用Ctrl+break结束

循环体中如果包含一个以上的语句，需要用{}括起来

例题：
求sum=1+2+……+100
思路：
令sum表示被加数（初始值为0）令i表示教书（初始值为1）
进行100次加法后结束，或者单加数大于100时结束
sum中存放计算结果

void main()
{
int sum=0,i=1;
printf("%d\n",sum);
while(i<=100)
{
sum=sum+i;
i++;
}
printf("sum=%d\n",sum);
}

do……while语句

一般形式：
do
语句；
while(表达式)

例题：
求sum=1+2+……+100
用do……while实现

void main()
{
int sum=0,i=1;
do{
sum=sum+i;
i++;
} while(i<=100);
}

while与do……while的区别

do……while的循环体至少要执行一次，
而while中的循环体可能一次也不执行

for语句

一般形式：
for(表达式1;表达式2;表达式3)
语句；
表达式1是初始条件
表达式2是循环条件
语句是循环体

先执行表达式1，表达式2判定条件，如果条件为真，执行语句，然后执行表达3
再判定条件，如果为真，在执行语句，在判定条件，直到为假，退出循环

for(表达式1;表达式2;表达式3)
1.如果省略了“表达式1”（初始条件）表示不对循环控制变量赋初值
2.如果省略了“表达式2”（循环条件）不做其他处理时，便成为死循环
3.如果省略了“表达式3”（循环变量增加量）则不对循环控制变量进行操作，这时可在语句体中加入修改循环控制变量的语句
4.可以省略表达式1和表达式3
5.表达式1可以是设置循环变量的初值的赋值表达式，也可以是其他表达式
6.表达式1和表达式3可以是一个简单的表达式，也可以是逗号表达式
7.表达式2一般是关系表达式或逻辑表达式，但也可以是数值表达式或字符表达式，只要其值非0，就执行循环体

例：
求sum=1+2+……+100
用for循环改写

int i,sum=0;
for(i=1;i<=100;i++)
sum=sum+i;

goto语句

一般形式：
goto 语句标号；
语句标号由字母、数字和下划线组成，不能使用整数

四种循环结构的区别

它们都可以用来处理同一个问题，一般可以相互代替，不提倡用goto型循环

while和do……while循环，循环体应当包括使循环趋于结束的语句，for语句功能更强，用while完成的，用for都能实现

用while和do……while循环时，循环变量初始化的操作在while和do……while语句之前完成，而for语句可以在表达式1实现循环变量的初始化

while、do……while、for循环，都可以用break语句跳出循环，用continue语句结束本次循环

break语句和continue语句

break语句提前终止循环

例题：
在全校1000名学生中进行捐款，当总数达到10万元时结束，
统计捐款人数以及平均每人捐款

#include<stdio.h>
#define SUM 100000
int main()
{
float amount,aver,total;
int i;
for(i=1,total=0;i<=1000;i++)
{
printf("输入捐款\n");
scanf("%f",&amount);
total=total+amount:
if (total>=sum) break;
}
aver=total/i;
printf("num=%d\n,aver=%10.2f\n",i,aver);
return 0;
}

用continue语句提前结束本次循环
有时并不想终止整个循环，而只是提前结束本次循环，
而接着执行下一次循环，这是可以用continue语句。

例题：
输出100-200之间不能被3整除的数

void main()
{
int i;
for(i=100;i<=200;i++)
{
if(i%3==0)
continue;
printf("%d\t",i);
}
}

break语句和continue语句的区别

continue语句只结束本次循环，而不是终止整个循环的执行
break语句结束整个循环过程，不在判断循环的条件是否成立

循环嵌套

一个循环体内又包含一个完整的循环结构，称为循环嵌套

内嵌的循环中还可以嵌套循环，这就是多层循环

例题：
输出下面的图形
*****
*****
*****
*****
*****

void main()
{
int i,j;
for(i=1;i<=5;i++)
{
for(j=1;j<=5;j++)
printf("*");
printf(""\n);
}
}

例题：
输出下面图形
*
**
***
****
*****

void main()
{
int i,j;
for(i=1;i<=5;i++)
{
for(j=1;j<=i;j++)
printf("*");
printf("\n");
}
}

例题：
输出下面图形
*
**
***
****
*****

void main()
{
int i,j;
for(i=1;i<=5;i++)
{
for(j=1;j<=5-i;j++)
printf(" ");
for(j=1;j<=i;j++);
printf("*");
printf("\n");
}
}

例题：
输出下面图形
*
***
*****
*******
*****
***
*

void main()
{
int i,j;
for(i=1;i<=4;i++)
{
for(j=1;j<=4-i;j++)
printf(" ");
for(j=1;j<=2*i-1;j++);
printf("*");
printf("\n");
}
for(i=1;i<=3;i++)
{
for(j=1;j<=i;j++)
printf(" ");
for(j=1;j<=x*(4-i)-1;j++)
printf("*");
printf("\n");
}
}

循环常用算法分析

累加

例：求1+2+3+......+n
分析：求多项式之和，首先得设置一个累加器sum存放结果
sum=0 sum=sum+1 sum=sum+i
整个过程一直在重复执行sum=sum+i，一共重复n次

累乘

例：求10！

int main()
{
int i,j;
long jc=1;
for(i=1.i<=10,i++)|
jc=jc*i;
printf("jc=%id\n",jc);
return 0;
}

例：求1！+2！+3！+4！+5！

#include <stdio.h>
void main()
{
int i,j,sum=0,jec=1;
for(i=1,i<=5,i++)
jec=jec*i;
sum=sum+jec;}
printf("%d\n",sum)
}

求最值

迭代法

例：求斐波那契数列的前40个数。这个数列的特点
第1,2个数为1,1.从第三个数开始，该数是前两个数之和
F1=1 (n=1)
F2=2 (n=2)
Fn=Fn-1+Fn-2 (n>=3)

void main()
{
int i,F1=1,F2=2,F3=0;
printf("%d\t，%d\t",F1,F2);
for(i=1,i<=38,i++)
{
F3=F1+F2;
printf("%d\t",f3);
F1=F2;
F2=F3;
}
}

素素问题

素素就是质数，一个大于1且只能被1和它本身整除的整数
例：输入一个大于3的整数n，判断它是否是素数
思路：
让n被i整除（i的值从2变到n-1）
如果n能被2~（n-1）之中任何一个数整除，则表示n肯定不是素数，
不必再进行后面的操作，可以用break提前结束循环

void main()
{
int,i,n;
scanf("%d",&n);
for(i=2;i<=n-1;i++)
if(n%i==0)
{
printf("%d不是素数",n);
break;
}
if(i==n)
printf("%d是素数\n",n);
}

求100~200间的全部素数

void main()
{
int,i,n;
for(i=100;i<=200;i++)
{
for(n=100;n<=i-1;n++)
if(i%n==0)
break;
if(i==n)
printf("%d\n",n);
}
}

穷举法

水仙花数
设一个三位数可以表示为abc，若其能满足条件a^3+b^3+c^3=abc，
则称其为水仙花数，例如153。 153=1^3+5^3+3^3
例：编程求出所有得到水仙花数

void main()
{
int i,a,b,c;
for(i=100;i<=999;i++)
{
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);
}
}

例：百元买百鸡
公鸡五元一个，母鸡三元一个，小鸡一元三个

void main()
{
int ,i,j,k,a;
for (i=1,i<=20;i++)
for(j=0;j<=34:j++)
for (k=0,k<=100;k++)
if(i+k+j==100&&i*5+i*3+k/3==100&&k%3==0)
printf("%\t,%d\t,%d\t\n",i,j,k);
}

字符统计

例：输入一个字符，分别统计出其中的英文字母、空格
数字和其他字符的个数

void main()
{
int z=0,s=0,k=0,q=0;
char ch;
ch=getchar();
while (ch!='\n')
{
if (ch>='a'&&ch<='z'||ch>='A'&&ch<='Z')
z++；
else if(ch==' ')
k++;
else if (ch>='0'&&ch<='q")
s++;
else
q++;
ch=getchar();
}
printf("%d\t,%d\t,%d\t,%d\t\n",z,k,s,q);
}

译密码

例：输入一行字符，输出相应的密码

void main()
{
char ch;
ch=getchar();
while (ch!='\n')
{
if(ch>='w'&&ch<='z'||ch>='W'&&ch<='Z')
ch=ch+4-26;
else
ch=ch+4;
printf("%c",ch);
ch=getchar();
}
}

数组

一维数组

怎么定义一维数组

数组是一组有序数据的集合，数据中各组数据的排列是有一定规律的，
下表代表数据在数据中的型号

数组中的每一个元素都属于同一个数据类型

数组必须先定义后使用

定义一维数组的一般形式为：
类型符数组名[常量表达式]

数组名的命名规范和变量名相同
如： int a[10]
int 每个元素的数据类型
a 数组名
10 数组长度
10个元素 a[0],a[1],a[2],........,a[9]

怎么引用一维数组元素

引用数组元素的表达式为
数组名 [下标]

注意：
只能引用数组元素而不能一次整体调用整个数组全部元素的值

实现数组的复制
void main()
{
int a[10]={1,2,3,4,5,6,7,8,9,10},b[10];
for (i=0;i<10;i++)
{
b[i]=a[i];
printf("%d",b[i]);
}
}

一维数组的赋值

给数组赋值的方法

用赋值语句对数组元素逐个赋值

采用初始化赋值

动态辅助（scanf()）

一维数组的初始化

数组初始化赋值是指：
在数组定义时给数组元素赋予初值，数组初始化是在编译阶段进行的。这样减少运行时间，提高效率

一般形式
类型说明符数组名[常量表达式]={值，值，值，........，值}
其中{}中的各数据值即为各元素的初值，各值之间用，隔开
如 int a[10]={0,1,2,3,4,5,6,7,8,9};

说明

可以对全部数组元素赋值
如 int a[10]={0,1,2,3,4,5,6,7,8,9};

可以只给一部分元素赋值
如 int a[10]={0,1,2,3,4};
只给前面5个元素赋值，后5个元素为0

如果想使一个数组中全部元素为0，可以写成
如 int a[10]={0,0,0,0,0,0,0,0,0,0};或如 int a[10]={0};
不能写成a[10]=0

在对全部数组元素赋值时，可以不指定数组长度
如 int a[10]={0,1,2,3,4,5,6,7,8,9};
可以写成如 int a[]={0,1,2,3,4,5,6,7,8,9};

一维数组的动态赋值

可以在程序执行过程中，对数组做动态赋值。
这时可以用循环语句配合scanf函数逐个对数组赋值
for (i=0;i<10;i++)
scanf("%d",&a[i]);

一位数组程序举例

例1：对10个数组元素依次赋值为0,1,2,3,4,5,6,7,8,9
要求按逆序输出

void main()
{
int i,a[10];
for(i=0;i<=9;i++)
a[i]=i;
for(i=9;i>=0;i--)
printf("%d",a[i]);
printf("\n");
return 0;
}

例2：将数组中的第一个元素与最后一个交换，
第二个元素与倒数第二个交换，依次类推

void main()
{
int ,i,t,a[10];
for (i=0;i<=9;i++)
a[i]=i;
for(i=0;i<10/2;i++)
{
t=a[i];
a[i]=a[9-i];
a[9-i]=t;
}
for(i=0;i<=9;i++)
printf("%d",a[i]);
}

例3：求一维数组中最大元素及其下标

#define N
void main()
{
int score[N],i,max,m;
for(i=0;i<n;i++)
{
scanf("%d",&score[i]);
printf("%4d",score[i]);
}
max=score[0];
m=0;
for(i=0;i<N；i++)
{
if (score[i]>max)
{
max=score[i];
m=i;
}
}
printf("最大值是%d\n,最大值下标是%4d\n",max,m);
}

例4：用数组处理斐波那契数列问题

#define N 40
void main()
{
int f[N]，i;
f[0]=f[1]=1;
printf("%d\n,%d\n",f[0],f[1]);
for (i=2;i<N;i++)
{
f[i]=f[i-1]+f[i-2];
printf("%d\n",f[i]);
}
}

二维数组

二维数组的定义

类型说明符数组名[常量表达式] [常量表达式]
int a[3] [4];
说明了一个三行四列的数组，数组名为a，类型是整型

我们可以把二维数组看做是一种特殊的一维数组:他的元素又是一维数组

二维数组在内存中的存放

二维数组在概念上是二维的，但是实际的硬件存储确实连续偏址的，
也就是说存储器单元是接受按一维线性排列的。二维数组是按行排列，
放完一行之后顺序放第二行

二维数组的引用

一般形式
数组名 [下标] [下标]
下标可以是整数表达式，a[2] [3],a[2-1] [2*2-1]
下标值应该在已定义的数组大小的范围内

二维数组的初始化

分行给二维数组赋初值
int a[3] [4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}

将所有数据写在一个华括弧内，按数组排列的顺序对各元素赋初值
int a[3] [4]={1,2,3,4,5,6,7,8,9,10,11,12}

可对部分元素赋初值
int a[3] [4]={{1},{2},{3}}
是对每一行的第一列元素赋值，未赋值的元素取0，
各元素的值为
1 0 0 0
2 0 0 0
3 0 0 0

二维数组程序举例

例1：
有一个3*4的矩阵，求出最大值以及他的行号和列号

void main()
{
int i,j,row,colum,max;
int a[3] [4]={{1,2,3,4},{9,8,7,6},{-10,-10,5,2}};
max=a[0] [0];
row=0;
colum=0;
for (i=0;i<=2;i++)
for(j=0;j<=3;i++)
if(a[i] [j]>max)
{
max=a[i] [j];
row=i;
colum=j;
}
printf("max=%d,row=%d,colum=%d\n",max,row,colum);
}

例2：
将一个二维数组行和列的元素互换，存到另一个二维数组中
a=1 2 3 b=1 4
4 5 6 2 5
3 6

int main()
{
int a[2] [3]={{1,2,3},{4,5,6}};
int b[3] [2],i,j;
printf("矩阵a是：\n");
for (i=0;i<=1;i++);
{
for (j=0;j<=2;j++)
{
printf("%5d",a[i] [j]);
b[i] [j]=a[i] [j];
}
printf("\n");
}
printf("矩阵b是\n");
for (i=0;i<=2;i++)
{
for (j=0;j<=1;j++)
printf("%5d",b[i] [j]);
printf("\n");
}
return 0;
}

例3：
有一个3*4的矩阵，要求将矩阵第一行与第三行对应元素减缓位置

void main()
{
int a[3] [4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int i,j,t;
printf("矩阵a是\n");
for(i=0;i<=2;i++)
{
for(j=0;j<=3;j++)
printf("%5d",a[i] [j]);
printf("\n");
}
for(i=0;i<=3;i++)
{
t=a[0] [j];
a[0] [j];
a[2] [i]=t;
}
printf("交换后:：\n");
for(i=0;i<=2;i++)
{
for(j=0;j<=2;j++)
printf("%5d",a[i] [j]);
printf("\n");
}

例4：
求两个矩阵之和

void main()
{
int i,j,c[4] [4];
int a[4] [4]={{1},{2},{3},{4}};
for (i=0;i<4;i++)
{
for (j=0;j<4;j++)
c[i] [j]=(a[i] [j]+b[i] [j]);
}
for(i=0;i<4;i++)
{
for (j=0;j<4;j++)
printf("%5d",c[i] [j]);
printf("\n")
}
}

字符数组

字符数组的定义

用来存放字符数据的数组。
字符数组中一个元素存放一个字符

定义形式
char c[10];

字符数组也可以是二维或多维数组

字符数组的初始化

逐个字符赋给数组中的各元素
char c[10]={'a',' ','c','d','e','f','g','b','q','r'};

如果花括号中提供的初值个数大于数组长度，则语法错误；
如果初值个数小于数组长度，只将这些字符赋给数组中前面那些元素，其余为'\0'

例如：
char c[10]={'a',' ','b','c','d','e','f','g','h'}
则c[0]='a',c[1]=' ',c[2]='b',c[3]='c',c[4]='d',c[5]='e'
c[6]='f',c[7]='g',c[8]='h',c[9]='\0'

如果提供的初值个数与预定的数组长度相同，在定义时可以省略各数组长度，系统会自动
根据初值个数确实数组长度 char c[ ]={'a','b','c','e'}

可以定义二维数组

例：输出一个字符串
void main()
{
char c[5]={'b',' ','o',' ','y'};
int i;
for (i=0;i<10;i++)
printf("%c",c[i]);
printf("\n");
}

字符串和字符串结束标志

在c语言中没有专门的字符串变量，通常用一个字符数组来存放一个字符串，有时，人们关心的是有效字符串的长度而不是字符数组的长度
例如，定义一个字符数组长度为100，而实际有效字符只有40个，为了测定字符串的实际长度，C语言规定可一个字符串结束标志，以字符'\0'代表

可以把一个字符串直接赋给一个字符数组所表示的变量，已初始化字符数组
如 charc[]={"I am happy"}; 或者 char c[]="I am happy";
注意：
这里不用单个字符作为初值，而是用一个字符串作为初值。数组c的长度不是10，而是11，字符串常量的最后由系统加上一个'\0'

用字符串赋值比用字符逐个赋值要多占一个字节，用于存放字符串结束标志'\0'

例：分析 char c[10]={"china"};在内存中的存储
c h i n a \0 \0 \0 \0 \0

字符数组的输入输出

逐个字符输入输出。用格式符"%c"输入或输出一个字符

将整个字符串一次输入或输出。用"%s"格式符，意思是对字符串的输入输出
char c[]={"china"};
printf("%s",c);只输出"china"5个字符

说明

用"%s"格式符输出字符串时，printf函数中的输出项是字符数组名，而不是数组元素名或&

如果数组长度大于字符串实际长度，也只遇到'\0'结束

输出字符不包括结束符'\0'

如果一个字符数组中包含一个以上的'\0'，则遇到第一个'\0'输出就结束

可以用scanf函数输入一个字符串
char c[20];
scanf("%s",c);
如果利用scanf输入多个字符串，则以空格分隔
char a[5],b[5],c[5];
scanf("%s%s%s",a,b,c);
输入数据： How are you ?

数组首地址
数组名代表了该数组的首地址。整个数组是以首地址开头一块的内存单元

字符串处理函数

用于输入输出的字符串函数，在使用之前应包含头文件"stdio.h"，使用其他字符串函数则应包含头文件"string.h"。

puts(str)

作用：
将一个字符串（以'\0'结束的字符序列）输出列到终端
char str[]={"china\nbeijing"};
puts(str);
输出 china
beijing

puts函数可以使用转义字符
puts函数可以由printf函数取代，
当需要按一定格式输入时，通常用printf

gets(str)

作用：
从终端输入一个字符串到字符数组，并且得到一个函数值。该函数值是字符数组的起始地址
如 gets(str)
从键盘输入 computer(回车)

注意：
用gets和puts函数只能输入或输出一个字符串
不能写成
puts(str1,str2)或gets(str1,str2)

当输入的字符串含有空格时，输出仍为全部字符串。
说明函数并不以空格作为字符串输入结束的标志，而只以回车作为输入结束
这是与scanf函数不同的。

strcat()

格式：
strcat(字符数组名1，字符数组名2)

功能：把字符数组2中的字符串连接到字符数组1中字符串的后面，
并删除字符串1后的标志位'\0'，结果放在字符数组1中。

字符数组1应定义足够的长度，否则不能全部装入被连接的字符串

gets() puts() strcat()的使用

#include<string.h>
int main()
{
char st1[30]="my name is";
char st2[10];
printf("输入你的名字：\n");
gets(st2)
strcat(st1);
}

strcpy

格式：
strcpy(字符数组名1，字符数组名2)

功能：
把字符数组2中的字符串拷贝到字符数组1中。穿结束标志"\0"也一同拷贝。
字符数组2也可以是一个字符串常量

例：
#include<stdio/h>
main()
{
char st1[15],str2[]="c language";
strcpy(st1,st2);
puts(st1);
printf("\n");
}
字符数组1应该有足够的长度

说明：
可以用strcpy()函数将字符串2中前面若干个字符复制到字符数组1中去

strupr()

格式：
strupr(字符串)

功能：
将字符串中小写字母转换成大写字母

数组注意问题

引用数组应该用[]

数组元素可以使用最大下标
int i,a[10]={1};
for(i=1i<10;i++)
printf("%d",a[i]);

二维数组和多维数组的定义和引用
int a[4][5]

用scanf函数向字符数组输入数组，不能加&
char a[20];
scanf("%s",a)
用scanf函数向数值型数组输入数据，要加&

误以为数组名代表数组全部元素
int a[4]={1,3,5,7},b[4];
b=a; 这是错误的

字符数组的初始化和赋值
char str[10]="china" 这是正确的
char str[4]；str="china" 这是错误的

混淆字符和字符串的表现形式
char sex;
sex="m"；
这是错误的，m是字符串，后面还有\0

数组的应用

数组的排序

选择法排序

冒泡法

数组中元素的插入和删除

查找

顺序查找

求二维数组的鞍点

按行求出各行最大的元素位置，某行最大元素与该元素所在列的所有元素比较，
判断是否是最小元素，是则是鞍点，否则不是

函数

函数就是功能
每一个函数用来实现一个特定的功能
函数的名字反映其代表的功能
int max(int x,int y) //求最大值

程序可由一个主函数和若干个其他函数构成

同一个函数调用可以被一个或多个函数调用任意多次（除了主函数）

例：
输出一下结果，用函数调用实现
****************
how do you do！
****************

#include<stdio.h>
int main()
{
void print_star(); /*声明
void print_message(); 函数*/
print_star(); /*函数
print_message();
print_star(); 调用*/
return 0;
}
void print_starc() //函数定义
{
printf("****************\n";) //输出16个*
}
void_message()
{
printf("how do you do!\n";) //输出 how do you do!
}

说明

一个c程序由一个或多个程序模块组成，每一个程序模块作为一个源程序文件
若干个源程序文件组成一个c程序
一个源程序文件可以为多个c程序共用

一个源程序文件由一个或多个函数以及其他有关内容组成
一个源程序文件是一个编译单位，在程序编译时以源程序文件为单位，进行编译的，不是以函数为单位

c程序的执行是从main函数开始，到main函数结束

所有函数都是平行的，即在定义时是分别进行的，是互相独立的
函数不能嵌套定义
函数间可以相互调用，但是不能调用main函数
main函数是被操作系统调用的

从声明角度看，函数有两种：
1.库函数
2.用户自己定义的函数
从函数的形式看，分两类：
1.无参函数
2.有参函数

函数的定义

无参函数的定义

类型标识符函数名() //函数头
{ //函数体
声明部分
语句
}

void printsar()
{
printf("******\n";)
}

有参函数的定义

类型标识符符函数名(形式参数列表)
{
声明部分
语句
}

int max(int x,int y)
{
int z;
z=x>y?x:y;
return (z);
}

定义空函数

类型名函数名()
{}

例：
编写一个求阶乘的函数，求5！+6！+7！

#include<stdio.h>
int main()
{
int fac(int n); // 函数的原型声明
int i,a,b,c;
a=fac(5):
b=fac(6);
c=fac(7);
printf("5!+6!+7!=%d\n",a+b+c);
}
int fac (int n) //函数的定义
{
int i,f=1;
for(i=1;i<n;i++)
f=f*i;
return f;
}

例：
求两个整数中的较大者

#include<stdio.h>
int main()
{
int max(int x,int y); //函数的原型声明
int a,b;
scanf("%d,%d",&a,&b);
printf("%d是最大值i\n",max(a,b); //函数的调用
}
int max(int x,int y) //函数的定义
{
int m;
if(x>y)
m=x;
else
m=y;
return m;
}

函数的调用

函数调用的形式
函数名（实参表列）

如果调用无参函数，则“实参表列”可以没有，但是括号不能省略
如果实参表列包含多个实参，则各参数之间用逗号隔开。c=max(a,b)

三种函数调用形式

函数调用语句

把函数调用单独作为一个语句如：print_star()
这是不能要求函数带回值，只要求函数完成一定的操作

函数表达式

函数调用出现在另一个表达式中，如c=max(a,b);
这是要求函数带回一个确定的值以参加表达式的运算

函数参数

函数调用作为另一个函数调用时的实参，如m=max(a,max(b,c));
其中max(b,c)是一次函数调用，他的值作为max另一次调用的实参

函数调用时的数据传递

在调用有参函数时，主调函数和被调函数之间有数据传递关系
定义函数时函数名后面的变量名称为“形式参数”
主调函数调用一个函数时，函数名后面函数称为实际参数
实际参数可以是常量、变量或表达式

函数调用的过程

在定义函数中指定的形参，在未出现函数调用时，他们并不占内存中的存储单元。
在发生函数调用时，函数max的形参被临时分配内存单元

实参与形参的类型应相同或赋值兼容

C语言规定，实参变量对形参变量的数据传递是值传递（即单向传递），只由实参传给形参，
不能由形参传回实参。在内存中，实参单元与形参单元是不同的单元

调用结束，形参单元被释放
实参单元维持原值，没有改变
如果在执行一个被调用函数时，形参的值发生改变，不会改变主调函数的实参的值

函数的返回值

通过函数调用使主调函数能得到一个确定的值，这就是函数值（函数返回值）

函数的返回值是通过函数中的return语句获得的
一个函数中可以有一个以上的return语句，执行到哪一个return语句，哪一个就起作用
return 表达式 ;或return (表达式);
return后面的值可以是一个表达式 return(x>y?x:y);
如果被调用函数中没有return语句，说明没有希望得到函数值。
为了明确表示“不常回值”，可以用void定义函数无类型，此时函数中不能有return语句
函数值的类型和函数定义中函数的类型应保持一致。如果函数值的类型和return语句中表达式的值不一致，以函数类型为准
不加类型说明的函数，自动按整型处理

被调用函数的声明和函数原型声明

一个函数调用另一个函数应具备以下条件：
1.被调研函数必须是已经定义的函数
2.如果用库函数，应该在本文件开头加上#include指令
3.如果使用自己定义的函数，而该函数的位置在调用它的函数后面，应该声明

函数的嵌套与递归

C语言的函数定义是相互平行的，独立的
即函数不能嵌套定义，但可以嵌套定义函数
即调用一个函数的过程中，可以调用另一个函数

函数的递归调用

在调用一个函数的过程中，又出现直接或间接地调用该函数本身，称为函数的递归调用

数组作为函数参数

数组元素作为函数参数

数组元素就是变量，他与普通变量并无区别。
因此它作为函数实参使用与普通变量时完全相同的，在发生函数调用时，
把作为实参的数组元素的值传递给形参，实现单向的值传送

数组名做函数参数

用数组名做函数实参时，向形参传递的是数组首元素的地址

说明：
用数组名与数组元素做函数参数不同点

1.用数组元素作为实参时，对数组元素的处理是按普通元素对待的。
用数组名做函数参数时，这要求形参和相对应的实参都必须是类型相同的数组，都必须有明确的数组声明

2.在函数调用时发生的值传递是把实参变量的值赋予形参变量。
在用数组名作函数参数时，不是进行值得传送，而是把实参数组的首地址回赋予形参数组

用多维数组名作函数参数

多维数组元素与一维数组一样，可以看做一个变量，所以在调用函数时可以作为实参，进行值得传递

用多维数组作为函数参数传递的是数组首元素的地址，要求形参是相同类型的同维数组。
这里，形参是二维数组时，第二维的大小（长度）必须指明，而第一维的大小（长度）随便
int array[3][10] 或 int array[][10]

字符数组名做函数参数

用字符数组名做函数参数传递得到是数组首元素的地址

变量的作用域

在程序中能对变量进行存取操作的范围称为变量的作用域
变量分为局部变量和全局变量

C语言

C语言的特点

语言简洁，紧凑，使用方便灵活。32个关键字，9种控制语句，程序形式自由。

丰富的运算符和数据类型，具有现代语言的各种数据结构。

具有结构化的控制语句，是完全模块化和结构化的语言。

能直接访问物理地址进行位操作，可以直接对硬件进行操作。

程序可移植性好（与汇编语言相比）。

C语言允许使用的两种注释方式

// ：单行注释

/* ......*/：多行注释

C语言程序的结构特点

一个源程序文件包括

预处理指令：#include<stdio.h>

函数定义：每个函数用来实现一定的功能

函数是C程序的主要组成部分

一个c程序是由一个或多个函数组成的

必须包含一个main函数（只能有一个）

程序总是从main函数开始执行，到main函数结束

C语言规定，在一个源程序中，main函数的位置可以任意

一个函数包括两个部分

函数首部

函数体

c程序对计算机的操作由C语句完成

c程序书写格式是比较自由的。

为清晰可见，习惯上每行只写一个语句。

数据声明和语句最后必须有分号。

C语言本身不提供输入输出语句。

程序应当包含注释，增加可读性。

C语言一行写不下时可以跨行写，但要分两种情况

预处理一行写不下时

把一个预处理指示写成多行时要用“\”换行，因为根据定义，一条预处理指示只能由一个逻辑代码组成

正常程序一行写不下时

把c代码写成多行则不必使用续航符（在任意空白处换行）

算法

一个程序主要包括：对数据的描述（数据结构），对操作的描述（要求计算机进行操作的步骤，也是算法）两方面的信息

什么是算法：算法是为了解决问题而执行的一系列步骤

计算机算法分为两大类

数值运算法：求数值解

非数值运算法：用于事务管理

算法的特性

有穷性：一个算法应该包括有限的操作步骤，而不能无线

确定性：算法中的每一个步骤都是确定的

有零个或多个输入：所谓输入是指在执行算法时需要从外界取得必要的信息

有一个或多个输出：算法的目的数为了求解，“解”就是输出，没有输出的算法是无意义的

有效性：算法中的每一个步骤都应该有效执行，并得到确定结果

常量，变量

C语言的数据类型

基本类型

整型

实型（浮点型）

单精度型

双精度型

枚举型

构造类型

结构体类型

数组类型

共用体构造

空类型（void函数）

常量和符号常量

定义：在执行过程中，其值不发生改变的量称为常量，其值可改变的量称为变量

在程序中，常量是可以不经说明而直接引用的，而变量必须先定义后使用

直接常量（直面常量）：可以直接从字面值看出来

整型常量：12/0、-3

实型常量：4.6、-1.23

字符常量'a'、'b'、'2'

符号常量：用标识符代表一个常量，称之为符号常量

符号常量一般格式为：
#define 标识符常量
例如：#define PI 3.1415

符号常量在使用之前必须先定义

符号常量后面不能用分号;

变量

定义：代表内存中具有特定属性的一个存储单位，用来存放数据，也就是该变量的值

程序编译连接执行时由系统给每个变量各分配内存地址

变量必须先定义后使用

标识符

定义：在C语言中用来对变量，符号常量，函数，数组等数据对象命名的有效符号序列统称为标识符

标识符命名规范

只能由字母、下划线、数字三种字符组成

第一个字符必须为字母下划线

不能使用C语言关键字

1、数据类型关键字（12个）：
(1) char ：声明字符型变量或函数 (2) double ：声明双精度变量或函数
(3) enum ：声明枚举类型 (4) float：声明浮点型变量或函数
(5) int：声明整型变量或函数 (6) long ：声明长整型变量或函数
(7) short ：声明短整型变量或函数 (8) signed：声明有符号类型变量或函数
(9) struct：声明结构体变量或函数 (10) union：声明共用体（联合）数据类型
(11) unsigned：声明无符号类型变量或函数
(12) void ：声明函数无返回值或无参数，声明无类型指针（基本上就这三个作用）

2、控制语句关键字（12个）：
(1) for：一种循环语句 (2) do ：循环语句的循环体
(3) while ：循环语句的循环条件 (4) break：跳出当前循环
(5) continue：结束当前循环，开始下一轮循环
(6)if: 条件语句
(7)else ：条件语句否定分支（与 if 连用）
(8)goto：无条件跳转语句 (9)switch :用于开关语句
(10)case：开关语句分支
(11)default：开关语句中的“其他”分支
(12）return ：子程序返回语句（可以带参数，也看不带参数）

3、存储类型关键字（4个）
(1)auto ：声明自动变量一般不使用
(2)extern：声明变量是在其他文件正声明（也可以看做是引用变量）
(3)register：声明寄存器变量 (4)static ：声明静态变量

4、其它关键字（4个）：
(1)const ：声明只读变量 (2)sizeof：计算数据类型长度
(3)typedef：用以给数据类型取别名（当然还有其他作用
(4)volatile：说明变量在程序执行中可被隐含地改变

整型数据

整型常量的表示方法

十进制整数：123、0、-456

八进制整数：以<0>开头，0123
八进制不能有8

十六进制整数：以<0x>开头，0x123

整型变量

类型说明符变量名标识符，变量名标识符，……
例如： int a,b,c;（a，b，c为整型变量）
long a,b,c;（a.b.c为长整型变量）
unsigned p,q;（p,q为无符号整型变量）

注意：
1.允许在一个类型说明符后，定义多个相同类型的变量。各变量名之间用逗号间隔。类型说明符与变量名之间至少用一个空格间隔。
2.最后一个变量名之后必须以“;”结尾。
3.变量定义必须放在变量使用之前。一般放在函数体的开头部分。

浮点型数据

实型常量的表示方法

实数，又称浮点数，十进制小数形式，如0..123.、123.、123.0、0.0

浮点型变量的分类

单精度float
有效数字：6
字节数：4
数的范围：0以及1.2*10的-38次方~3.4*10的38次方

双精度double
有效数字：15
字节数：8
数的范围：0以及2..3*10的-308次方~1.7*10的308次方

长双精度型long double
有效数字：19
字节数：16
数的范围：0以及3.4*10的-4932次方~1.1*10的4932次方

指数形式：数字+e（E）+整数
如123e3=123*10^3

字母e（E）之前必须有数字，且e后面的指数必须是整数

字符型数据

字符常量

定义：用单引号''括起来的一个字符是字符型常量

只能包含一个字符
如'a'，'A'，'#'，'?'，'6'

说明：
'A'，'a'是不同的字符常量
字符常量只能用单引号括起来，不能用双引号或其他括号
字符常量只能是单个字符，不能是字符串。

字符常量转义字符：以“\”开头的特殊字符
（转义字符只能使用小写字母，每个转义字符只能看做一个字符）
\n 换行，将当前位置移到下一行开头
\t 水平制表，跳到下一个tab位置，8位为一个tab位置
\b 退格，将当前位置移到前一列
\r 回车，将当前位置移到本行开头
\f 换页，将当前位置移到下一页开头
\\ 反斜杠字符"\"，输出单个\
\' 单撇号字符，输出单个'
\" 双撇号字符，输出单个"
\ddd 1-3位八进制所代表的的字符
\xhh 1-2位十六进制所代表的的字符
\a 响铃
\v 垂直制表vt
\? 问号字符
\0 空字符
除了\r，其余转义字符的跳格，会取代原来屏幕上该位置显示的字符

字符串常量

字符串常量是一对“双引号”括起来的字符序列
"how are you?" "china"A

C规定：在每个字符串的结尾加一个“字符串结束标志\0”，以便系统据此判断字符串是否结束

在内存中字符串存储为：字符串+'\0'
书写时不必加'\0'，系统会自动加上'\0'

字符变量

字符变量用来存放字符常量，但只能存放一个字符。
字符变量的定义形式如下
char c1，c2；
它表示c1和c2为字符型变量，各可以放一个字符
c1='a',c2='b';

字符数据在内中的存储形式及其使用方法

将一个字符放到一个字符变量中，
在内存单元中，是将该字符的相应的ASCII代码放到存储单元中

函数strlen：计算给定字符串的长度，不包括“\0”在内

例如：表达式strlen("\x69\082\n")的值是1

运算符与表达式

变量赋初值

一般形式
类型说明符变量1=值1，变量2=值2，……

int a=3; /* 指定a为整型变量，初始值为3 */
float f=3.14; /* 指定f为实型变量，初值为3.14*/
也可以使被定义的变量的一部分赋初值
int a,b,c=5;
如果对几个变量赋予初值为3，应写成
int a=3,b=3,c=3;

各类数值型数据间的混合运算

整数、实数、字符型数据可以混合运算
10+'a'+15-8768.123*'b'

若参加运算的类型不同，则先转换成同一类型在进行计算

转换按数据长度增加的方向进行，以保证精度不降低

所有的浮点运算都是以双精度（double）进行的

char型和short型参与运算时，必须先转换为int型

在赋值运算中，赋值号两边的数据类型不同时，赋值号右边量的类型转换为左边量的类型
int a=3.2 a=3

只要有double类型，运算结果也为double类型

算数运算符和算数表达式

C语言运算符简介

算数运算符 + - * / %
关系运算符 > < == >= <= !=
逻辑运算符！ && ||
位运算符 << >> ~ | ^ &
赋值运算符 =及其扩展运算符
条件运算符？：
逗号运算符 ,
指针运算符 * &
长度运算符 sizeof
强制类型转换运算符（类型）
分量运算符 . ->
下标运算符 [ ]
其他如函数调用运算符（）

算数运算符和表达式

基本的算数运算符
+ - * /

两个整数相除的结果为整数
5/3结果为1，舍去小数部分

如果两个数有一个小数，结果为小数
5.0/2=2.5

除数或被除数中有一个为负值，舍入方向不固定

%运算符：称为求余运算符

%两侧均为整型数据
7%4的值为3

对于求余运算，运算结果与第一个数的符号相同

一个变量a能被3整除，则写成a%3==0

算数表达式和运算符的优先级与结合性

强制类型转换运算符

含义：用来将一个算数表达式的值转换成所需类型

定义格式
（类型名）（表达式）

int i;
float j;
j=10.01;
i=(int)j;
把j强制转换成整型赋给i

注意：
无论是强制转换或是自动转换，都只是为了本次运算的需要而改变量的值
进行临时转换，而不改变数据说明时对该变量定义的类型

自增自减运算

定义格式
++a，--a
a++，a--
含义 a=a+1
a=a-1

++a，--a 在使用之前，先使a的值加1/减1（先加后用）
a++，a-- 在使用之后，使a的值加1/减1（先用后加）

a++与++a的区别
a++在使用a之后，使a的值加1，因此执行完a++之后，整个表达式的值为a，而a的值变为a++
++a在使用a之前，使a的值加1，因此执行完++a后，整个表达式的和a的值均变为a+1

注意事项：
自增自减运算只能用于变量，不能用于常量和表达式。如5++，（a+b）++都不合法
++和--的结合方向是自右向左

赋值运算符和赋值表达式

赋值运算符 “=”
a=3

类型转换

如果赋值运算符两侧的类型不一致，但都是数值型或字符型时，在赋值时要进行类型转换

int a;
a=6.3
a的值为6

将实型（浮点型）数据赋给整型变量时，舍弃小数部分

将整型数据赋给单双精度变量时，数字不变，但以实数形式存储到变量中

将一个double型数据赋给一个float型变量时，截取前面的7位有效数字，存放到float变量的存储单元中

字符型数据赋给整型变量时，由于字符只能占一个字节，而整型变量为四个字节，因此将字符数据（8位）放到整型变量低8位中

将一个int，short，long型数据赋给char型变量时，只将其低八位原封不动的送到char型变量（即截断）

复合的赋值运算符

在赋值运算符“=”之前加上其他运算符

一般形式为：变量双目运算符=表达式
它等效于变量=变量运算符表达式

a+=3等价于a=a+3
x*=y+8等价于 x=x*(x+8)
x%=3等价于 x=x%3

赋值表达式

定义：由赋值运算符将一个变量和一个表达式连接起来的式子

一般形式：
<变量> <赋值运算符> <表达式>

注意：不能把一个表达式赋给另一个表达式，只能赋给一个变量

逗号运算符和逗号表达式

C语言提供一种特殊的运算符——逗号运算符
用它将两个表达式连接起来

一般形式：
表达式1，表达式2
扩展：表达式1，表达式2，……，表达式n

求解过程：根据左结合性，分别求n个表达式的值，并以表达式n的值作为整个逗号表达式的值
最右边的值是整个表达式的值

a=3*5，a*4 表达式的值为60
（a=3*5，a*4），a+5 表达式的值是20

C语言常用的数学函数

abs

功能：求整数x的绝对值

说明：计算|x|,当x不为负时返回x，否则返回-x

fabs

功能：求浮点数x的绝对值

说明：计算|x|,当x不为负时返回x，否则返回-x

ceil

功能：求不小于x 的最小整数

说明：返回x的上限
如74.12的上限是75
-74..12的上限为-74，返回值为float类型

floor

求不大于x 的最大整数

说明：返回x的下限
如74.12的下限是74
-74..12的下限为-75，返回值为float类型

pow

功能：计算x 的y次幂

说明：x应大于0，返回幂指数的结果

sqrt

功能：计算x的平方根

说明：x应该大于0

sin

计算x（弧度表示）的正弦值

说明：x的值域为[-1.0,1.0]

格式输出输入

C语句的分类

表达式语句

一般形式：表达式；

例：x=y+z；i++

函数调用语句

一般形式：函数名（实际参数表）

例：printf("C Program");

复合语句

把多个语句用{}括起来组成一个语句

例：{
x=y+z;a=b+c;
print("%d%d",x,a);
}

控制语句

条件判断语句：if switch

循环执行语句：do while，while，for

转向语句：break，goto，continue，return

空语句

只有分号";"组成的语句，什么也不执行，在程序中可做空循环体

赋值语句

一般形式：变量=表达式
例 int a；
a=5;

说明

在变量说明中给变量赋初值和赋值语句的区别

1. int a=6,b=6,c=6; /*变量赋初值*/
2. int a,b,c; /*变量的定义*/
a=6,b=6,c=6; /*赋值语句*/
3. int a,b,c; /*变量的定义*/
a=b=c=6; /*赋值语句的嵌套*/
1.2.3之间等价

赋值表达式和赋值语句的区别

赋值表达式可以包括在其他表达式之中，赋值语句不能

if((x>y;)>0) z=x; 错
if((x>y)>0) z=x; 对

数据输入输出的概念及实现

c语句本身不提供输入输出语句

输入输出操作是由C标准函数库的函数来实现的

printf();
scanf();
getchar();
putchar();

在使用输入输出函数时，要在程序文件的开头用预编译指令

#include<stdio.h>

字符数据的输入输出

putchar函数（字符输出函数）

向终端输出一个字符

一般形式：
putchar（字符变量）

getchar函数（字符输入函数）

从键盘上输入一个字符，当输入多个字符时，只取第一个

一般形式：
getchar()

格式输出——printf函数

printf函数

作用：按照指定的输出格式，向终端输出若干个任意类型的数据

一般格式：
printf(格式控制，输出表列)
如printf("%d,%c\n",i,c);

格式控制

用双引号括起来的字符串，它包括两种信息

格式说明，由"%"和格式字符组成，
如%d，%f。

格式字符

整数的格式输出

d格式符：输出十进制整数

%d：按整型数据的实际长度输出

%md： m为指定字段的输出宽度
如果数据的位数小于m，则左端补空格
如果数据的位数大于m，则按实际位数输出
如 printf("%4d",a);

%ld：输出长整型数据
long int a=135790;
printf("%ld",a);

%o格式符：以八进制输出无符号整数

%x格式符：以十六进制输出无符号整数

%u格式符：输出十进制无符号(unsigned)整数

字符的格式输出

c格式符：用来输出一个字符

s格式符：用来输出一个字符串

%s：按字符串的实际长度输出

%ms：m为指定输出字段的宽度
如果字符串长度小于m，左边补空格
如果字符串长度大于m，按实际长度输出

%m.ns：输出占m列，只取字符串左端n个字符，
输出在右侧，左补空格

%-m..ns：输出在左侧，右补空格。
如果n>m，则m自动取n值，输出n个字符

实数的格式输出

单精度floal有效位：6位
双精度double有效位：15位

f格式符：用来输出实数，以小数形式输出

%f：系统自动指定宽度，整数部分全部输出，小数部分输出6位

%m.nf：输出占m列，n为小数位，输出在右侧，左端补空格

%-m.nf：输出在左侧，右端补空格
如果m小于（整数位数+n），则正常输出，小数部分输出n位

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

%e：系统自动指定宽度，共13位，小数部分占6位，指数占5位

%m.ne输出占m列，n为小数位，输出在右侧，左补空格

%-m.nf：输出在左侧，右端补空格
如果m小于（整数位数+n），则正常输出，小数部分输出n位

%me：没有指定小数位，则小数位6位

g格式符：
用来输出实数，输出格式为f格式或e格式，
系统会根据数据占宽度m大小，自动选择
占宽度较小的某种格式输出，g格式不输出小数点后无意义的0

格式字符归纳

普通字符，需要原样输出的字符
（一般都是说明性文字和逗号，空格等）

输出列表

需要输出的一些数据，可以使变量，也可以是表达式

格式输入——scanf函数

scanf函数

一般形式
scanf(格式控制，地址列表)
地址列表可以是变量的地址（加&）或字符串的首地址

格式声明

以%开始，以一个格式字符结束，中间可以插入
附加的字符（如“，”）

格式字符归纳

&a声明

&是一个取地址运算符，&a是一个表达式，其功能是求变量的地址。
这个地址是编译系统在内存中给a变量分配的存储空间地址

变量的值和变量的地址是两个不同的概念
变量的地址是C编译系统分配的
变量的地址和变量值关系如下
如a=567；a为变量名，567是变量的值
&a是变量a的起始地址1001。

使用scanf函数应注意的问题

scanf函数没有精度控制

scanf函数中要求给出变量地址，而不是变量名

若格式控制中没有非格式字符做输入数据之间的间隔，则可以空格，tab，回车做间隔
如果有非格式字符，则在输入时，在对应位置上要输入这些字符

在输入字符数据时，若格式控制串中无非格式字符，则认为所有输入的字符均为有效字符

例：scanf("%c%c%c",&c1,&c2,&c3);
输入a_b_c
输出a_b_
因为把'a'赋给c1,把_赋给c2,'b'赋给c3，因为空格是有效字符

如果%后面有一个“*”附加说明符，表示跳过他指定数列

例：scanf("%2d_%*3d_%d",&a,&b);
输入12_345_67
系统将12赋给a，%*3d表示读入3位整数，但不会赋给任何变量，跳过345，将67赋给b

关系运算符和关系表达式

关系运算符

C语言提供6中关系运算符
1. < 小于
2. > 大于
3. <= 小于等于
4.>= 大于等于
5.== 等于
6.！= 不等于
1、2、3优先级相同（高）
4、5、6优先级相同（低）

算数运算符（+ - * / %）、关系运算符（> < >= <= == !=）、
赋值运算符（=）的优先级比较

算数运算符高
关系运算符 ↓
赋值运算符低

关系表达式（左结合性）

定义：用关系运算符将两个表达式连接起来的式子

一般形式：
表达式关系运算符表达式
表达式可以是
算数表达式 a+b>c-d
逻辑表达式、关系表达式 (a>b)>(c-d)
赋值表达式 (a=3)>(b=5)
字符表达式 'a'+1>c

关系表达式的值是一个逻辑值，即真或假

C语言编译系统在表示逻辑运算结果时，1代表真，0代表假
但是在判断一个量是否为“真”时，以“0代表假”，以非零的数值代表真

逻辑运算符和逻辑表达式

逻辑运算符

1. && 逻辑与
2. || 逻辑或
3 ！逻辑非
1、2是双目运算符，3是单目运算符
优先级：！→&& →||

a&&b 只有a，b都为真，则a&&b都为真
a||b 只要a，b有一个为真a||b为真
！a 若a为真，则！a为假

如a=7，b=8，c=9，a1=-7，求下列的值
a>b&&b>c 0
a+a1||b+a1 1
a>b||c>b 1
!a &&! b 0
! a|| b 1

逻辑运算符、算数运算符、关系运算符优先级
！非高
算数运算符 ↓
关系运算符 ↓
&&和|| ↓
赋值运算符低

逻辑表达式

一般形式：
表达式逻辑运算符表达式

运算规则：
只有在必须执行下一个表达式才能求解时，才求解该表达式
（并不是所有的表达式都被求解）

对于逻辑与（&&）运算，如果第一个操作数被判定为假，
系统不再判定或求解第二个操作数

对于逻辑或（||）运算，如果第一个操作数被判定为为真，
系统不再判定或求解第二个操作数

选择结构（if、switch）

if语句

if语句的作用：

用来判定所给的条件是否满足
并且判定的结果（真或假）决定执行给出的两种操作之一

if语句有三种基本形式

if

例题：输入两个数a，b判断并输出其中较大的数
main()
{
int a,b,max;
printf("输入两个数\n");
scanf("%d%d",&a,&b);
max=a;
if(max<b) max=b:
printf("max=%d",max);
}

if-else

例题：输入两个数a，b判断并输出其中较大的数
main()
{
int a,b,max;
printf("输入两个数\n");
scanf("%d%d",&a,&b);
if(a>b)
printf("max=%d\n",a);
else
printf("max=%d\n",b);
}

if-else-if

if(表达式1) 如果表达式1为真，执行语句1；
语句1; 如果表达式2为真，执行语句2；
if(表达式2) .
语句2； .
. .
. .
. .
if(表达式n) 如果表达式n为真，执行语句n；
语句n; 否则执行语句m。
else
语句m;

例题：已知百分之成绩mark，显示对应等级成绩
90-100优秀 80-89良好 70-79中等
60-69及格 <60不及格

void main()
{
int mark:
scanf("%d",&mark);
if(mark)<60
printf("不及格\n");
if(mark)<69
printf("及格\n");
if(mark)<79
printf("中等\n");
if(mark)<89
printf("良好\n");
if(mark)<100
printf("优秀\n");
else
printf("输入错误\n");
}
注意：
写这种多分支语句时，应该从小于小的，
大于打大的开始写

if语句中应该注意的问题

该表达式通常是逻辑表达式或关系表达式，但也可以是其他表达式，甚至也可以是一个变量
if(a=5) if(b)

在if语句中，条件判断表达式，必须用括号括起来，在语句之后必须加分号
if(a>b)
max=a;

在if语句的三种形式中，所有的语句应为单个语句，如果现在满足条件时执行一组（多个）语句，
则必须把这一组语句用{}括起来组成一个复合语句。但要注意在}后不能再加分号。
if(a>b) {a++,b++}
else {a=0,b=0;}

例题：输入两个实数，按代数值从小到大的顺序输出这两个数
解题思路：如果a>b,交换a，b如果a<b,不用交换
int main()
{
float a,b,t;
scanf("%a,%b",&a&b);
if(a>b)
{
t=a;
a=b;
b=t;
}
printf("%52f,%5.2f\n",a,b)
return 0;
}

if语句的嵌套

在if语句中又包含一个或多个if语句，称为if语句的嵌套

if()
if()
语句1;
else
语句2;
else
if()
语句3;
else
语句4;
else总是与它前面最近的没有配对的if配对

例题：比较两个数的大小关系
main ()
{
int a,b;
printf("输入两个数：\n");
scanf("%d,%d",&a&b);
if(a!=b)
if(a>b)
printf("a>b\n");
else
printf("a<b\n");
else
printf("a=b\n");
}

条件运算符

？

格式：
表达式1？表达式2:表达式3
如果表达式1为真，执行表达式2；否则执行表达式3

例：
if(a>b) 等价于 max=(a>b)?a:b;
max=a;
else
max=b;

结合性：
自右向左

switch语句——实现多分支选择结构

一般形式：

switch(表达式) 表达式可以使整数类型（包括字符型）
{
case 常量表达式1:语句1；break;
  case 常量表达式2:语句2；break;
  case 常量表达式3:语句3；break;
……
  case 常量表达式n:语句n；break;
default:语句n+1;
}

说明

在case后的常量表达式值不能相同，否则会出现错误

在case后，允许有多个语句，可以不用{}括起来，没有语句时，什么也不做，直到遇到后面的break。

case和default子句的先后顺序可以变动，而不会影响程序执行的结果

default子句可以省略不用

case后不能出现多个变量，不能出现变量及有关运算符

例题：按考试成绩等级输出百分制分数段，
A等85分以上，B等70-84分，C等60-69分，D等60分以下
由键盘输入成绩等级

void main()
{
char mark;
scanf("%c",&mark);
switch(mark)
{
case A:printf("85分以上\n");break;
case B:printf("70-74分\n");break;
case C:printf("60-69分\n");break;
case D:printf("60分以下\n");break;
default:printf("输入错误\n");break;
}
}

选择结构综合举例

写一个程序，判断是否是闰年
用变量leap代表是否是闰年的信息
若是闰年，令leap=1，非闰年，leap=0
最后判断leap是否为1（真），若是输出闰年信息

#include<stdio.h>
void main()
{
int year leap;
printf("请输入一个年份\n");
scanf("%d",&year);
if(year%4==0)
if(year%100==0)
if(year%400==0)
else leap=0;
else leap=1;
else
leap=0;
if(leap)
printf("%d是闰年",year);
else
printf("%d不是闰年",year);
printf("a leap year \n");
}