一 、C语言学习第一天

1.1 编写C语言代码：hello.c

#include<stdio.h>
#include<stdlib.h>  //调用system系统函数需要包含的头文件

int main()
{
   
	printf("hello world\n");
	system("pause");
	return 0;
}

解决在运行程序的时候，黑窗口一闪而过的方法

1、通过system()函数解决，在return 0之前，添加system(“pause”);函数调用

2、借助VS工具解决：在项目上 —》右键 —》 属性 —》 配置属性 —》 链接器 —》 系统 —》 子系统 —》 在下拉框中选择“控制台 (/SUBSYSTEM:CONSOLE)”

1.2 编写helloworld程序的两种方式

1、借助VS编辑工具编写：创建项目 --》 创建 helloworld.c 源文件 --》 写 helloworld程序 --》Ctrl + F5 执行

2、借助笔记本、gcc编译工具编写

• 在记事本中写 helloworld 程序
• 使用记事本创建 helloworld.c 文件
• 使用gcc编译工具 ，在记事本写的 helloworld.c 所在目录中，执行 gcc helloworld.c -o myhello.exe
• 在终端（黑窗口）中，运行 ： myhello.exe

gcc 、g++编译常用选项说明

#include< > 与 #include " "的区别：

• < > 表示系统直接按系统指定的目录检索
• " " 表示系统先在 " " 指定的路径(没写路径代表当前路径)查找头文件，如果找不到，再按系统指定的目录检索

1.3 system函数

作用：执行系统命令，如： pause、cmd、calc、mspaint、notepad…

代码示例：

#include <stdio.h>
#include <stdlib.h>

int main()
{
   
	//system("calc"); //windows平台
	system("ls"); //Linux平台, 需要头文件#include <stdlib.h>

	return 0;
}

1.4 gcc编译的四个步骤【重点】

1、预处理的命令格式：gcc -E xxx.c -o xxx.i

预处理所完成的事情：

• 头文件展开，不检查语法错误，可以展开任意文件
• 宏定义替换，将宏名替换为宏值
• 替换注释，将注释变成空行
• 展开条件编译，根据条件来展开指令

2、编译的命令格式：gcc -S hello.i -o hello.s

编译所完成的事情：

• 逐行检查语法错误【重点】，整个编译4步骤中最耗时的过程
• 将C程序翻译成汇编指令，得到 .s汇编文件

3、汇编的命令格式：gcc -c hello.s -o hello.o

汇编所完成的事情：

• 翻译：将汇编指令翻译成对应的二进制代码

4、链接的命令格式：gcc hello.o -o hello.exe

链接所完成的事情：

• 数据段合并
• 数据地址回填
• 库引入

1.5 程序的调试

1、设置断点，F5启动调试

2、停止的位置，是尚未执行的指令

3、逐语句执行下一条(F11)：进入函数内部，逐条执行跟踪

4、逐过程执行下一条(F10)：不进入函数内部，逐条执行程序

5、添加监视：调试–》窗口–》监视：输入监视的变量名，自动监视变量值的变化

为程序添加行号的方法：

工具–》选项–》文本编辑器–》C/C+±-》行号 ，选中即可

1.6 VS2013的C4996错误

错误原因：由于微软在VS2013中不建议再使用C的传统库函数scanf,strcpy,sprintf等，所以直接使用这些库函数会提示C4996错误

解决办法：如果想要继续使用此函数，需要在源文件中添加一下指令就可以避免这个错误的提示

#define _CRT_SECURE_NO_WARNINGS     //这个宏定义最好要放到.c文件的第一行
#pragma warning(disable:4996)	//或者使用这个

二、C语言学习第二天（数据类型）

2.1 常量与变量

2.1.1 关键字

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 , contiune , goto , return

存储类关键字(5个)：auto，extern , register , static , const

其他关键字(3个)：sizeof , typedef , volatile

2.1.2 数据类型

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

2.1.3 常量

特点：

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

示例：

1. “hello”、'A'、-10、3.1415926（浮点常量）	

