C语言详细知识点复习（上）

❄️下一篇❄️C语言详细知识点（下）

一、C语言概述

1、C语言的主要特点

程序一组计算机能识别和执行的指令

1、什么是计算机语言？

机器语言：计算机工作基于二进制，从根本上来说计算机只能识别和接受由0和1组成的指令。计算机能直接识别和接受的二进制代码称为机器指令。机器指令的集合就是该计算机的机器语言。
符号语言：它用英文字母和数字表示一个指令，例如用add代表“加”，sub代表“减”。又称为符号汇编语言或汇编语言
高级语言：语言功能性很强，且不依赖于具体的机器，用它写出的程序对任何型号的计算机都适用，它与具体的计算机距离较远，所以成为高级语言

高级语言发展阶段
1、非结构化语言
2、结构化语言
3、面向对象语言

2、C语言程序的结构

1. 一个程序由一个或多个源程序文件组成
   预处理指令 如#include
   全局声明 即在函数之外进行数据声明
   函数定义 指定每个函数的功能
2. 函数是C程序的主要组成部分 编写C程序就是编写一个个函数
3. 一个函数包括两个部分
   函数首部 即函数的第一行，包括函数名，函数类型，函数属性，函数参数，参数类型
   函数体 即函数首部下面花括号的部分
   声明部分
   执行部分 由若干个语句组成，指定函数中所进行的操作
4. 程序总是从main函数开始执行的
5. 程序中要求计算机完成的操作是由函数中的C语句完成的
6. 在每个数据声明和语句的最后必须有一个分号
7. C语言本身不提供输入输出语句 输入输出语句是由库函数scanf和printf等函数来完成的
8. 程序应当包含注释

3、运行C程序的步骤与方法

1. 上机输入和编译源程序 a.c
2. 对源程序进行编译处理 a.obj
3. 进行连接处理 a.exe
4. 运行可执行程序

4、程序设计的任务

1. 问题分析
2. 设计算法
3. 编写程序
4. 对源程序进行编辑、编译和连接
5. 运行程序，分析结果
6. 编写程序文档

2、算法的概念及特点

1、程序=算法+数据结构
1、对数据的描述，在程序中指定用到哪些数据，以及这些数据的类型和数据的组织形式。这就是数据结构
2、对操作的描述，要求计算机操作的步骤，也就是算法

2、简单算法举例
1、求5！

#include
int main(){
	//求5的阶乘 
	int t=1,i=2;
	while(i<=5){
		t=t*i;
		i++;
	}
	printf("%d",t);
} 
1
2
3
4
5
6
7
8
9
10

2、求1* 3* 5* 7* 9

#include
int main(){
	//求1*3*5*7*9
	int t=1,i=3;
	 while(i<=9){
 		t=t*i;
 		i=i+2;
 	}
 	printf("%d",t);	
}
1
2
3
4
5
6
7
8
9
10

3、有50个学生，要求输出成绩在80分以上的学生的学号和成绩
4、判定2000-2500年中的每一年是否为闰年，并将结果输出
5、给出一个大于或等于3的正整数，判断它是不是一个素数

3、算法的特性

1. 有穷性
2. 确定性
3. 有零个或多个输入
4. 有一个或多个输出
5. 有效性

4、三种基本结构

1. 顺序结构
2. 选择结构
3. 循环结构

• 当型（while型）循环结构
• 直到型（until型）循环结构

二、C程序设计的基础语法

1、常量和变量

1、常量

1. 整型常量 如100，25，-100
2. 实型常量

• 十进制小数形式，由数字和小数点组成。如12.34，0.0，1.0，-0.2
• 指数形式，如 12.34e3（代表12.34 * 10³）,0.145E-25(代表0.145 * 10^-25),故规定以字母e或E代表以10为底的指数，注意：e或E之前和之后必须有数字，且e或E后面必须为整数

3. 字符常量

