本文详细介绍了C语言的学习内容，包括第一个C程序的编写，数据类型的关键字，如char、int、float等，以及存储相关的关键字如register、static、const。还讲解了控制语句，如if、for、while和switch，以及运算符的使用，如算术运算符、关系运算符、逻辑运算符和位运算符。文章还涵盖了数据类型的转换、运算符优先级和结合性，以及循环控制语句的使用技巧。
第一章 第一个C程序
经典的hello world。需要在调用库函数之前对库函数进行声明，标准C库用<>符号包含调用的头文件。main函数返回int整形，一个程序中有且只有一个main函数，是程序的入口。函数开始结尾要有大括号，每条语句用分号结尾。
写注释的方法：//单行注释 注释双斜杠到行末；/* */多行注释
# include<stdio.h>
int main()
{
printf("hello world\n");
return 0;
}
第二章 数据类型及语句
2.1关键字
2.1.1数据类型相关的关键字
用于定义变量或者类型
1、char：字符型变量
定义字符型变量，占1个字节，只能定义一个字符
char ch1 = 'b';//正确
char ch2 = '1';//正确
char ch3 = '1234';//错误
字符存放的是ASCII码的值，即用1的ASCII码给ch1赋值
int main()
{
char ch;
ch = 'a';
printf("ch = %c\n", ch);
return 0;
}
2、short：短整型
short int a = 11;
一般short和int配合使用，范围是 -32768 --- 32767
3、int：整型变量
32位系统下占4个字节，16位占2字节，范围是 -20亿 --- 20亿。
int a =44;
4、long：长整型
在32位系统占4个字节
long int a = 144;
5、float：单浮点型实数
带小数点，占4个字节。f修饰3.8是float类型的实数，不加默认为double类型。
float b = 3.8f;
6、double：双浮点型实数
带小数点，占8个字节，精度更高
double b = 3.8;
7、struct：结构体类型，
8、union：联合体（共用体）
9、enum：定义枚举类型
10、signed：有符号数
在定义字符型char、整形short int long时用signed修饰，表示数据是有符号的，保存正负0，不写默认是有符号
signed int b = -6;
11、unsigned：无符号数
在定义字符型char、整形short int long时用signed修饰，表示数据是无符号的，只能保存正数和0.
unsigned int a = 100;
unsigned int a = -100; //错误
12、void：空类型
不能定义变量，修饰函数的参数和返回值，代表函数没有参数或没有返回值
void fun(void)
{
}
代表没有参数，没有返回值
int main()
{
char a;
short int b;
int c;
long int d;
float e = 3.8f;
double f = 5.6;
printf("sizeof(a) = %d\n", sizeof(a));
printf("sizeof(b) = %d\n", sizeof(b));
printf("sizeof(c) = %d\n", sizeof(c));
printf("sizeof(d) = %d\n", sizeof(d));
printf("sizeof(e) = %d\n", sizeof(e));
printf("sizeof(f) = %d\n", sizeof(f));
return 0;
//sizeof(a) = 1
//sizeof(b) = 2
//sizeof(c) = 4 说明vs编译环境是32位
//sizeof(d) = 4
//sizeof(e) = 4
//sizeof(f) = 8
}
2.1.2、存储相关关键字
1、register：寄存器
用register修饰的变量是寄存器变量。一般定义的变量的存储空间会被分配在内存中，而用register修饰变量，编译时会告诉编译器尽量将其存储空间分配在寄存器中，有可能存放入也有可能没有存放入，只有内存中的变量才有地址，故不能用取地址的方式读取register修饰的变量。
（1）定义的变量不一定是存放在了寄存器中；
（2）CPU取数据的时候在寄存器中读取比在内存中快；
（3）不能定义寄存器数组；
（4）register只能修饰字符型char和整形short、int、long，不能修饰浮点型float、double；
register char ch;
register short int b;
register int c;
register float d; //错误
（5）只有内存中的变量才有地址，故不能用取地址的方式读取register修饰的变量。
register int a;
int* p;
p = &a; //错误，可能a没有地址
2、static：静态
static可以修饰全局变量、局部变量、函数。
3、const：只读变量
不能修改，只能读取。
const int a = 101;//定义了一个只读的变量a，a=101，在定义之后不能再修改了
a = 101;//错误，不能给只读变量赋值
4、auto：自动类型
auto int a 与 int a 等价，不常用。
5、extern：外部函数或外部变量声明
一般用于函数和全局变量的声明，常用在头文件中。
2.1.3 控制语句相关的关键字
1、if
2、else
3、break
4、continue
5、for
6、while
7、do
8、switch.....case.....
9、goto
10、default
2.1.4 其他关键字
1、sizeof
用来测变量、数组、指针等占用存储空间的大小（占用内存的字节数）
int a = 10;
in num;
num = sizeof(a);
测量a在内存中占用的字节数，即int类型占用的字节数
2、typedef
给一个已有的类型名如int、float等重新起个名字，比如把long int叫成abcd，不能创造一个新的类型
定义方式：：typedef + 需要替代的变量名 + 新变量名
例如：typedef unsigned short int U16; //即将unsigned short int 重命名为U16
//使用 INT 代替 short int 作为类型名称定义变量
//short int a;
//short int INT16;
typedef short int INT16;
int main()
{
short int b = 100;
INT16 c = 111;
printf("b = %d\n", b);
printf("c = %d\n", c);
return 0;
}
3、volatile：易改变
即告诉CPU每次用volatile变量时候，重新去内存中读取，以保证是最新的值，而不是寄存器中的备份。CPU读取数据是先把数据从内存中放到寄存器中再去用，再次读取直接在寄存器中读取。较少使用。
注意事项
1、命名要求
字母、数字、下划线，不能以数字开头，必须以字母或者下划线开头
Linux风格： stu num
驼峰风格： StuNum
大小写敏感：int Num; int num; 即大写和小写是两个变量名，Num 不等同于 num；
要求见名知意。
2、C语言的程序结构
一个完整的C语言程序，有且仅有一个main()函数（又称主函数），和其他若干个函数组成。
main()函数是程序的入口。main函数可以传参，也可以不带参。
2.2 数据类型
2.2.1基本类型
1、常量和变量
常量：程序运行过程中，其值不能改变的量称为常量。
变量：其值可以改变的量称为变量。
（1）字符常量和字符变量
字符常量包括直接常量和转义字符。
直接常量：用单引号括起来。如'a','0'
转义字符：反斜杠\开头，后跟一个或几个字符：'\n'制表符，'\t'制表符等
字符变量：用char定义的字符，每个字符变量分配一个字节的内存空间，字符值用ASCII码的形式存放在变量的内存空间中。
char a;
a = 'x';
a变量存放的是字符x的ASCII：120，即a = 120; 和 a = 'x';是一样的
int main()
{
char a = 120;
char b = 'x';
printf("a = %c\n",a);
printf("b = %c\n", b);
return 0;
}
运算结果是：a = x b = x
（2）字符串常量和字符串变量
字符串常量：用双引号括起来的一连串字符，如“CHINA”，“湖南大学”
字符串常量和字符常量有区别：
a、单引号和双引号，‘a’和“a”；
b、每个字符串结尾编译器会自动补一个结束标志位 '\0'，即"a"包含两个字符'a'和'\0'。
（3）整形数据 short、int、long
整形常量（按进制分类）：十进制：以数字1-9开头，如123、145
八进制：以数字0开头，如0123、0152
十六进制：以数字0x开头，如0x1e,0x25 （a=10,b=11,c=12,d=13,e=14,f=15）
整形变量：（un/signed）short (int)、（un/signed）int、（un/signed）long (int)（4）实型数据（浮点型）,float,double
实型常量（实数或浮点数）：十进制形式和指数形式，不以f结尾默认double类型，以f结尾是float类型。
实型变量：单精度（float，占4个字节，7位有效数字），双精度（double，占8字节，16位有效数字）。
2、格式化输出字符
%d 十进制有符号整数
%u 十进制无符号整数
%x 十六进制整数
%o 八进制整数
%f float型浮点数（7位有效数字）
%lf double型浮点数
%e 指数形式的浮点数
%s 字符串
%c 单个字符
%p 指针的值
%3d 要求宽度为3位，如果不足3位则前面用空格补齐，如果足够3位则该条语句无效
%03d 要求宽度为3位，如果不足3位则前面用0补齐，如果足够3位则该条语句无效
%-3d 要求宽度为3位，如果不足3位则后面用空格补齐，如果足够3位则该条语句无效
%.2f 小数点后只保留2位
int main()
{
char a = 'x';
int b = 101;
float c = 3.1415926f;
double d = 1.23;
int e = 0x3d;//61
printf("a = %c\n", a);
printf("b = %d\n", b);
printf("c = %f\n", c);
printf("d = %lf\n", d);
printf("e = %x\n", e);
printf("e = %d\n", e);
return 0;
}
int main()
{
printf("%03d\n", 1);
return 0;
}
2.2.2构造类型
由若干个相同或不同数据构成的集合，这种数据类型称为构造类型，例如：int a[10];数组、结构体、共用体、枚举。
2.2.3 类型转换
不同类型数据之间的转换，有两种转换方法：
1、自动转换
遵循一定的规则，有编译器自行完成：占用内存字节数较少的类型向占用字节数较多的类型转换，以保证精度不降低。
（1）当表达式中出现了char、short int、int类型中的一种或多种，没有其他类型了，参加运算的成员全部变成int参加运算，结果也是int类型
int main()
{
printf("%d\n", 5 / 2);
return 0;
}
运算的结果是2，不是2.5，说明自动转换成了int类型。
（2）当表达式中出现了带小数点的实数，如2.5，参加运算的成员全部变成double类型的参加运算，结果也是double类型。
int main()
{
printf("%lf\n",5.0 / 2);
return 0;
}
运算的结果是2.500000（默认保留6位小数）
（3）当表达式中有有符号数signed，也有无符号数unsigned，且没有浮点数，参加运算的成员都变成无符号数unsigned参加运算，结果也是unsigned无符号数。
int main()
{
signed int a = -8;
unsigned int b = 7;
if (a + b > 0)
{
printf("a + b > 0\n");
}
else if (a + b < 0)
{
printf("a + b < 0\n");
}
else
{
printf("a + b = 0");
}
return 0;
}
运算的结果是a + b > 0；
（4）赋值语句中等号右边的类型自动转换成等号左边的类型。
int main()
{
int a;
float f = 5.8f;
a = f;
printf("a = %d\n", a);
printf("f = %f\n", f);
return 0;
}
运算的结果是a = 5，f = 5.800000,编译器提示：从“float”转换到“int”，可能丢失数据。
（5）自动类型转换时只是临时性的转换，在运算结束后恢复原来的数据类型。
2、强制类型转换：
将表达式的运算结果强制转换成所需要的数据类型，通过类型转换运算来实现
（类型说明符）（表达式）
注意：类型说明符一定要加括号，而表达式如果是字符串需要加括号，是单个字符可不加。
int main()
{
float x;
int i;
x = 3.6f;
i = (int)x;
printf("i = %d\n", i);
printf("x = %f\n", x);
return 0;
}
运算的结果是i = 3，x = 3.600000。说明也是临时性的转换，在运算结束后仍恢复原来的数据类型。
2.3 运算符
2.3.1 运算符
用算术运算符将运算对象（或称操作数）连接起来，符合C语言规则的式子，成为C算术表达式，运算对象包括常量、变量、函数等等
例如 a*b/c-1.5+'a'
2.3.2 运算符的分类（操作数的个数）
1、双目运算符
参加运算的操作数有两个。例如 a+b，两个操作数：a,b，运算符+，则运算符+是双目运算符。
2、单目运算符
参加运算的操作数有一个。如自增运算符++，自减运算符--：a++,b--。
3、三目运算符
参加运算的运算符有三个。如条件运算符：()?():()。
2.3.3 算数运算符
+，-，*，/（取模），%（取余），复合运算符：+=，-=，*=，/=，%=a，复合运算符运算时等号右边的用括号括起来
a +=3 即 a = a + 3;
a *= 1 + 2 即 a = a*(1+2);
int main()
{
int a = 10;
int b = 3;
printf("a / b = %d\n", a / b);
printf("a % b = %d\n", a % b);
a += 3;//a = a + 3;
printf("a = %d\n", a);
b %= 2;//b = b % 2;
printf("b = %d\n", b);
b += 2 * 8;//b = b + (2 * 8)，复合运算符等号右边的用括号括起来
printf("b = %d\n", b);
return 0;
}
运算的结果a / b = 3，a%b = 1，a = 13，b = 1,b = 17。
2.3.4 关系运算符
>，<，==（两个等号判等），>=，<=，!=（判断不等）
一般用于判断条件或者循环语句中。
int main()
{
int a = 1;
int b = 2;
if (a > b)
{
printf("a > b\\n");
}
else if (a < b)
{
printf("a < b\n");
}
else
{
printf("a = b\n");
}
return 0;
}
2.3.5 逻辑运算符
1、&&（逻辑与）
双目运算符，两个条件都为真，则结果为真。
if ((a>b)&&(a<c))，只有a>b和a<c同时满足（即b<a<c)，才进行if下的语句,不存在if(b<a<c)这种语句。
int main()
{
int a = 1;
int b = 2;
int c = 3;
if ((a < b) && (a > c))
{
printf("b>a>c\n");
}
else
{
printf("不满足\n");
}
return 0;
}
2、||（逻辑或）
两个条件至少一个为真，则结果为真，只有都为假，结果才为假。
if ((a>b)||(a<c))，a>b和a<c中只要有一个为真，则执行if下的语句。
3、！（逻辑非）
取反。
if(!(a>b))，如果a>b为真，取反为假，不能执行if后的语句；如果a<b，则取反为真，执行if后的语句。
int main()
{
int a = 1;
int b = 2;
if (!(a > b))
{
printf("a <= b\n");
}
else
{
printf("a > b\n");
}
return 0;
}
运算的结果是 a <= b；
2.3.6 位运算符
1十进制转二进制的方法
除2取余法
2、正数负数的存储方法
正数在内存中以原码的形式存放，负数在内存中以补码形式存放。
正数的原码 = 补码 = 反码
原码：将一个整数转换成二进制，最高位是符号位，正数的符号位为0，负数的符号位为1，就是原码。5的原码是0000 0101，-5的原码是1000 0101。
反码：正数的反码就是其原码，而负数的反码是将原码中除符号位以外的每一位取反。5的反码是0000 0101，-5的反码是1111 1010。
补码：正数的补码就是其原码，而负数的补码是将其反码+1。5的补码是0000 0101，-5的补码是1111 1011。
int main()
{
printf("%x\n", 5);
//5的原码、补码、反码：0000 0000 0000 0000 0000 0000 0000 0101,即5
printf("%x\n", -5);
//-5是整形，占4个字节（4*8 = 32位）
//-5的原码：1000 0000 0000 0000 0000 0000 0000 0101
//-5的补码：1111 1111 1111 1111 1111 1111 1111 1010
//-5的反码：1111 1111 1111 1111 1111 1111 1111 1011
// f f f f f f f b
return 0;
}
运算的结果：5，fffffffb。
注意：无论是正数还是负数，编译系统都是按照其内存中存储的内容进行运算的。
int main()
{
printf("%x\n", -5 & 10);//-5和10按位与
printf("%x\n", -5 | 10);//-5和10按位或
return 0;
//-5
//原码 1000 0000 0000 0000 0000 0000 0000 0101
//反码 1111 1111 1111 1111 1111 1111 1111 1010
//补码 1111 1111 1111 1111 1111 1111 1111 1011‘
//10
//原码 0000 0000 0000 0000 0000 0000 0000 1010
//-5&10，按位与
// 0000 0000 0000 0000 0000 0000 0000 1010 即：a
//-5|10，按位或
// 1111 1111 1111 1111 1111 1111 1111 1011 即：fffffffb
}
3、位运算符，即按位运算
（1）&（按位与），
（2）|（按位或），
（3）~（按位取反，区别于逻辑运算符！取反），
（4）^（按位异或，相异得1，相同得0），
（5）位移：<<左移，>>右移，右移分为逻辑右移和算术右移。
右移>>：逻辑右移：无论有符号数还是无符号数，都是高位补0，低位溢出，例如：0101 1010 >>3（右移3位），得：0000 1011
算术右移：高位都补符号位，低位溢出（有符号数）例如：1010 1101 >>3（右移3位），得：1111 0101
到底是逻辑右移还是算术右移，取决于编译器
int main()
{
printf("%d\n", -1 >> 3);
// 原码 1000 0000 0000 0000 0000 0000 0000 0001
// 反码 1111 1111 1111 1111 1111 1111 1111 1110
// 补码 1111 1111 1111 1111 1111 1111 1111 1111
// >>3
//逻辑右移：0001 1111 1111 1111 1111 1111 1111 1111
//算术右移：1111 1111 1111 1111 1111 1111 1111 1111
return 0;
}
运算的结果是-1，说明VS的右移是算术右移，低位溢出，高位补符号位
左移<<：高位溢出，低位补0，例如：5<<1（0000 0101左移1位），得0000 1010
2.3.7 条件运算符（三目运算符）
()?():()
A?B:C
如果A为真，则整个表达式的值为B
如果A为假，则整个表达式的值为C
int main()
{
int a = 1;
int b = 2;
int c = 3;
printf("%d\n", (a < 3) ? (b + 3) : (c + 2));
return 0;
}
a < 3 为真，则结果是b+3，即5。
2.3.8 逗号运算符
(),()
逗号运算符的结果是,后面的表达式
int main()
{
int num;
num = (5,6);
printf("num = %d", num);
return 0;
}
运算的结果是 num = 6
2.3.9 自增自减运算符
（1）i++ i-- 运算符在变量的后面，则在当前表达式先用i的值，下条语句i的值才改变
int main()
{
int num;
int i = 3;
num = i++;
printf("num = %d,i = %d\n", num, i);
return 0;
}
运算的结果是：num = 3, i = 4，即i++先将i当前的值3赋给num，然后再自增。
（2）++i --i 运算符在变量的后面，则先加，后用
int main()
{
int num;
int i = 3;
num = ++i;
printf("num = %d,i = %d\n", num, i);
return 0;
}
运算的结果是num = 4, i = 4，即++i现将i当前的值3加1变成4，再赋值给num。
（3）一条语句中有多个自增或自减，而不同的编译器的处理方法不同，结果也不相同。
int main()
{
int num1,num2;
int i = 3;
int j = 3;
num1 = (i++)+(i++)+(i++);
num2 = (++j) + (++j) + (++j);
printf("num1 = %d,i = %d\n", num1, i);
printf("num2 = %d,j = %d\n", num2, j);
return 0;
}
运算的结果是num1 = 9,i = 6；num2 = 18, j = 6。
2.3.10 运算符的优先级和结合性
1、运算符优先级
表达式中按照优先级的先后进行计算，优先级高的先于优先级低的运算，同等优先级的按结合性运算
2、运算符结合性
左结合性：从左向右运算，a = 2 + 3 + 5 + 7
右结合性：从右向左运算，a = b = c = d = 100; 赋值运算符是从右向左赋值，100先赋值给d
当表达式比较复杂时应用（）括起来，防止出错
2.4 控制语句
2.4.1选择控制语句
1、if语句
（1）if（条件表达式）{复合语句} 或 if（条件表达式）一条语句
如果条件表达式成立，则执行大括号内的所有语句，如果条件不成立则不执行。
int main()
{
int a = 10;
if (a > 5)
{
printf("a>5\n");
printf("helloworld\n");
}
return 0;
}
运算的结果是a>5，helloworld
注意：如果不加大括号，则如果条件表达式成立，只执行if后的第一条语句，其他语句被认为是if外的语句，不受条件表达式成立与否，都会执行。
int main()
{
int a = 1;
if (a > 5)
printf("a>5\n");
printf("helloworld\n");
return 0;
}
运算的结果是helloworld
（2）if（条件表达式）{……}else{……}
int main()
{
int a = 3;
if (a > 5)
{
printf("a > 5\n");
}
else
{
printf("a <= 5\n");
}
return 0;
}
运算的结果是a <= 5。
注意：在这种模式下如果不加大括号，并且有多条语句，编译会出错，只有在只有一条语句或者一条复合语句时才能正常运行。
（3）if（条件表达式1）{……} else if (条件表达式2){……} else if (条件表达式3){……} else {……}
从上往下判断，一旦有成立的表达式则执行对应的复合语句，完成后执行if模块之后的语句，也就是说即便之后还有成立的条件表达式，也不去执行对应的复合语句了，各个判断条件是互斥的。
//判断学生成绩等次
#include <stdio.h>
int main()
{
float score;
printf("请输入学生的成绩：\n");
scanf_s("%f",&score,5);//从键盘输入一个浮点型的数据，并保存在score中
//在高版本的 Visual Studio 编译器中，scanf 被认为是不安全的，被弃用，应当使用scanf_s代替scanf。
if (score < 0 || score > 100)
{
printf("请输入一个0~100之间的成绩");
}
else if (score < 60)
{
printf("不合格");// score<60 不合格
}
else if (score < 80)
{
printf("合格");// 60<=score<80 合格
}
else if (score < 90)
{
printf("良好");// 80 <= score <90 良好
}
else // 90<= score <100 优秀
{
printf("优秀");
}
return 0;
}
2、switch语句
表达式只能是字符型char或整形的(short int、int、long int),不能是浮点型的
switch（表达式）
{
case 常量表达式1:
语句1;
break;
case 常量表达式2:
语句2;
break;
default: //如果表达式与上面的都不相同，则执行default内的语句
语句3;
break;
}
如果表达式 == 常量表达式1,则执行之后的语句1
//判断输入的数字对应星期几
#include <stdio.h>
int main()
{
int n;
printf("请输入一个1~7之间的数\n");
scanf_s("%d", &n);
switch (n)
{
case 1:
printf("星期一\n");
break;
case 2:
printf("星期二\n");
break;
case 3:
printf("星期三\n");
break;
case 4:
printf("星期四\n");
break;
case 5:
printf("星期五\n");
break;
case 6:
printf("星期六\n");
break;
case 7:
printf("星期日\n");
break;
default:
printf("您输入的数字有误，请输入一个1~7之间的数\n");
break;
}
return 0;
}
注意：case后的语句一定要加break，如果不加break，会继续执行下一个case内的语句，直到break。
int main()
{
int n = 1;
switch (n)
{
case 1:
printf("星期一\n");
case 2:
printf("星期二\n");
case 3:
printf("星期三\n");
case 4:
printf("星期四\n");
default:
printf("请输入一个1~7之间的数\n");
break;
}
return 0;
}
运行的结果是：星期一，星期二，星期三，星期四，请输入一个1~7之间的数。没有break会一直运行，不论条件是否成立，都会从上往下依次执行，直到碰到break。
2.4.2、循环控制语句
1、for循环
for（表达式1；表达式2；表达式3）
{//复合语句（称为循环体）
}
第一次进入循环时首先执行一次表达式1，之后不再执行表达式1了。表达式2是循环的条件，只有表达式2为真，才执行循环体，执行完循环体后首先执行表达式3，再判断表达式2是否成立；如果表达式2不成立，则直接执行表达式3，再判断表达式2是否成立。
//计算1-100的累加和
#include <stdio.h>
int main()
{
int i;
int sum = 0;
for (i = 1; i <= 100; i++)
{
sum = sum + i;
}
printf("1~100的累加和是%d\n", sum);
return 0;
}
运行结果是：1~100的累加和是5050
//输出1~10十个数字
#include <stdio.h>
int main()
{
int i;
for (i = 1; i <= 10; i++)
{
printf("i = %d\n", i);
}
return 0;
}
（1）break和continue在循环中的作用
int main()
{
int i;
for (i = 1; i <= 10; i++)
{
printf("i = %d\n", i);
if (i == 5)
{
break;
}
}
return 0;
}
运行结果是 i = 1，i = 2，i = 3，i = 4，i = 5
只执行到break，break的作用是结束break所在的大循环。
int main()
{
int i;
for (i = 1; i <= 10; i++)
{
if (i == 5)
{
continue;
}
printf("i = %d\n", i);
}
return 0;
}
i = 1，i = 2，i = 3，i = 4，i = 6，i = 7，i = 8，i = 9，i = 10
continue的作用是结束本次循环，进入到下一次循环。
（2）循环嵌套
#include <stdio.h>
int main()
{
int i, j;
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
{
printf("i = %d,j = %d;", i, j);
}
}
return 0;
}
运行的结果是：i = 0, j = 0; i = 0, j = 1; i = 0, j = 2; i = 0, j = 3; i = 1, j = 0; i = 1, j = 1; i = 1, j = 2; i = 1, j = 3; i = 2, j = 0; i = 2, j = 1; i = 2, j = 2; i = 2, j = 3; i = 3, j = 0; i = 3, j = 1; i = 3, j = 2; i = 3, j = 3;
i = 0 时,j 循环一套，也就是从0自增到3，循环结束后，i自增1（i=1），j再循环一套……以此类推。
//输出九九乘法口诀表
#include <stdio.h>
int main()
{
int i, j;
for (i = 1; i <= 9; i++)
{
for (j = 1; j <= i; j++)
{
printf("%d * %d = %d ", j, i, i * j);
}
printf("\n");
}
return 0;
}
2、while循环
（1）形式1：先判断，再循环体
while（条件表达式）
{//复合语句（循环体）
}
如果没有大括号，认为while后只跟一条语句。
当条件表达式为真，则执行循环体，执行完后再次判断条件表达式是否成立，直到为假，则跳出循环，执行之后的语句。
//计算1-100的累加和
# include<stdio.h>
int main()
{
int i = 1;
int sum = 0;
while (i <= 100)
{
sum += i;
i++;
}
printf("1~100的累加和是：%d\n", sum);
return 0;
}
（2）do while循环：先执行循环体，再判断
do{//循环体;
}while（条件表达式）;
先执行循环体，再判断条件表达式是否成立，如果成立，则再次执行循环体，然后判断条件表达式是否成立，循环直到为假
//计算1-100的累加和
#include<stdio.h>
int main()
{
int i = 1;
int sum = 0;
do {
sum += i;
} while (i <= 100);
printf("1-100的累加和是：%d\n", sum);
return 0;
}
3、goto语句
使用标签进行跳转
#include <stdio.h>
int main()
{
printf("1,");
goto _2;
_1:
printf("2,");
printf("3,");
printf("4,");
printf("5,");
return 0;
_2:
printf("6,");
printf("7,");
printf("8,");
goto _1;
}
运行结果：1, 6, 7, 8, 2, 3, 4, 5,
扫一扫
830
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