2. #define PI 3.1415	【强调】：没有分号结束标记。 【推荐】 定义宏： 定义语法： #define 宏名 宏值

3. const int a = 10;	定义语法：const 类型名 变量名 = 变量值。

		const关键字： 被该关键字修饰的变量，表示为只读变量。

2.1.4 变量

特点：

• 在程序运行过程中，其值可以改变
• 变量在使用前必须先定义，定义变量前必须有相应的数据类型
• 变量在编译时为其分配相应的内存空间
• 可以通过其名字和地址访问相应内存

标识符的命名规则：

1、标识符不能是关键字

2、标识符只能由字母、数字、下划线组成

3、第一个字符必须为字母或者下划线

4、标识符中字母区分大小写

声明和定义的区别

• 声明变量不需要建立存储空间，如：external int a;
• 定义变量需要建立存储空间，如：int b;

示例：

#include <stdio.h>

int main()
{
   
	//extern 关键字只做声明，不能做任何定义
	//声明一个变量a，a在这里没有建立存储空间
	extern int a;
	a = 10;	//error, 没有空间，就不可以赋值

	int b = 10;	//定义一个变量b，b的类型为int，b赋值为10

	return 0;
}

代码示例：

#include <stdio.h>
#define MAX 10 //声明了一个常量，名字叫MAX，值是10，常量的值一旦初始化不可改

int main()
{
   
	int a;	//定义了一个变量，其类型为int，名字叫a

	const int b = 10; //定义一个const常量，名为叫b，值为10
	//b = 11; //err,常量的值不能改变

	//MAX = 100;	//err,常量的值不能改变

	a = MAX;//将abc的值设置为MAX的值
	a = 123;

	printf("%d\n", a); //打印变量a的值

	return 0;
}

2.2 整形

2.2.1 整形变量的定义和输出

代码示例：

#include <stdio.h>

int main()
{
   
	int a = 123;	//定义变量a，以10进制方式赋值为123
	int b = 0567;	//定义变量b，以8进制方式赋值为0567
	int c = 0xabc;	//定义变量c，以16进制方式赋值为0xabc

	printf("a = %d\n", a);
	printf("8进制：b = %o\n", b);
	printf("10进制：b = %d\n", b);
	printf("16进制：c = %x\n", c);
	printf("16进制：c = %X\n", c);
	printf("10进制：c = %d\n", c);

	unsigned int d = 0xffffffff; //定义无符号int变量d，以16进制方式赋值
	printf("有符号方式打印：d = %d\n", d);
	printf("无符号方式打印：d = %u\n", d);
	return 0;
}

输出结果：

a = 123
8进制：b = 567
10进制：b = 375
16进制：c = abc
16进制：c = ABC
10进制：c = 2748
有符号方式打印：d = -1
无符号方式打印：d = 4294967295
请按任意键继续. . .

2.2.2 整形变量的输入

代码示例：

#include <stdio.h>

int main()
{
   
	int a;
	printf("请输入a的值：");

	//不要加“\n”
	scanf("%d", &a);

	printf("a = %d\n", a); //打印a的值

	return 0;
}

输出结果：

请输入a的值：10
a = 10
请按任意键继续. . .

2.2.3 short 、 int 、 long 、 long long类型

类型所占内存大小:

打印输出格式：

代码示例：

#include <stdio.h>

int main()
{
   
	short a = 10;
	int b = 10;
	long c = 10l; //或者10L
	long long d = 10ll; //或者10LL

	printf("sizeof(a) = %u\n", sizeof(a));
	printf("sizeof(b) = %u\n", sizeof(b));
	printf("sizeof(c) = %u\n", sizeof(c));
	printf("sizeof(c) = %u\n", sizeof(d));

	printf("short a = %hd\n", a);
	printf("int b = %d\n", b);
	printf("long c = %ld\n", c);
	printf("long long d = %lld\n", d);

	unsigned short a2 = 20u;
	unsigned int b2 = 20u;
	unsigned long c2= 20ul; 
	unsigned long long d2 = 20ull; 

	printf("unsigned short a = %hu\n", a2);
	printf("unsigned int b = %u\n", b2);
	printf("unsigned long c = %lu\n", c2);
	printf("unsigned long long d = %llu\n", d2);

	return 0;
}