• 普通字符，用单撇号括起来的一个字符，如：‘a’,‘#’,‘?’ 注意：撇号只是界限符，字符常量只能是一个字符，不包括单撇号，字符常量存储在计算机存储单元中时，并不是存储字符本身，而是以其代码（一般采用ASCII代码）存储的。
• 转移字符，意思是将"\"后面的字符转换成另外的意义如’\101’代表八进制101也就是10进制65对应字符’A’，‘\x41’代表十六进制41也就是10进制65对应字符’A’。
  

4. 字符串常量，用双撇号把若干个字符括起来。
5. 符号常量，用#define指令，指定用一个符号名称代表一个常量，如 #define PI 3.1415 //注意行末没有分号
   好处见名知意、一改全改，注意符号常量不占内存，编译后，符号不存在

2、变量

变量代表一个有名字的、具有特定属性的一个存储单元
变量必须先定义后使用，变量名实际上是以一个名字代表的一个存储地址，从变量中取值，实际上是通过变量名找到相应的内存地址，从存储单元中读取数据。

3、标识符

用来对变量、符号常量名、函数、数组、类型等命名的有效字符序列统称为标识符，简单来说标识符就是一个对象的名字
标识符只能由数字、字母和下划线组成，且不能以数字开头
编译系统区分大小写自定义的标识符不能是关键字

2、数据类型

C标准没有具体规定各种类型数据所占用存储单元的长度，这是由各编译系统自己决定的。sizeof运算符，可以测量变量或类型的长度，占用的字节数，决定了可以表示数的范围

1、整型数据分类

1. 整型（int）4字节
2. 短整型（short int）2字节
3. 长整型（long int）4字节
4. 双长整型（long long int）8字节

注意：只有整型、字符型可以使用signed或unsigned修饰，实型不可以，无符号整型用%u输出，%u表示用无符号十进制数的格式输出

2、字符型数据

由于字符是按其代码（整型）形式存储的，因此C99把字符型数据作为整型的一种
大写字母’A’的 ASCII代码是十进制数65,二进制形式为1000001。
小写字母’a’的ASCII 代码是十进制数97,二进制形式为1100001。
数字字符’1’的ASCII代码是十进制数49,二进制形式为0110001。
空格字符’‘的 ASCII代码是十进制数32,二进制形式为0100000。
专用字符’%'的ASCII代码是十进制数37,二进制形式为0100101。
转义字符’n’的 ASCII代码是十进制数10,二进制形式为0001010。

字符变量是用类型char定义字符变量。

char c='?'；
printf("%d %c",c,c);
输出结果63 ?
1
2
3

3、浮点型数据
由于小数点位置可以浮动，所以实数的指数形式称为浮点数。
浮点数类型包括，float（单精度浮点型），double（双精度浮点型），long double（长双精度浮点型）
1、float – 4字节 – 3.14f – 6位有效数字
2、double – 8字节 – 3.14 – 15位有效数字
3、long double – 16字节 3.14l–19位有效数字 不同编译器对long double型处理方法不同

区分类型和变量
每一个变量都属于一个确定的类型，类型时变量的一个重要属性，变量是占用存储单元的，是具体存在的实体，在其占中的存储单元中可以存放数据。类型是变量的共性，是抽象的，不占用存储单元，不能存放数据

3、运算符和表达式

1、C语言运算符
（1）算数运算符 （+ - * / ++ --）
（2）关系运算符（> < == >= <= !=）
（3）逻辑运算符（！&& ||）
（4）位运算符（<< >> ~ | &）
（5）赋值运算符（=）
（6）条件运算符（？：）
（7）逗号运算符（，）
（8）指针运算符（ * &）
（9）求字节数运算符（sizeof）
（10）强制类型转换运算符（（类型））
（11）成员运算符（. ->）
（12）下标运算符（[ ]）

全部运算符解释：注意符号，优先级，结合性，运算规则