输出结果：

sizeof(a) = 2
sizeof(b) = 4
sizeof(c) = 4
sizeof(c) = 8
short a = 10
int b = 10
long c = 10
long long d = 10
unsigned short a = 20
unsigned int b = 20
unsigned long c = 20
unsigned long long d = 20
请按任意键继续. . .

2.2.4 有符号数和无符号数的区别

• 有符号数最高位为符号为，0代表整数，1代表负数

代码示例：

#include <stdio.h>

int main()
{
   
	signed int a = -1089474374; //定义有符号整型变量a
	printf("%X\n", a); //结果为 BF0FF0BA

	//B       F      0        F       F     0        B	      A
	//1011 1111 0000 1111 1111 0000 1011 1010

	return 0;
}

• 无符号数最高位不是符号位，而是数的一部分，无符号数不可能是负数

代码示例：

#include <stdio.h>

int main()
{
   
	unsigned int a = 3236958022; //定义无符号整型变量a
	printf("%X\n", a); //结果为 C0F00F46

	return 0;
}

2.3 sizeof关键字

1、sizeof不是函数，所以不需要包含任何头文件，它的功能是计算一个数据类型的大小，单位为字节

2、sizeof的返回值为size_t

3、size_t类型在32位操作系统下式unsigned int,是一个无符号整数

代码示例:

#include <stdio.h>

int main()
{
   
	int a;
	int b = sizeof(a);//sizeof得到指定值占用内存的大小，单位：字节
	printf("b = %d\n", b);

	size_t c = sizeof(a);
	printf("c = %u\n", c);//用无符号数的方式输出c的值

	return 0;
}

输出结果：

b = 4
c = 4
请按任意键继续. . .

2.4 字符型

2.4.1 字符变量的定义和输出

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

代码示例：

#include <stdio.h>

int main()
{
   
	char ch = 'a';
	printf("sizeof(ch) = %u\n", sizeof(ch));

	printf("ch[%%c] = %c\n", ch); //打印字符
	printf("ch[%%d] = %d\n", ch); //打印‘a’ ASCII的值

	char A = 'A';
	char a = 'a';
	printf("a = %d\n", a);		//97
	printf("A = %d\n", A);	//65

	printf("A = %c\n", 'a' - 32); //小写a转大写A
	printf("a = %c\n", 'A' + 32); //大写A转小写a

	ch = ' ';
	printf("空字符：%d\n", ch); //空字符ASCII的值为32
	printf("A = %c\n", 'a' - ' '); //小写a转大写A
	printf("a = %c\n", 'A' + ' '); //大写A转小写a

	return 0;
}

输出结果：

sizeof(ch) = 1
ch[%c] = a
ch[%d] = 97
a = 97
A = 65
A = A
a = a
空字符：32
A = A
a = a
请按任意键继续. . .

2.4.2 字符变量的输入

代码示例：

#include <stdio.h>

int main()
{
   
	char ch;
	printf("请输入ch的值：");

	//不要加“\n”
	scanf("%c", &ch);
	printf("ch = %c\n", ch); //打印ch的字符

	return 0;
}

输出结果：

请输入ch的值：A
ch = A
请按任意键继续. . .

ASCLL码大致由一下两部分组成：

• ASCLL非打印控制字符：ASCII 表上的数字 0-31 分配给了控制字符，用于控制像打印机等一些外围设备
• ASCII 打印字符：数字 32-126 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。数字 127 代表 Del 命令

2.4.3 转义字符

注意：黄色字体标注的为不可打印字符

代码示例：

#include <stdio.h>

int main()
{
   
	printf("abc");
	printf("\refg\n"); //\r切换到句首， \n为换行键

	printf("abc");
	printf("\befg\n");//\b为退格键， \n为换行键

	printf("%d\n", '\123');// '\123'为8进制转义字符，0123对应10进制数为83
	printf("%d\n", '\x23');// '\x23'为16进制转义字符，0x23对应10进制数为35

	return 0;
}

输出结果：

efg
abefg
83
35
请按任意键继续. . .

2.5 实型（浮点型）：float、 double

实型变量也可以称为浮点型变量，浮点型变量是用来存储小数数值的。在C语言中， 浮点型变量分为两种： 单精度浮点数(float)、 双精度浮点数(double)， 但是double型变量所表示的浮点数比 float 型变量更精确。由于浮点型变量是由有限的存储单元组成的，因此只能提供有限的有效数字。在有效位以外的数字将被舍去，这样可能会产生一些误差。不以f结尾的常量是double类型，以f结尾的常量(如3.14f)是float类型。

代码示例：

#include <stdio.h>

int main()
{
   
	//传统方式赋值
	float a = 3.14f; //或3.14F
	double b = 3.14;

	printf("a = %f\n", a);
	printf("b = %lf\n", b);

	//科学法赋值
	a = 3.2e3f; //3.2*1000 = 3200，e可以写E
	printf("a1 = %f\n", a);

	a = 100e-3f; //100*0.001 = 0.1
	printf("a2 = %f\n", a);

	a = 3.1415926f;
	printf("a3 = %f\n", a); //结果为3.141593

	return 0;
}

输出结果：

a = 3.140000
b = 3.140000
a1 = 3200.000000
a2 = 0.100000
a3 = 3.141593
请按任意键继续. . .

2.6 进制

2.6.1 二进制

二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”，借位规则是“借一当二”。当前的计算机系统使用的基本上是二进制系统，数据在计算机中主要是以补码的形式存储的。

十进制转化二进制的方法：

用十进制数除以2，分别取余数和商数，商数为0的时候，将余数倒着数就是转化后的结果

十进制的小数转换成二进制

十进制的小数转换成二进制：小数部分和2相乘，取整数，不足1取0，每次相乘都是小数部分，顺序看取整后的数就是转化后的结果

2.6.2 八进制

八进制，Octal，缩写OCT或O，一种以8为基数的计数法，采用0，1，2，3，4，5，6，7八个数字，逢八进1。一些编程语言中常常以数字0开始表明该数字是八进制。八进制的数和二进制数可以按位对应（八进制一位对应二进制三位），因此常应用在计算机语言中。

十进制转换八进制的方法

用十进制数除以8，分别取余数和商数，商数为0的时候，将余数倒着数就是转化后的结果

2.6.3 十六机制

十六进制（英文名称：Hexadecimal），同我们日常生活中的表示法不一样，它由0-9，A-F组成，字母不区分大小写。与10进制的对应关系是：0-9对应0-9，A-F对应10-15。十六进制的数和二进制数可以按位对应（十六进制一位对应二进制四位），因此常应用在计算机语言中。

十进制转化十六进制的方法

用十进制数除以16，分别取余数和商数，商数为0的时候，将余数倒着数就是转化后的结果

2.6.4 C语言如何表示相应进制数

代码示例：

#include <stdio.h>

int main()
{
   
	int a = 123;		//十进制方式赋值
	int b = 0123;		//八进制方式赋值， 以数字0开头
	int c = 0xABC;	//十六进制方式赋值

	//如果在printf中输出一个十进制数那么用%d，八进制用%o，十六进制是%x
	printf("十进制：%d\n",a );
	printf("八进制：%o\n", b);	//%o,为字母o,不是数字
	printf("十六进制：%x\n", c);

	return 0;
}

输出结果：

十进制：123
八进制：123
十六进制：abc
请按任意键继续. . .

2.7 计算机内存数值的存储方式

2.7.1 原码

一个数的原码(原始的二进制码)有以下特点：

1、最高位做为符号位，0表示正,为1表示负

2、其它数值部分就是数值本身绝对值的二进制数

3、负数的原码是在其绝对值的基础上，最高位变为1

说明：原码表示法简单易懂，与带符号数本身转换方便，只要符号还原即可，但当两个正数相减或不同符号数相加时，必须比较两个数哪个绝对值大，才能决定谁减谁，才能确定结果是正还是负，所以原码不便于加减运算。