（1）、算数运算符
符号：+、-、*、/（两个整数相除结果为整数）、%（操作数必须为整数）、++、 – （只能用于变量，分清前缀后缀）

优先级：算数运算符是自左至右，赋值运算符是自右至左

结合性：除数和被除数中一个为负值，则舍入的方向是不固定的，多数编译系统采取“向零取整”的方法，即5/3=1 -5/3=-1 取整后向0靠拢
运算规则
++i ,–i （在使用之前，先使 i 的值加（减）1）
i++ ,i-- （在使用之后，使 i 的值加（减）1）

int  a=3,c;
c=a++;   c=3 a=4    ==>c=a; a++
c=++a;   c=4,a=4    ==>a++ ;c=a
2.5/2=1.25
5/2=2
(a+b)++     错误
1
2
3
4
5
6

例1、给定一个大写字母，要求用小写字母输出

#include
int main()
{
	char a='A';
	printf("%c",a+32);
	return 0;
}
1
2
3
4
5
6
7

例2、输入一个四位数，分别输出千位、百位、十位和个位

#include 
void main()
{
  	int x,a,b,c,d;
  	scanf("%d",&x);
  	a=x/1000;
  	b=x%1000/100;
  	c=x%100/10;
  	d=x%10;
  	printf("千位:%d百位：%d十位：%d个位：%d",a,b,c,d);
}
7536
千位:7百位：5十位：3个位：6
1
2
3
4
5
6
7
8
9
10
11
12
13

强制类型转换
(double)a
(int)(x+y)
(float)(5%3)

（2）、关系运算符
符号（> < >= <= != ==）

优先级：
1、前四种关系运算符的级别相同，后两种也相同，前四种高于后两种
2、关系运算符的优先级低于算数运算符
3、关系运算符的优先级高于赋值运算符

用关系运算符将两个数值或数值表达式连起来的式子称为关系表达式。如：a>b,a+b>b+c

结合性：自左至右
关系表达式的值 1（表达式成立，真）或0（表达式不成立，假）
运算规则
int x=5;
10<=x<=99 关系表达式自左至右求解，先求10<=x,则表达式不成立表达式的值为0 ，接下来继续求解0<=99 ,结果为1
不论x的值是多少，表达式10<=x<=99的值恒为1

思考为什么：：：表达式 (3==x==3) 的值恒为0
1

（3）、逻辑运算符
符号 &&逻辑与 ||逻辑或（双目运算符） ！逻辑非（单目运算符）
优先级：
1、！（非）->&&（与）->||（或）
2、逻辑运算符中的&&和||低级运算符，！高级运算符

结合性：自左至右

运算规则 （a,b可以为一个常量或变量或表达式）
a &&b，a,b两者同为真（非零为真，否则为假）时，结果为真
a||b，a,b同时为假，结果为假，否则结果为真
！a，取反，a为真，结果为假，a为假结果为真
系统如何判断一个量的真假：非零为真，0为假
系统如何表示真假：1–真 0----假

逻辑表达式的值为1或0，成立（真）为1，否则为0
a=3,b=4,c=5
((a+b)>c)&&(b==c)     逻辑表达式  值为0
a||((b+c)&&(b-c))       短路现象          1
((!(a>b))&&(!c))||1       不存在短路现象    1
(!(x=a))&&(y=b)&&0      短路现象   0
((!(a+b))+c-1)&&(b+c/2)         1
1
2
3
4
5
6
7

短路现象：存在于&&和||中，
a&&b，当a为假的时候，不需要计算b的值，就可以直接得到整个逻辑表达式的值为假，这个现象称为短路现象
a||b，当a为真的时候，不需要计算b的值，就可以直接得到整个逻辑表达式的值为真，这个现象称为短路现象
例如
a=3,b=4,c=5
x=1，y=2则执行下面的表达式后，x=3，y=2（短路现象）
(!(x=a))&&(y=b)&&0
逻辑运算符两侧运算对象的数据类型可以是任何类型的数据

（4）、条件运算符