2.7.2 反码

反码的特点：

1、对于正数，反码与原码相同

2、对于负数，符号位不变，其它部分取反(1变0,0变1)

说明：反码运算也不方便，通常用来作为求补码的中间过渡

2.7.3 补码

在计算机系统中，数字一律用补码来存储

补码的特点：

1、对于正数，原码、反码、补码相同

2、对于负数，其补码为它的反码加1

3、补码符号为不动，其他位取反，最后整个数加1，得到原码

代码示例：

#include <stdio.h>

ints main()
{
   
	int  a = -15;

	printf("%x\n", a);
	//结果为 fffffff1
	//fffffff1对应的二进制：1111 1111 1111 1111 1111 1111 1111 0001
	//符号位不变，其它取反：1000 0000 0000 0000 0000 0000 0000 1110
	//上面加1：1000 0000 0000 0000 0000 0000 0000 1111  最高位1代表负数，就是-15

	return 0;
}

2.7.4 补码的意义

示例1：用8位二进制数分别表示+0和-0

说明：不管以原码方式存储，还是以反码方式存储，0也有两种表示形式。为什么同样一个0有两种不同的表示方法呢？

但是如果以补码的方式存储，补码统一了零的编码：

示例2：计算9-6的结果

以原码的方式相加：

结果为-15，不正确

以补码方式相加：

最高位的1溢出，剩余8位二进制表示的是3，结果正确

在计算机系统中，数值一律使用补码来存储，主要原因是：

1、统一了零的编码

2、将符号位和其他位统一处理

3、将减法运算转变为加法运算

4、两个用补码表示的数相加时，如果最高位（有符号）有进位，则进位被舍弃

2.7.5 数值溢出

当超过一个数据类型能够存放最大的范围时，数值会溢出

有符号位最高位溢出的区别：符号位溢出会导致数的正负发生改变，但最高位的溢出会导致最高位丢失

代码示例：

#include <stdio.h>

int main()
{
   
	char ch;

	//符号位溢出会导致数的正负发生改变
	ch = 0x7f + 2; //127+2
	printf("%d\n", ch);
	//	0111 1111
	//+2后 1000 0001，这是负数补码，其原码为 1111 1111，结果为-127

	//最高位的溢出会导致最高位丢失
	unsigned char ch2;
	ch2 = 0xff + 1; //255+1
	printf("%u\n", ch2);
	//	  1111 1111
	//+1后 10000 0000， char只有8位最高位的溢出，结果为0000 0000，十进制为0

	ch2 = 0xff + 2; //255+1
	printf("%u\n", ch2);
	//	  1111 1111
	//+1后 10000 0001， char只有8位最高位的溢出，结果为0000 0001，十进制为1

	return 0;
}

输出结果：

-127
0
1
请按任意键继续. . .

2.8 类型限定符

2.9 字符串格式化输出和输入

2.9.1 字符串常量

1、字符串是内存中一段连续的char空间，以’\0’(数字0)结尾

2、字符串常量是由双引号括起来的字符序列，如“china”、“C program”，“$12.5”等都是合法的字符串常量

字符常量与字符串常量的不同

每个字符串的结尾，编译器会自动的添加一个结束标志位’\0’，即 “a” 包含两个字符’a’和’\0’

2.9.2 printf函数和putchar函数

printf是输出一个字符串，putchar输出一个char

printf格式字符：

printf附加格式：

代码示例：

#include <stdio.h>
int main()
{
   
	int a = 100;
	printf("a = %d\n", a);//格式化输出一个字符串
	printf("%p\n", &a);//输出变量a在内存中的地址编号
	printf("%%d\n");

	char c = 'a';
	putchar(c);//putchar只有一个参数，就是要输出的char
	long a2 = 100;
	printf("%ld, %lx, %lo\n", a2, a2, a2);

	long long a3 = 1000;
	printf("%lld, %llx, %llo\n", a3, a3, a3);

	int abc = 10;
	printf("abc = '%6d'\n", abc);
	printf("abc = '%-6d'\n", abc);
	printf("abc = '%06d'\n", abc);
	printf("abc = '%-06d'\n", abc);

	double d = 12.3;
	printf("d = \' %-10.3lf \'\n", d);

	return 0;
}

输出结果：

a = 100
0046F834
%d
a100, 64, 144
1000, 3e8, 1750
abc = '    10'
abc = '10    '
abc = '000010'
abc = '10    '
d = ' 12.300     '
请按任意键继续. . .

2.9.3 scanf函数与getchar函数

1、getchar是从标准输入设备读取的一个char

2、scanf通过%d转义的方式可以得到用户通过标准输入设备输入的数据

代码示例：

#include <stdio.h>

int main()
{
   
	char ch1;
	char ch2;
	char ch3;
	int a;
	int b;

	printf("请输入ch1的字符：");
	ch1 = getchar();
	printf("ch1 = %c\n", ch1);

	getchar(); //测试此处getchar()的作用

	printf("请输入ch2的字符：");
	ch2 = getchar();
	printf("\'ch2 = %ctest\'\n", ch2);

	getchar(); //测试此处getchar()的作用
	printf("请输入ch3的字符：");
	scanf("%c", &ch3);//这里第二个参数一定是变量的地址，而不是变量名
	printf("ch3 = %c\n", ch3);

	printf("请输入a的值：");
	scanf("%d", &a);
	printf("a = %d\n", a);

	printf("请输入b的值：");
	scanf("%d", &b);
	printf("b = %d\n", b);

	return 0;
}

输出结果：

请输入ch1的字符：a
ch1 = a
请输入ch2的字符：b
'ch2 = btest'
请输入ch3的字符：c
ch3 = c
请输入a的值：10
a = 10
请输入b的值：12
b = 12
请按任意键继续. . .

三、C语言学习第三天运算符与表达式

3.1 常用运算符分类

3.2 算术运算符

3.3 赋值运算符

3.4 比较运算符

C语言中的比较运算符，“真”用数字“1”表示，“假”用数字“0”表示

3.5 逻辑运算符

3.6 运算符优先级

3.7 类型转换

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

转换的方法有两种：

1、自动转换(隐式转换)：遵循一定的规则,由编译系统自动完成

2、强制类型转换：把表达式的运算结果强制转换成所需的数据类型

类型转换原则：

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

3.7.1 隐式类型转换

代码示例：

#include <stdio.h>

int main()
{
   
	int num = 5;
	printf("s1=%d\n", num / 2);
	printf("s2=%lf\n", num / 2.0);

	return 0;
}

输出结果：

s1=2
s2=2.500000
请按任意键继续. . .

3.7.2 强制类型转换

说明：强制类型转换指的是使用强制类型转换运算符，将一个变量或表达式转化成所需的类型，其基本语法格式如下所示：(类型说明符) (表达式)

代码示例：

#include <stdio.h>

int main()
{
   
	float x = 0;
	int i = 0;
	x = 3.6f;

	i = x;			//x为实型, i为整型，直接赋值会有警告
	i = (int)x;		//使用强制类型转换

	printf("x=%f, i=%d\n", x, i);

	return 0;
}

输出结果：

x=3.600000, i=3
请按任意键继续. . .

四、C语言学习第四天-程序流程结构

4.1 概述

C语言支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构

1、顺序结构：程序按顺序执行，不发生跳转

2、选择结构：依据是否满足条件，有选择的执行相应的功能

3、循环结构：依据条件是否满足，循环多次执行某段代码

4.2 选择结构

4.2.1 if语句

代码示例：

#include <stdio.h>

int main()
{
   
	int a = 1;
	int b = 2;

	if (a > b)
	{
   
		printf("%d\n", a);
	}

	return 0;
} 

4.2.2 if…else语句

代码示例：

#include <stdio.h>
int main()
{
   
	int a = 1;
	int b = 2;

	if (a > b)
	{
   
		printf("%d\n", a);
	}
	else
	{
   
		printf("%d\n", b);
	}
	return 0;
}