符号： ？：（三目运算符）
表达式1？表达式2：表达式3
优先级： 条件运算符优先级高于赋值运算符，因此赋值表达式的求解过程式先求解条件表达式，再将其赋值给变量
运算规则： 求解表达式1，为真则求解表达式2，并将表达式2的结果作为整个条件表达式的结果，否则求解表达式3，并将表达式3的结果作为整个条件表达式的结果

等价于二分支结构
if(表达式1)
表达式2
else
表达式3
1
2
3
4
5

（5）、逗号运算符
符号： ，
运算规则： 自左至右求解，并将最后一个表达式的值作为整个条件表达式的值

间接引用运算符：后面只能跟地址，表示的是地址指向的内存
int a; *&a===a

地址运算符&：后面只能跟变量
int a;int *p=&a; &a=====p 均指整型变量a的地址
int *p; &p-----代表指针变量的地址，合法

4、C 语句

1、控制语句

1. if()…else…（条件语句）
2. for()…（循环语句）
3. while()…（循环语句）
4. do…while()（循环语句）
5. continue（结束本次循环语句）
6. break（终止循环语句）
7. switch（多分支选择语句）
8. return
9. goto

2、函数调用语句：由一个函数调用加一个分号组成
printf(“hello world”);

3、表达式语句：由一个表达式加一个分号组成
a=3；

4、空语句
；
可以用来作为流程的转向点（流程从程序其他地方转到此语句处），也可以作为循环语句中的循环体（循环体是空语句，表示什么也不做）

5、复合语句：用{}把一些语句和声明括起来成为复合语句（语句块）

{
	float pi=3.14,r=2.5,area；
	area=pi*r*r;
	printf("area=%f",area);
}
1
2
3
4
5

1、赋值语句

（1）基本赋值运算符=：将右侧的值赋给左侧的变量
int a,b; a+b=5(错误)

（2）复合赋值运算符+=：
a+=b<===> a=a+(b) 括号不要忘记 a一定是变量，b是表达式（一个变量或常量是最简单的表达式）
如 a%=x+y ===> a=a%(x+y)

（3）赋值表达式
赋值表达式的作用将一个表达式的值赋给一个变量，因此赋值表达式具有计算和赋值双重功能
对赋值表达式求解的过程是：先求赋值运算符右侧的表达式的值，然后赋给赋值运算符左侧的变量，表达式的值等于赋值后左侧变量的值

a=b=c=5
a=5+(c=6)
a=(b=4)+(c=6)
1
2
3

（4）结合性：自右至左

int a,b,c=8;a=b=c ===> a=(b=c)
int a,b,c;  a=b+1=c+2;===>a=(b+1=c+2)  错误
int a=b=3;  错误，b未声明
int a=3,b=3;  或 int a,b; a=b=3;正确
1
2
3
4

（5）赋值运算符两侧的类型转换
两侧的类型都是数值型，以左侧变量的类型为准，由系统自动完成

double a=1;   ==>a=1.0
int a=3.4;  ==>int a=(int)3.4  -->a=3(有精度损失的警告，但不影响运行，但在java中报编译错误)
1
2

5、数据的输入和输出

1、输入输出概念
（1）输入输出是以计算机主机为主体而言的
（2）C语言本身不存在输入输出语句
（3）要在程序文件的开头用预处理指令#include把有关头文件放在本程序中

• 用尖括号形式（）时编译系统从内存存放C编译系统的子目录中去找所要包含的文件（stdio.h），这称为标准方式。
• 如果用双撇好形式（"stdio.h"），在编译时，编译器系统首先在用户的当前目录（一般是用户存放源程序文件的子目录）中寻找要包含的文件，若找不到，在按标准方式查找

2、用printf输出数据

（1）printf函数的一般格式
printf(格式控制，输出列表)

• 格式控制：是用双撇号括起来的一个字符串，称为格式字符串
  以%开头的格式控制符（与输出项对应），以及其他普通字符（原样输出）
• 输出列表，常量、变量或表达式

（2）格式字符

1. d格式符：用来输出一个有符号的十进制整数，长整型 ld
   指定输出数据的域宽（所占的列数），如用“%5d”指定输出数据占5列，输出的数据显示在此5列区域的右侧

printf("%5d\n%5d",12,-345);
   12 （12前面3个空格）
 -345（-345前面1个空格）
1
2
3

2. c格式符：用来输出一个字符
3. s格式符：用来输出一个字符串
4. f格式符：用来输出一个实数（单、双精度、长双精度），以小数形式输出
   4.1.基本型，用%f不指定输出的长度，实数的整数部分全部输出，小数部分输出6位
   4.2.指定数据宽度和小数位数，用%m,nf

double a=1.0;
printf("%20.15f",a/3);
   0.333333333333333
1
2
3

4.3.输出的数据向右对齐，用%-m.nf，当数据长度不超过m时，数据向左靠，右端补齐空格

5. e格式符：指定以指数输出实数
   printf(“%e”,123456.789);

   

3、用scanf输入数据

（1）scanf函数的一般形式
scanf（格式控制，地址列表）

（2）scanf函数中的格式声明
以%开始，以一个格式字符结束，中间可以插入附加的字符，以及其他普通字符（原样输入）
scanf(“a=%f,b=%f,c=%f”,&a,&b,&c);

（3）使用scanf函数时注意的问题
3.1.格式控制后面是变量地址而不是变量名 scanf("%f",a);错误
3.2.如果格式声明外还有其他字符，输入数据时应当输入对应字符 scanf("a=%f",&a) 输入a=2
3.3.在用"%c"格式输入字符时，空字符和转义字符中的字符都作为有效字符输入

	scanf("%d%c%f",&a,&b,&c);
	输入：1234a 123o45
1
2

4、字符输入输出函数
1、用putchar输出一个字符
例1、先后输出BOY三个字符

#include
void main()
{
	char a='B',b='O',c='Y';
	//char a=66,b=79,c=89;
	putchar(a);
	putchar(b);
	putchar(c);
	putchar('\n');
}
1
2
3
4
5
6
7
8
9
10

2、getchar输入一个字符
例2、输入BOY并输出

#include
void main()
{
	char a,b,c;
	a=getchar();
	b=getchar();
	c=getchar();
	putchar(a);
	putchar(b);
	putchar(c);
	putchar('\n');
}
1
2
3
4
5
6
7
8
9
10
11
12

注意：在输入BOY并按回车后，字符才送到计算机中，然后输出
例3、输入大写字母输出小写字母

#include
void main()
{
	char a;
	a=getchar();
	putchar(a-32);
}
1
2
3
4
5
6
7

三、选择结构

（1）if语句

语法：if(表达式)
语句
注意：
1）表达式是任意合法的表达式，表达式后不能加分号
2）语句为一条语句，如果有多条，需要用大括号构成复合语句
3）执行：如果表达式成立（为真，非零为真），则执行语句

例1、输入两个实数，按照由小到大输出这两个数

#include 
void main()
{
    float a,b,t;
    scanf("%f%f",&a,&b);
    if(a>b){
    	t=a;
    	a=b;
    	b=t;
    }
    printf("%.2f,%.2f",a,b);
}
1
2
3
4
5
6
7
8
9
10
11
12

例2、输入三个数a,b,c，要求由小到大输出