4.2.3 if…else if …else

代码示例：

#include <stdio.h>

int main()
{
   
	unsigned int a;
	scanf("%u", &a);

	if (a < 10)
	{
   
		printf("个位\n");
	}
	else if (a < 100)
	{
   
		printf("十位\n");
	}
	else if (a < 1000)
	{
   
		printf("百位\n");
	}
	else
	{
   
		printf("很大\n");
	}

	return 0;
}

4.2.4 三目运算符

#include <stdio.h>

int main()
{
   
	int a = 10;
	int b = 20;
	int c;

	if (a > b)
	{
   
		c = a;
	}
	else
	{
   
		c = b;
	}
	printf("c1 = %d\n", c);

	a = 1;
	b = 2;
	c = ( a > b ? a : b );
	printf("c2 = %d\n", c);

	return 0;
}

4.2.5 switch语句

#include <stdio.h>

int main()
{
   
	char c;
	c = getchar();

	switch (c) //参数只能是整型变量
	{
   
	case '1':
		printf("OK\n");
		break;//switch遇到break就中断了
	case '2':
		printf("not OK\n");
		break;
	default://如果上面的条件都不满足，那么执行default
		printf("are u ok?\n");
	}
	return 0;
}

4.3 循环结构

4.3.1 while语句

代码示例：

#include <stdio.h>

int main()
{
   
	int a = 20;
	while (a > 10)
	{
   
		scanf("%d", &a);
		printf("a = %d\n", a);
	}

	return 0;
}

4.3.2 do…while语句

代码示例：

#include <stdio.h>

int main()
{
   
	int a = 1;
	do
	{
   
		a++;
		printf("a = %d\n", a);
	} while (a < 10);

	return 0;
}

4.3.3 for语句

代码示例：

#include <stdio.h>

int main()
{
   
	int i;
	int sum = 0;
	for (i = 0; i <= 100; i++)
	{
   
		sum += i;

	}

	printf("sum = %d\n", sum);

	return 0;
}

输出结果：

sum = 5050
请按任意键继续. . .

4.3.4 嵌套循环

循环语句之间可以相互嵌套

代码示例：

#include <stdio.h>

int main()
{
   
	int num = 0;
	int i, j, k;
	for (i = 0; i < 10; i++)
	{
   
		for (j = 0; j < 10; j++)
		{
   
			for (k = 0; k < 10; k++)
			{
   
				printf("hello world\n");
				num++;
			}
		}
	}

	printf("num = %d\n", num);

	return 0;
}

4.4 跳转语句break 、 continue 、 goto

4.4.1 break语句

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

1、当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构

2、当它出现在循环语句中，作用是跳出当前内循环语句，执行后面的代码

3、当它出现在嵌套循环语句中，跳出最近的内循环语句，执行后面的代码

代码示例：

#include <stdio.h>

int main()
{
   
	int i = 0;
	while (1)
	{
   
		i++;
		printf("i = %d\n", i);

		if (i == 10)
		{
   
			break; //跳出while循环
		}
	}

	int flag = 0;
	int m = 0;
	int n = 0;

	for (m = 0; m < 10; m++)
	{
   
		for (n = 0; n < 10; n++)
		{
   
			if (n == 5)
			{
   
				flag = 1;
				break; //跳出for (n = 0; n < 10; n++)
			}
		}

		if (flag == 1)
		{
   
			break; //跳出for (m = 0; m < 10; m++)
		}
	}

	return 0;
}

4.3.2 continue语句

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

代码示例：

#include<stdio.h>

int main()
{
   
	int sum = 0;           //定义变量sum

	for (int i = 1; i <= 100; i++)
	{
   
		if (i % 2 == 0)   //如果i是一个偶数，执行if语句中的代码
		{
   
			continue;      //结束本次循环
		}
		sum += i;          //实现sum和i的累加
	}

	printf("sum = %d\n", sum);

	return 0;
}

4.3.3 goto语句(无条件跳转，尽量少用)

代码示例：

#include <st