#include 
void main()
{
    float a,b,c,t;
    scanf("%f%f%f",&a,&b,&c);
    if(a>b){
    	t=a;
    	a=b;
    	b=t;
    }
    if(a>c){
    	t=a;
    	a=c;
    	c=t;
    }
    if(b>c){
    	t=b;
    	b=c;
    	c=t;
    }
    printf("%.2f,%.2f,%.2f",a,b,c);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

（2）if…else语句
语法：if(表达式)
语句1
else
语句2
注意：
1）表达式是任意合法的表达式
2）语句1、2为一条语句，如果有多条，需要用大括号构成复合语句
3）else表示的情况与if完全相反，并且else必须和if配对使用
4）执行：如果表达式成立（为真，非零），则执行语句1，否则执行语句2

例3、输入一个小写字母，转成大写字母

#include 
void main()
{
	char c1,c2;
	c1=getchar();
	if(c1>=97&&c1<=122)
		c2=c1-32;
		putchar(c2);
		else
		printf("error");
}
//程序错误
1
2
3
4
5
6
7
8
9
10
11
12

else总是和离它最近没有配对的if配对，可以用大括号改变配对，else不能单独使用

（3）if语句的嵌套

例4、有一阶跃函数，输入一个x值，输出对应y值

#include
void main(){
   int x,y;
   scanf("%d",&x);
   if(x>=0){
   		if(x>0) y=1;
   		else y=0;
   } else{
   		y=-1;
   } 
   printf("y=%d",y);
}
1
2
3
4
5
6
7
8
9
10
11
12

（4）switch 语句—多分支语句（开关语句）
switch(表达式)
{
case 常量表达式1:语句1；
case 常量表达式2:语句2；
case 常量表达式3:语句3；
….
default:语句n；
}
注意：
1）表达式可以为任意合法的表达式，但其值必须为整型（字符型）
2）case后面必须是常量表达式，并且不能重复
3）case后面的语句可以有多条，不必加括号
4）执行：首先计算表达式的值，然后将其和case后面的常量比对，如果相等，则执行case后面的语句，一直到结束，除非遇到break语句，结束swtich语句
5）多个case可以共用一条语句
6）break ，default不是必须的

例5、A等成绩85分以上，B等成绩70 ~ 84分，C等成绩60 ~ 69分，D等成绩60分以下，成绩键盘输入

#include
void main(){
	char x;
	scanf("%c",&x);
	switch(x){
		case 'A':
		case 'a':printf("85~100");break; 
		case 'B':
		case 'b':printf("70~84");break; 
		case 'C':
		case 'c':printf("60~69");break; 
		case 'D':
		case 'd':printf("0~60");break;
		default:printf("error"); 
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

例6、90 ~ 100为A，80 ~ 89为B，70 ~ 79为C，60~69为D，60以下为E，分数键盘输入

#include 
void main()
{
    float x;
    int t;
    scanf("%f",&x);
    t=(int)(x/10);
    switch(t)
    {
    	case 10:
    	case 9:printf("A");break;
    	case 8:printf("B");break;
    	case 7:printf("C");break;
    	case 6:printf("D");break;
    	case 5:
    	case 4:
    	case 3:
    	case 2:
    	case 1:
    	case 0:printf("E");break;
    	default:printf("error");
    } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

选择程序结构综合举例
例7、判定输入的年份是否为闰年，并将结果输出
分析：
条件一：普通闰年：公历年份是4的倍数，且不是100的倍数的，为闰年（如2004年、2020年等就是闰年）。
条件二：世纪闰年：公历年份是整百数的，必须是400的倍数才是闰年（如1900年不是闰年，2000年是闰年）。

#include
void main(){
	int x,flag;
	scanf("%d",&x);
	if(x%4==0){
		if(x%100==0){
			//能被400整除,满足条件而二 
			if(x%400==0){
				flag=1;
			} else{
				flag=0;
			}
		}else{
			//能被4整除，不能被100整除，满足条件一 
			flag=1; 
		}
	}else{
		flag=0;
	}
	if(flag) printf("%d是闰年",x); 
	else printf("%d不是闰年",x); 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

例8： 求ax²+bx+c=0的解
思考方法？？？

四、循环结构

1、循环结构

循环变量的初始值、循环条件、循环体（一条语句，循环体中有使循环条件趋于不成立的语句）

（1）while语句
语法：
while(表达式)//循环条件，后面没有分号
{
语句 //循环体，包含使循环条件不成立的语句
}
注意：
1）表达式为任意合法的表达式，当表达式为真时，执行循环体，当表达式为假，结束循环，循环体最少执行0次

例1、求1~100的和

#include 
void main()
{
    int i=1,t=0;
    while(i<=100){
    	t=t+i;
    	i++;
    }
    printf("%d",t);
}
//5050
1
2
3
4
5
6
7
8
9
10
11

（2）do…while语句
语法：
do
{
语句//循环体，包含使循环条件不成立的语句
}while(表达式); //循环条件，后面有分号
注意：
1）表达式为任意合法的表达式，先执行语句，然后判断循环条件，当表达式为真时，继续执行循环体，当表达式为假，结束循环，循环体至少执行1次

例2、求1~100的和

#include 
void main()
{
    int i=1,t=0;
    do{
    	t=t+i;
    	i++;
    	}
    while(i<=100);
    printf("%d",t);
}
1
2
3
4
5
6
7
8
9
10
11

（3）for语句
语法：
for(表达式1;表达式2;表达式3)//后面没有分号
{
语句
}
注意：先执行表达式1，然后判断表达式2，如果为真则执行语句，然后执行表达式3，如果为假则结束循环
三个表达式都可以省略，分号不可以省略
表达式1通常为循环初始条件，表达式3通常为循环变量的改变
例3、求1~100的和

#include 
void main()
{
	int i,t=0;
	for(i=1;i<=100;i++){
		t=t+i;
	}
	printf("%d",t);
    
}
1
2
3
4
5
6
7
8
9
10

例4、输出以下矩阵

#include 
void main()
{
    int i,j,k;
    for(i=1;i<=4;i++)
    {
		for(k=1;k<=4-i;k++)
		{
    		printf(" ");
		}
    	for(j=1;j<=i;j++)
    	{
    		printf("*");
    	}
    	printf("\n");    	
    }    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1️⃣ for语句一般形式：for(表达式1;表达式2;表达式3)
等价于
表达式1；
while 表达式2
{
语句
表达式3
}
2️⃣ 表达式1可以省略
i=1;
for(;i<=100;i++) sum=sum+i;

3️⃣ 表达式2可以省略
for(i=1;;i++) sum=sum+i;

4️⃣ 表达式3可以省略
for(i=1;i<=100;){
sum=sum+i;
i++;
}
5️⃣表达式1和表达式3都没有
i=1;
for(;i<=100;){
sum=sum+i;
i++;
}
6️⃣3个表达式都省略 😉
for( ; ; ) printf(“%d”,i);

7️⃣表达式1可以是与循环变量无关的其他表达式,
for(sum=0;i<=100;i++) sum=sum+i;

8️⃣表达式1和表达式3也可以是逗号表达式，即包含一个以上的简单表达式
for(i=0,j=100;i<=j;i++,j–)

9️⃣表达式2可以是数值表达式或字符表达式
for(i=0;(c=getchar())!=‘\n’;i+=c);
for(;(c=getchar())!=‘\n’; ) printf(“%c”,c);

2、break\continue

break 结束其所在的循环（可用在循环和选择结构中）
continue结束本次循环，接着进行下一次循环条件的判断（只能用在循环结构中）

例1、在全系1000名学生中举行慈善募捐，当总数达到10万时就结束，统计此时捐款人数以及平均每人捐款的数目。

#include 
void main()
{
	float toal=0.0,amount,aver;
	int i;
	for(i=1;i<=1000;i++){
		scanf("%f",&amount);
		toal=toal+amount;
		if(toal>=100000)break;
	}
	aver=toal/i;
	printf("捐款人数%d捐款平均金额%f",i,aver);   
}
输入：
55555
44444
11111
输出：
捐款人数3捐款平均金额37036.666667
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

例2、输出100~200不能被3整除的数

#include 
void main()
{
	int i;
	for(i=100;i<=200;i++){
		if(i%3==0)
			continue;
			printf("%d\n",i);
	} 
}
1
2
3
4
5
6
7
8
9
10

3、循环程序举例

例3、输出以下4*5矩阵
1 2 3 4 5
2 4 6 8 10
3 6 9 12 15
4 8 12 16 20

#include 
void main()
{
   int i,j;
   for(i=1;i<=4;i++){
   	for(j=1;j<=5;j++){
   		printf("%d\t",i*j);
   	}
   	printf("\n");
   	}
}
1
2
3
4
5
6
7
8
9
10
11

例4、用公式π/4≈1-1/3*1/5-1/7+…求π的近似值，直到发现某一项的绝对值小于10^-6为止（该项不累加）

#include 
#include 
void main()
{
	int sign=1;
	float pi=0.0,term=1.0,n=1.0;
	while(fabs(term)>=1e-6){//fabs取绝对值
		pi=pi+term;
		n=n+2;
		sign=-sign;
		term=sign/n;
	}

	printf("%f",pi*4);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

例5、求斐波那契数列的前40个数，这个数列有如下特点：第1,2两个数为1,1。从第三个数开始，该数是其前面两个数之和。即该数列为1,1，2,3，5,8，13…

#include 
void main()
{
	int f1=1,f2=1,f3=0,i;
	printf("%d\n%d\n",f1,f2);
	for(i=1;i<=38;i++){
		f3=f1+f2;//后一项等于前两项和
		printf("%d\n",f3);
		f1=f2;
		f2=f3;	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

改进原来算法每月输出站一行，篇幅太大不可取

#include 
void main()
{
	int f1=1,f2=1,i;
	for(i=1;i<=20;i++){
		printf("%d\t%d\t",f1,f2);
		f1=f1+f2;
		f2=f1+f2;
		if(i%2==0) printf("\n");	
	}
}
1
2
3
4
5
6
7
8
9
10
11

例6、输入一个大于3的整数n，判定它是否为素数
注意：所谓素数是指除了 1 和它本身以外，不能被任何整数整除的数，例如17就是素数，因为它不能被 2~16 的任一整数整除。

#include 
void main()
{
	int n,i,flag=1;
	scanf("%d",&n);
	for(i=2;i<n;i++){
		if(n%i==0) 
		flag=0;
	}
	if(flag==1) printf("是素数");
	else printf("不是素数");	
}
1
2
3
4
5
6
7
8
9
10
11
12

例7、求100~200的全部素数

#include 
void main()
{
	int i,j,flag;
	for(i=100;i<=200;i++){
		flag=1;
		for(j=2;j<i;j++){
			if(i%j==0)	flag=0;
		}
		if(flag==1) printf("%d\n",i);
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12

方法二：

#include 
void main()
{
	int i,j,n=0;
	for(i=100;i<=200;i++){
		for(j=2;j<i;j++){
			if(i%j==0)	break;
		}
		if(j==i) {
			n++;
			printf("%d\n",i);	
		}
	}	
	printf("%d个素数",n);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

例8、将字母A变成字母E，a变成e，字母B变成字母F，b变成f，非字母字符保持不变，如China！变成Glmre！

#include 
void main()
{
	char ch;
	while(ch!='\n'){
		ch=getchar();
		if(ch>='a'&&ch<='z'||ch>='A'&&ch<='Z'){
		ch=ch+4;	
		}
	putchar(ch);	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

💗💙💜❤️💚💓💕💞💘💖

#include
void main()
{
	double  x, y, a;
	char ch;
	for (y = 1.5; y > -1.5; y -= 0.1)
	{
		for (x = -1.5; x < 1.5; x += 0.05)
		{
			a = x * x + y * y - 1;
			ch = a * a * a - x * x * y * y*y <= 0.0 ? '*' : ' ';
			putchar(ch);
		}
		system("color 0c");   //修改颜色
		printf("\n");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17