[C++知识库]C语言入门篇

C语言入门篇

1. C程序的构成

1.1 头文件

? 在C语言中，头文件被大量的使用。头文件就像程序的大脑一样，里面记录了大量用户不需要的函数库。一般而言，每个C/C++程序通常都由头文件和定义文件组成。头文件作为一种包含功能函数、数据接口声明的载体，主要用于保存程序的声明，而定义文件用于保存程序的实现，.c就是你所编写的程序文件。

? 一般在一个应用开发体系中功能的真正逻辑实现是以硬件层为基础，在驱动程序、功能层程序以及用户的应用程序中完成的。头文件的主要作用在于多个代码文件全局变量的重用、防止定义的冲突。对各个被调用函数给出一个描述，其本身不需要包含程序的逻辑实现代码，它只起到描述性作用，用户程序只需要按照头文件中的接口声明来调用相关函数和变量，链接器就会从库中寻找相应的实际定义代码。

? C/C++的头文件以".h"为扩展名。

1.2 主函数

注意：C程序的设计原则设计把函数作为程序的构成模块，main()函数一般被称为主函数，一个C程序总是从main()函数开始执行的。

1.2.1 main()函数的形式

在C99的标准中，只有以下两种定义方式设计正确的：

int main(void)    /*无参数形式*/
{
    ...
    return 0;
}

int main(int argc, char *argv[])   /*带参数形式*/
{
    ...
    return 0;
}

int指明了main()函数的返回类型，传输给函数的信息一般被包含在函数名的后面的括号中，void表示没有给函数传递参数。

1.2.2 main()函数的返回值

main()函数的返回值类型是整数，而程序最后的return 0；说明0就是函数的返回值。那么这个0表示返回哪里呢？返回操作系统，表示程序正常退出。return语句常常写在程序的最后面，也就是说，只要程序最后执行了这个return语句，那么这个程序就结束了。所以，return语句的作用不只是返回一个值，还有结束函数。

1.3 其他组成部分

以下面这段代码为例：

#include<stdio.h>
#define _CRT_SECURE_NO_WARNINGS
#define PI 3.1415926  //定义常量

float area(float r);  // 声明计算面积饿函数
float perimeter(float r); //声明计算周长的函数

void main(void) {
    float r;  // 定义变量r来保存圆的半径
    float s, l;  // 定义变量来保存圆的面积和周长

    printf("请输入圆的半径：");  // 显示提示信息
    scanf_s("%f",&r);  // 接收用户输入的半径

    s = area(r);  //调用area()函数计算面积
    l = perimeter(r);  //调用perimeter()函数计算周长

    printf("半径R=%.2f, 面积S=%.2f \n", r, s); //输出圆的面积
    printf("半径R=%.2f, 周长L=%.2f \n", r, l); //输出圆的周长
}
/*函数area()计算圆的面积*/
float area(float r) {
    float s;

    s = PI * r * r;  // 计算圆的面积
    return s;    // 返回圆的面积
}
/*函数perimeter()计算圆的周长*/
float perimeter(float r) {
    float l;

    l = 2 * PI * r;   // 计算圆的周长
    return l;      // 返回圆的周长
}

1.定义常量

? 使用#define定义一个符号为PI，值为3.1415926。当程序被编译时，程序后面的PI都会被替换成3.1415926。

? 使用符号常量的好处就在于其名称可以给程序员起到提示作用，另一个好处就是方便修改，如果需要修改圆周率的精度，只需要修改符号常量的定义语句即可。若不使用符号常量，若修改则需要修改所有的PI变量的值

2.声明函数原型

? 在C语言中，函数声明称为函数原型。它的主要作用就是利用它在程序的编译阶段对调用函数的合法性进行全面的检查。

? 如果函数调用前没有对函数做出声明，则编译系统会把第一次遇到的该函数的形式（函数定义或者函数调用）作为函数的声明，并将函数的类型默认为整型。使用这种方法时，系统无法对参数的类型进行检查，或者调用函数时参数使用不当，在编译时也不会报错。因此，为了程序的清晰和安全，建议对函数做出声明。

3.程序语句

? C程序是由多条语句构成的，不同的语句完成不同的功能。在C程序中，一般一条语句占用一行，语句以分号结束。C程序一般使用以下语句。

（1）变量定义

? 程序对半径、面积、周长的变量的定义为变量定义语句。在C语言中，在使用变量之前必须先进行定义。编译器遇到变量定义语句时，按变量类型为其分配内存空间。

（2）输出语句

? 程序使用printf()库函数向屏幕上输出信息。

（3）输入语句

? scanf()库函数用于从键盘接收用户的输入，并将结果保存到指定的变量中

（4）运算语句

? 调用面积函数和周长函数，函数中计算面积与周长的语句。

（5）返回语句

? 调用面积函数和周长函数，最后return返回面积和周长的语句。

1.4 函数定义

? C语言中的函数相当于BASIC中的子程序、Pascal中的过程。通过函数将相关功能进行封装，调用函数时不必了解函数的实现细节。在ANSI C中有数量众多的库函数，这些函数都是程序中常用的功能，如上面代码中的scanf()和printf()两个库函数。

? 在更多的情况下用户需要编写自己的函数，以此来完成更多的特定功能。函数定义包括两个部分：函数头和函数体。函数头定义函数的名称、参数和函数返回值的类型；而函数体则定义函数具体完成的工作。

? 在上面代码中的main()、area()和perimeter()三个函数。从函数头定义中可以看出main()函数无参数、无返回值；area()和perimeter()函数需要一个float类型的参数，并返回一个float类型的返回值。

1.5 注释

? 为程序添加注释是一个非常好的编程习惯。C语言编译器将忽略所有的注释内容，因为注释不是写给编译器的，而是写给程序员阅读的。当一个程序比较简单时，注释显得有点多余，但是随着程序的变大、参与开发的人员变多，在程序中通过注释说明该程序的逻辑和结构，可以使代码的可读性大大的提高。

/* */ 为块注释，注释一段代码块

// 行注释 ，注释一行的代码

1.6 拓展训练

1.6.1 打印字母C

#include<stdio.h>
void main(void) {
	printf("*****\n");
	printf("*\n");
	printf("*\n");
	printf("*****\n");
}

1.6.2 scanf()函数的应用

#include<stdio.h>
void main(void) {
	int a;
	scanf_s("%d", &a);
	printf("The number is %d \n", a);
}

在VS中直接调用scanf()函数会报错，因此可以在头文件中加入#define _CRT_SECURE_NO_WARNINGS，或者是应用如上的scanf_s()来解决问题。

1.7 C语言的一些基础规范

1.7.1 规范命名

在C语言中，一般被命名的名字都被称作标识符。标识符是指一个字符组成的序列，通常包括变量名、常量名、函数名、程序名等。这些命名都必须符合C语言的规范，否则程序运行时会出现错误。

命名是必须符合以下C语言的规范：

• C语言中严格区分大小写，如A和a分别表示两个不同的命名，意义完全不一样
• C语言命名必需以下划线或者字母开头，不能以数字开头
• C语言中命名的名字长度不限，但一般只有前8位有效，不同的命名前8位一定要不相同

C语言中的标识符可以分为3类：

（1）关键字：指C语言中有固定含义的标识符，不能表示其他的含义。包含32个：auto、extern、register、static、typedef、char、const、double、enum、float、int、long、short、signed、struct、union、unsigned、void、volatile、break、case、continue、default、do、else、for、goto、if、return、switch、while和sizeof。

（2）特定字：指C语言中有特定含义的标识符，不能表示其他的含义，与关键字并无很大区别。

特定字包括：include、define、under、ifdef、ifndef、endif、main

（3）用户标识符：值用户自己定义的一些标识符，如程序中的变量名、函数名等注意：用户标识符由下划线、数字和字母组成，首字符不能为数字，并且命名的名字不能与关键字和特定字相冲突

1.7.2 美观对称

? 在C语言中，代码讲究规范、对称和美观。通常从一个程序中就可以看出一名程序员的编程风格，好的程序员编写的代码都很简洁、美观和对称。因此开始学习C语言的时候必须注意养成良好的编程习惯。

? 建议如下：

1. 空行：空行虽然不会浪费内存，但是会浪费纸张。因此，需要根据实际情况来判断是否加空行，必要时加上空行。
2. 一行代码最好只做一件事，不要都挤在一行。
3. 在定义变量时就对该变量进行初始化，可以避免变量未初始化引发的问题。
4. 编译代码时“{” 和 “}“要对齐，可以使程序简洁，尤其是出现多队{}符号时，对齐的效果非常明显。
5. 修饰符应该紧靠变量，不容易让人产生误解

char* a,b;
char *a,b;  //不容易产生误解

1.7.3 注释形式

? 在C语言中添加注释，可以用来对程序进行分析说明以及提示需要注意的问题。注释就像旁白一样，是独立于程序本身的，不会影响程序的运行。注释虽然有助于代码的理解，但是也不能滥用。

? 建议如下：

1. 一些简单的语句不用添加注释
2. 注释应与源代码相近，不可以太远，放在代码的左边、右边、上边都可以
3. 注释应适量，不可以太多，毕竟注释只起到辅助的作用
4. 修改代码的同时应该修改注释，以保证代码和注释的一致性
5. 注释应该尽可能准确和简洁
6. 对于结构化的部分，应在该结构的开头或末尾添加注释，以便于阅读和理解

2. 数据是一切程序存在的基础

2.1 C语言中的数据类型

数据类型是按规定的形式表示数据的一种方式，不同的数据类型将占用不同的存储空间，就像我们要建造的房屋的地基，只有使用正确的数据类型，才能将这个房屋建造好。C语言提供了许多的数据类型，可以分为基本类型、构造类型、指针类型、空类型四个大类。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XHjbh10J-1631880972539)(…/C-数据类型.png)]

2.1.1 基本类型

? 基本类型不可以在分解为其他的类型，包含浮点型、整数型、字符型、枚举类型。

? 注意：其中整型包括长整型和短整型

? 整型一般占用4字节(32位)，最高位代表符号位，整数用0表示，负数用1表示，取值的范围是-2147483648~2147483647，它在内存中的存储顺序为地位在前、高位在后。

• 整型的定义：

int a=6;

• 长整型的定义：

long a=6;

• 短整型的定义：

short a=6

注意：浮点型也包括包括单精度和双精度型

• 浮点型，又称实型，也称单精度型，一般占4字节(32位)，定义如下：

float a=4.5;

• 双精度型一般站8个字节(64位)，定义如下：

double a=4.5;

• 字符型在各类系统中都只占1字节(8位)，定义如下：

char c='a';

• 字符型也可以通过字符对应的ASCII码赋值，定义如下：

char c=97;

注意：以上指定是一般情况，不同的平台可能还会有所不同，具体的平台可以用sizeof关键字进行测试

2.1.2 构造类型

? 构造类型是指使用基本类型或其他已定义的一个或多个数据类型来构造一个新的数据类型。构造类型就像一节车厢，里面包含了各种不同类型的乘客。即一个构造类型可以分解为若干个成员，每个成员都是一个基本类型或一个已定义的构造类型，比如结构类型、联合类型、数组类型等。

struct point
{
    //包含4个变量成员
    int x;      // 包含整型变量x
    int y;      // 包含整型变量y
    char z;     // 包含字符型变量z
    int A[10];  // 包含整型数组A
} // 自定义的构造类型

2.1.3 指针类型

? C语言的精华实在程序中使用指针。指针是一种特殊的、具有重要作用的数据类型。他就像内存的门牌号，指针的值表示某个地址，有了地址就能方便的访问内存。

? 指针类型跟指针的值有关，指针在内存中占4个字节，但是指针的类型却是各不相同的。例如，可以定义指针：

int *a;
char *b;
float *c;

2.1.4 空类型

? 空类型主要用来设置函数的返回值。函数在结束的时候一般都会要求调用者返回一个类型，如整型、指针类型等，编程者在设计函数的时候就要构想好函数的返回值是什么，如果函数不返回值，就设置函数返回值为空。具体设置方法如下：

void main(void)
{
    
}

2.2 数据的存储原理

2.2.1 内存单元

? 我们把计算机的内存看做一条长长的火车，一般来说，每一节火车由8个车厢构成，也就是说，在个人计算机中，一般由8个二进制“位”组成一个字节。如下图所示：

![img](file:///C:\Users\26217\Documents\Tencent Files\2621715498\Image\C2C\AC]46RTR$2SW4L2Y4`AQT.png)

? 计算机可以处理海量的信息，也需要具有巨大的容量的内存系统。为了适应海量内存的表示，通常对内存可以有多个表示单位，各个度量单位之间的转换关系如下：

1Byte = 8 bit
1KB = 1024 Byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB

注意：C程序可以处理内存的最小单位为位(bit)

? 现在计算机有512MB、1GB甚至2GB以上的内存，对于这些海量的内存单元，计算机如何做到在指定的内存单元中存取数据呢？在计算机中，每个内存单元都有一个地址，通过这个地址即可对内存中的数据进行保存和读取操作。

? 下图显示了4个字节的内容，左侧为每个字节的地址，如地址是8100内存单元中保存的数据就是97，实际上保存在计算机中的是二进制数“01100001”，在图中显示的十进制数。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NjcjjXr8-1631880972543)(…/内存地址.png)]

? 计算机中的内存是按字节顺序排列的，内存地址也依次编码。在C程序中，程序员一般不要关系具体的地址值，这些都是C编译器自动处理的。

2.2.2 字符的存储

? 要将数据保存到计算机，必须使用二进制形式来表示数据。对于字符和数值将按不同的方式进行保存。

? 对于字符，可以使用ASCII来表示。ASCII码将字母、数字、特殊符号都进行了编码，如编号97表示小写字母a，在计算机中保存字母a时，实际上是保存数字编码97(97转换为二进制编码为“01100001”)。

2.2.3 数值的存储

? 1字节为8位二进制位，正好可以存储一个字符ASCII码。而如果保存数值，则8位二进制数最大只能表示256。如果要表示更大的数，1字节就不够了。

? 在计算机中，一般整数用2字节来表示存放，而实数则用4字节或更多的字节来存放。

? 在计算机中，保存到每个字节的都是8位二进制位，那么计算机怎么区分保存的是字符还是数值呢？这就需要在程序中指明将要保存或读取的数据类型。如果设置保存字符，则只将数据写入1字节，如果设置保存整数，则将内存中相邻的2字节中写入数据。同样，在读出数据的时候，若指定读取的输出为一个字符，则只从内存中读取1字节的数据，若指定读取一个整数值，则将读取的内存中相邻的2字节，并组合为一个整数值。

2.3 标识符和关键字

2.3.1 标识符

? 在C语言中，为了引用常量、变量、数组、函数、宏名等，需要给元素设置一个名称，这些名称就是标识符。标识符就行我们为自己创造的东西起的名字，这些名字不能与已有的名字重复。每一种程序设计语言对标识符都有一定的限制，C语言标识符一般遵循以下的命名规则：

• 标识符必须以字母或下划线开头，后面可跟任意多个(可为0个)字符，这些字符可以是英文字母、下划线、数字，其他字符不允许出现在标识符中。
• 对于标识符的长度，C89规定，编译器至少能够处理31个字符(包括31)以内的标识符，C99规定，编译器应该至少能够处理63个字符(包括63)以内的标识符。在程序中，如果使用超出最大数目限制的字符来命名标识符，则编译器会忽略超出的那部分字符。
• C语言中的关键字具有特殊含义，不能作为用户自定义的标识符。
• 自定义的标识符最好取具有一定意义的字符串(见名知意)，以方便阅读，记忆和使用

注意：标识符区分大小写name、Name、NAME是3个不同的标识符。

? 了解标识符的相关规定后，即可在程序中为相关的元素设置符合要求的名称，以下的标识符是正确的，可以在程序中作为符号变量、变量、函数等的名称使用。

name
Age
address_home
telephone2
_frequency
__X

? 而下面这些标识符就是错误的

2telephone  // 以数字开头
First name  // 含有空格
return      // C语言的关键字
a+b         // 包含+号

2.3.2 关键字

? C语言简洁、紧凑，使用方便、灵活。ANSI C标准C语言共有32个关键字，9种控制语句，程序书写形式自由，区分大小写。把高级语言的基本结构和语句与低级语言的实用性结合起来。C语言可以像汇编语言一样对位、字节和地址进行操作，而这三者是计算机中最基本的工作单元。

? C语言中关键字如下：

auto、extern、register、static、typedef、char、const、double、enum、float、int、long、short、signed、struct、union、unsigned、void、volatile、break、case、continue、default、do、else、for、goto、if、return、switch、while和sizeof。

? 1999年12月16日，ISO推出了C99标准，新增了5个C语言关键字，如下：

inline、restrict、 _Bool、_ Complex、_Imaginary

? 2011年12月8日，ISO发布C语言的新标准C11，该标准新增了7个C语言关键字。如下所示：

_Alignas、_Alignof、_Atomic、_Static_assert、_Noreturn、_Thred_iocal、_Generic

注意：程序中只能使用关键字的规定作用，而不能给它们赋予新的含义。例如，关键字int规定的作用是说明整形数据，而不能用于其他的用途。

2.4 常量

? 在C语言中，程序执行时其值不发生改变的值称为常量，其值可变的称为变量，常量可以直接使用，而变量必须先定义后使用。

2.4.1 直接常量

? 直接常量又称字面常量，通过数据直接表现的形式来确定其数据类型，比如：

s=3.14*r*r;

? 在以上代码中，3.14表示为小数形式，该常量的数据类型为浮点数类型。

l=2*3.14*r

? 在以上代码中，2表示为整数，该常量的数据类型为整数类型。

2.4.2 符号常量

? 在C语言中经常用一个与常量相关的标识符来代替常量出现在程序中，这种相关的标识符称为符号常量。

? 使用符号常量的优点：

1. 使程序的常量含义清楚
2. 若修改常量，则只需修改定义符号常量的语句即可

提示：符号常量不是变量，它所代表的值在程序运行过程中不能改变。也就是说，在程序运行中，不能再使用赋值语句对它重新赋值。

可以用以下两种方法定义符号常量

• #define宏定义

#define 符号常量名 宏表达式

警告：使用#define进行宏定义的时候，最后不能添加分号。若有分号，则在进行宏替换的时候将连分号一起替换，将得到错误的结果。

• const语句定义

  另一种定义符号常量的方法是使用const语句，其语法格式如下:

  const 类型 符号常量=表达式;
  

注意：const是一条C语句，需要在语句末尾添加分号作为结束

const float PI=3.14;

2.5 变量

? 变量是常量的兄弟，不同的是，变量需要先定义再使用，否则编译器会报错。

注意：习惯上，符号常量的标识符用大写字母，变量的标识符用小写字母，以示区别。

2.5.1 变量声明

? 在C语言中，变量需要先声明再使用，这样做的好处在于：

• 确保程序中引用的变量名正确。凡引用未声明的变量，在编译时都会提示报错，这样可以减少因为输入错误而导致的变量引用错误。
• 编译器按声明的变量类型分配相应的内存单元
• 在C语言中，不同的数据类型可以进行的运行不同，在变量声明时指定了变量的类型，在编译时可以检查变量所进行的运算是否合法。

声明变量的简单格式如下：

类型说明符 变量名表;

2.5.2 变量初始化

? 编译器给声明的变量分配内存空间时，并不会对分配的内存单元清零。就像在高铁上，每个座位都有可能入座，尽管他们不一定有票，当你出示你的车票的时候，这个座位就是你的了，你便可以将霸占你座位的人赶走，也就是说，这时的内存单元是一个不确定的值。为了程序的不会因为使用一个不确定值而出现数据混乱，应在使用变量前对其进行赋初值，使其有确定的值，这种方法被称为初始化。

int age, num, count;
age=18;
count=50;

? 后面两条语句就是赋值语句，分别将常量18保存age变量中，将常量50保存count变量中。如果多个变量具有相同的值，还看使用以下的连续赋值的方式来快速初始化变量：

a=b=c=d=8;  // 执行这条语句后a、b、c、d的值都为8

? 最方便的初始化方法是在声明变量的同时为其赋值，其语法格式如下：

类型说明符 变量1=值1,变量2=值2,···;

例如：

int age=18;
int num,count=50;  //只给count变量赋初值，对变量num未进行处理

2.6 整数类型

C语言提供了多种整数类型，分别用来表示不同范围的整数。其中int类型是最基本的整数类型，程序员可根据需要选择其他类型。

2.6.1 整数类型及其存储

1. 整数类型

? 在C语言中，根据计算机字长的不同，为int分配的存储空间也不一样。如果要查看自己的计算机中int类型占用即字节的内存，可以使用以下的语句：

printf("int: %d Bytes. \n",sizeof(int));

? 其中，sizeof为一个运算符，用来计算指定数据类型或变量占用的存储空间大小，以字节为单位。

? 在声明int类型的变量时，还可以给int添加各种修饰符。通过添加修饰符可改变int类型的含义，使其更加精确的适合程序的需要。共有以下4个修饰符。

• signed：有符号，默认值

• unsigned：无符号

• long：长型

• short：短型

  在默认情况下，直接使用int关键字声明变量，该变量用来表示有符号数。以下两种声明方式是相同的：

  signed int i;
  int i;
  

  ? 在计算机中，若要表示负数，则必须使用有符号数。在有符号数中，使用一位二进制位表示符号位，如果int类型为16位字长，那么这时只能用15位来表示数值，所有其表示的数据范围将缩小。有符号int类型的取值范围为-32768_{32767。若使用unsigned来修饰int类型，用来保存无符号数据，则可以使用16位二进制位来全部表示数据，其取值范围为0}65535.

  ? 使用long修饰int，可以直接简写为long。这种类型可能占用比int类型更多的存储空间，比如在16位的计算机中，int类型为16位，long类型则为32位；在字长为32的计算机中，int类型和long类型都是32位。

  ? 使用short类型修饰int，可以之间简写为short。这种类型可能占用比int类型更少的存储空间，比如在16位的计算机中，short类型和int类型都是16位，而在字长32位的计算机中，short类型为16位，int类型为32位。

  ? 如果要表示比较大的整数，还可以使用两个long关键字来修饰int类型，如下：

  long long int i;
  

  ? 其中，关键字int可以省略，直接写为long long。这种类型占用比long类型更多的存储空间。

2. 整数的存储

? C语言提供的整数类型以及每种类型的占用的存储空间上面已经介绍。在计算机中，负数的保存比较特殊，并不是简单的将符号位位置改为1即可。为了提高计算机加减运算的速度，现代计算机都采用补码来保存数据。

? 补码的转换非常简单，可使用下面两个规则来求一个数的补码：

• 整数的补码就是本身
• 负数的补码，除符号位外逐位取反，最后再加1

2.6.2 整型常量的表示

? 在C语言中，编译器根据字面常量的表达形式确定其类型。如果程序中的字面常量看起来像整型，编译器就会将其作为整型。例如：

f=32+c;

? 在以上代码中，32将被作为int类型的常量，而如果写作如下形式：

f=32.0+c;

? 因为有小数点，则编译器会将其作为float类型的常量。

1. 整型常量的类型

? 通常，C编译器将智能识别整型常量的类型。例如，在程序中使用数字1200，编译器会将该数字以int类型存储到内存中。如果程序中有数字268263823849，这时使用int类型的将不能完整的保存该数值，那么编译器将会自动的选择unsigned long类型，如果仍不能完整的保存数据，那么编译器将会选择long long类型保存该数，甚至使unsigned long long 类型。

? 在一个小的整数后面添加一个字母l或者L，则该数被看做一个long类型的常数。在16位的计算机中，编译器将128作为2字节的int类型存储，而128L则会告诉编译器将该数保存为4字节的long类型。

? 若需要将小的整数按long long类型存储，则可以在整型常量的后面添加后缀LL(或ll)。

? 若需要将整型常量作为无符号数据存储，则可以在整型常量的后面添加后缀u(或U)。后缀U和L或LL可以一起使用。

2. 整型常量表示为十进制

? 在C语言中，可以将整型常量按十进制、十六进制、八进制来写。

十进制整型常量不需要前缀，直接由0~9的数字组成。以下各数都是合法的十进制整型常量：225、-512、65535、156472。

而以下各数不是合法的十进制整型常量：

• 0735：使用了前导0，编译器会将其认为是八进制数，相当于十进制的477
• 0818：使用了前导0，编译器会将其认为是八进制数，在八进制数中使用超过7的编码，编译器会提示出错
• 5F：含有非十进制数码

提示：在C程序中，编译器将根据数字前缀来区分各种进制，因此在书写常数时不能把前缀弄错，以免造成结果不正确。

3. 整型常量表示为十六进制

十六进制整型常量前缀为0X或0x。其数码取值为0_9，AF或a~f共16个数码。

以下是合法的十六进制整型常量：

• 0XFF：十进制的255

• 0x10000：十进制的65535

• 0x3a4f：十进制的14927

而以下的各数不是合法的十六进制整型常量：

• FFFF：无前缀0X或者0x
• 0x5HB：H为非十六进制数码

4 .整型常量表示为八进制

八进制整型常量必须以0为前缀。其数码取值为0~7.

以下各数是合法的八进制整型常量：

• 0735
• 0101
• 010000
• 0777

而以下各数不是合法的八进制整型常量：

• 254：无前缀0，编译器会将其认为是十进制的数值进行保存
• 0818：包含非八进制的数码

2.6.3 整形数据输出

? 使用printf()库函数可以将整型数据显示到屏幕上，一般情况下，可在printf()中使用%d输出整型数据。但对于unsigned、long long类型的数据，直接使用%d输出数据时可能会出现问题。另外，为了方便用户，有时还可能需要将整型数据输出为八进制或十六进制数。

1. 输出不同类型的数据

在printf()函数中，使用%d控制符可输出带符号的十进制整数。还可以使用以下控制符输出整数。

• %ld：输出signed long数值(使用%d也可以输出long数值，但若移植其他系统则可能出现问题)
• %hd：输出signed short数值
• %lld：输出signed long long数值。在有的系统中，需要使用%I64d输出该类型(是i的大写字符I，不是小写字母l)
• %u：输出unsigned int数值
• %lu：输出unsigned long数值
• %llu：输出unsigned long long数值

#include<stdio.h>
int main() {
	unsigned int ui = 2147483649U;
	long l = 65537;
	short s = 128;
	long long vl = 13198317000;

	printf("无符号整型数：%u, 显示为有符号整型数：%d\n\n", ui, ui);
	printf("短整型数：%hd, 显示为无符号短整型数：%hu, 显示为整型数：%d\n\n", s, s, s);
	printf("长整型数：%ld, 显示为整型数：%d, 显示为短整型数：%hd\n\n", l, l, l);
	printf("特长整型数：%lld, 显示为整型数：%d\n\n", vl, vl);
	getch();
	return 0;
}

运行代码得到以下结果。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6UJXbnLd-1631880972580)(…/整型数据输出实例.png)]

2. 输出十六进制数和八进制数

编写C源代码时可按3种数制(十进制、十六进制、八进制)书写数字，也允许按照这3种数制输出整数。在默认情况下输出十进制数，可在printf()函数中使用控制符来控制输出数据的数制。

• %x：将整数输出为十六进制数
• %o：将整数输出为八进制数

#include<stdio.h>
int main() {
	int i;

	printf("请输入一个十进制数：");
	scanf_s("%d", &i);

	printf("\n你输入的十进制数是：%d\n\n", i);
	printf("转换为十六进制数：%x\n\n", i);
	printf("转换为八进制数：%o\n\n", i);
	getchar();
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A6jG02Rs-1631880972584)(…/十六进制和八进制输出.png)]

2.7 字符类型

2.7.1 字符常量

与整型常量不同，字符常量必须使用指定的定界符来进行限制。字符常量是用单引号括起来的一个字符。

'c'、'w'、'y'、'0'、'#'

在程序中输入字符常量的时候，需要注意以下几点：

• 字符常量的定界符为单引号，只能用单引号来括起来，不能用双引号或其他符号
• 一对单引号只能包括一个字符，不能是多个字符
• 字符可以是ASCII码中的任何字符
• 数字被定义为字符就不能代表数字字面的量，若参与数值运算，其值将是对应的ASCII码。

2.7.2 字符变量及其初始化

与声明其他类型的变量类似，使用char关键字声明字符变量

char c1,c2;
char answer;

以上两条语句定义了三个字符变量，编译器将为每个字符变量分配1个字节的存储空间。可以使用以下的语句为字符变量赋初值：

c1 = 'w';

编译器处理该语句的时候，将字符常量w对应的ASCII码值119保存到为变量c1分配的内存单元中。

使用以下语句赋初值是不对的：

c1 = "w";
c1 = w;

因为字符常量是作为一个整数进行保存的，所以也可以使用下面的语句进行赋值

c1 = 119;

使用整数值给变量赋值时，如果整数值超过取值范围，则编译将会出现错误提示。有的C编译器将char作为有符号类型，这样其取值范围就是-128_{127；而另一些C编译器将char作为无符号类型，其取值范围就是0}255。

2.7.3 转义字符

除英文字母、数字和一些特殊符号能在屏幕上显示之外，还有许多不能显示的字符，如果让计算机蜂鸣的ASCII码值为7，怎么将这个字符赋值给一个变量呢？可以使用两种方法。

第一种方法就是将ASCII码值直接赋值给char变量，例如:

char beer=7;

这种方法可能带来一些问题，首先是不直观，其次是给程序的移植带来一些问题。如果将这个程序移植到不支持ASCII码的系统中，那么计算机蜂鸣的代码可能就不是7了。

第二种方法就是转义字符。转义字符是一种特殊的字符常量，以反斜线"\"开头，后面跟一个或几个字符。反斜线后面的字符不在具有原来的意义，所以称为转义字符。例如我们经常看见的"\n"，用来表示回车换行，下表列举了C语言中的转义字符及其意义。

广义的讲，C语言字符集合中的任何一个字符都可以用转移字符来表示，上表中最后两个就是为此提出的。ddd和xhh分别是八进制和十六进制的ASCII码值，如\111表示的字符“I”(大写的i)，\112表示的是字母"J"，\x2a表示的是字符"*"等。

转义字符中的\t产生一个制表符，制表符常用来生成一定排列规则的数据。

#include<stdio.h>
int main() {
	int i = 1, j = 2, k = 3;
	printf("输出第一种形式：\n");
	printf("变量i\t变量j\t变量k\n");
	printf("%d\t%d\t%d\n", i, j, k);
	printf("\n输出第二种形式：\n");
	printf("变量i\t%d\n", i);
	printf("变量j\t%d\n", j);
	printf("变量k\t%d\n", k);
	getch();
	return 0;
}

运行以上代码的结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sNMWDUyq-1631880972587)(…/转义字符实例.png)]

2.7.4 字符类型数据的输出

在C语言中，可以对char类型变量赋予初值，同样也允许对整型变量赋予字符常量，此时，编译器会将字符常量对应的ASCII码值保存到整型变量中。

既然char类型变量保存的也是整型数，那么也对char类型变量进行加减运算。当运算结果超过char类型的取值范围时，程序会自动舍弃高位的值，而只保存低八位的值。

在输出时，既允许把字符变量按整型数输出，也允许把整型量按字符量输出。在C语言中，printf()函数使用控制符"%c"输出字符。若要将字符量输出为ASCII码值，则可以使用输出整数的控制符"%d"。

在程序当中int类型变量中的值作为字符输出时，因为int类型占4个字节，而char类型只占了1个字节，所以此时只有低八位的值参与处理。

例如，下面的程序演示将int类型输出为字符，对char类型进行加法运算的效果：

#include<stdio.h>
int main()
{
	int i = 65, j;
	char c = 'a';
	j = i + 1;
	printf("整数i=%d，显示为字符：%c\n", i, i);
	printf("整数j=%d，显示为字符：%c\n", j, j);
	printf("字符c=%c，显示为整数：%d\n", c, c);
	c = c + 1;
	printf("字符c=%c，显示为整数：%d\n", c, c);
	getch();
	return 0;
}

编译以上程序，结果如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ekpaXlRi-1631880972588)(…/字符型数据输出实例.png)]

2.8 实数类型

在大多数程序中，使用整数就能完成任务。但是，实际中，经常会遇到处理财务数据等需要使用小数的情况，这时就需要使用C语言中的实数类型(浮点数)。

2.8.1 实数类型及其存储

1. 实数类型及其取值范围

C语言中实数包括float、double、long double三种类型。

• float类型：C语言标准规定，float类型至少能表示6位有效数字，取值范围为1十的负三十七次方~十的三十七次方。六位有效数字指float至少能表示数据的六位有效值，超出该有效值时系统会采用近似的数表示。
• double类型：称为双精度实数。double类型与float类型相比，增加了数据的精度，至少能表示10位有效数字。
• long double类型：该类型可以满足比double类型更高的精度要求。不给C语言要求long double类型至少应于double类型具有一样的精度。

2. 实数的存储

实数类型的数据与整数类型的数据存储方式不同。实数保存到内存中时会将数据分为三部分。如图所示，其中，符号位用来表示正负数，小数部分用来表示有效位，指数部分表示10的几次冥。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OdGVSQO6-1631880972589)(…/实数存储.png)]

2.8.2 实型常量的表示

与整数类型相比，实数类型可以表示更大或更小的数据。在C语言中，整数是不含小数点的数，只要数据包含小数点，就将其表示为实数。比如，5是一个整数，5.0却是一个实数。

1. 实型常量的表示方法

实型常量一般由两种表示方式：

一种是直接书写的、包含小数点的数。比如：

+0.618
.618   // 省略整数部分
95.    // 省略小数部分
-6.66

对于正号，可以省略正号。对于只有小数部分的数可以省略整数部分的0，对于无小数部分的数可以省略小数点后面的0，但是都不能省略小数点，否则会被当成整数处理。

另一种表示方法就是科学计数法，这种方法可以表示很大或者很小的数据。

对比两种形式，显示是科学计数法的形式更直观，要知道第一种表现形式数据的大小需要去仔细的数后面有多少个0。

在C语言中，科学计数法使用以下形式来表示：

尾数E阶码

尾数和阶码都可以包含符号，字母E也可以小写

注意：尾数、字母E、阶码之间不能有空格。

例如，6乘以十的九次幂可以编写成以下几种形式：

6.0E9
6.E+9
+6.E+9

2. 强制类型

在默认情况下，C编译器将实数按照double类型存储。之所以用double类型，是因为该类型的有位数多一些，能够保证计算的精度。但是double类型要占用8字节，比float多占一倍的控件，所以降低程序的运行速度。

2.8.3 实型变量

实型变量的声明和初始化方法与整型变量相同。例如：

float price = 18;
double star,end;
long double id_star = 5.833333L;

警告：实型变量和整型变量不同，整型变量能够精确的表示数据，而实型变量受有效位数的限制，在超过有效位数后将采取近似值来表示数据。

2.8.4 实型数据的输出

在库函数printf()中，可以使用以下控制符输出实型数据：

• %f：该控制符可以用来按十进制计数法输出float和double类型的数据。
• %e：该控制符可以按指数计数法输出float和double类型的数据。
• %Lf、%Le：用来输出long double类型的数据。

下面程序演示输出实型数据的方法：

#include<stdio.h>
int main() {
	float f;
	double d;

	f = 1234567890123.456789;
	d = 1234567890123.456789;

	printf("f=%f\t科学计数法f=%e\n", f, f);
	printf("d=%f\t科学计数法d=%e\n", d, d);
	getch();
	return 0;
}

运行以上程序，等到以下结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xDh2eKw9-1631880972590)(…/实型数据输出实例.png)]

在程序中给f和d初始化为通用的值。因为float和double类型的保存数据的精度不洗头，所以在输出数据的时候，显示的结果也就不同。因为float类型只能保存6~7位的有效数，所以从第8位开显示近似数。double类型的数据因其有效位数是16位，所以从第17位开始显示近似数。

2.9 混合运算及类型转换

2.9.1 混合运算

在不同的数据类型混合在一起运算时，就要进行类型转换。其转换规则很简单，各基本数据类型可以排出以下等级：

long double>double>float>long long>long>int>short>char

左边的类型比右边的类型等级高。

在不同的数据类型参与运算的时候，C语言总是将等级低的类型转换为等级高的类型，这种类型转换称为自动转换，是由编译器自动完成的。

自动转换遵循以下规则：

• 若参与计算的数据类型不同，则先转换成同一类型，然后再进行运算。
• 转换按数据长度增加的方向进行，以保证精度不降低。
• 所有的浮点运行都是双精度进行的，即使仅包含float单精度运算的表达式，也要先转换为double类型，再进行运算。
• char类型和short类型参与运算，都必须先转换为int型。

注意：在赋值运算时，无论等号右侧的类型如何，都转换为左侧变量的类型，若右侧数据的精度具有较高等级，则将被截短或舍入，使结果与左侧的变量的类型相同。

以下演示char类型和int类型的转换：

#include<stdio.h>
int main() {
	int i1;
	char c1 = 'a', c2;

	i1 = c1;
	c2 = i1;
	printf("c1=%d\tc2=%d\ti1=%d\n", c1, c2, i1);
	getch();
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3IsGtexR-1631880972591)(…/char和int类型转化实例.png)]

以下代码将float类型转换为int类型：

#include<stdio.h>
int main() {
	int i1;
	float f1 = 6.18, f2;

	i1 = f1;
	f2 = i1;
	printf("f1=%f\tf2=%f\ti1=%d\n", f1, f2, i1);
	getch();
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BsdRczis-1631880972592)(…/float类型转换为int类型.png)]

注意：代码中将float类型数据赋值给int类型时，小数部分被截掉，然后将int类型数据赋值给float类型数据时，变量i1中只存在整数部分数据。

2.9.2 强制数据类型转换

在C语言表达式中，强制数据类型转换就行司令一样，可使用强制类型转换来显示转换数据类型。强制类型转换是通过类型转换运算来实现的。表达式为：

(类型名) (表达式)；

以上格式将表达式的运行结果转换成类型名所规定的类型。类似于先将表达式的结果指定给一个指定类型的变量，然后再用该变量来参与运算。

以下演示强制类型转换实例：

#include<stdio.h>

int main()
{
	float f = 6.18;
	printf("f=%f\t(int)f=%d\n", f, (int)f);
	getch();
	return 0;
}

第6行代码通过(int)f将变量f强制转换为整数输出。转换过后并不会改变f的值，仍然为原来的6.18。

2.10 逻辑型

C99中增加了_BOOl类型，可以用来存储数据值0和1。_Bool类型是一个整数类型。

2.11 复数类型(_Complex和__Imaginary)

许多科学和工程计算都需要复数和虚数，复数是具有一个实部和一个虚部，实部就是普通的实数，虚部就是一个虚数，虚数是-1的平方根的倍数，复数常写做以下格式：

2.2+1.8i;

其中i表示-1的平方根。

C99标准支持这些类型，提供了关键字_Complex和__Imaginary，以及附加的头文件和几个新的库函数。

复数类型有3种，分别是：

• float _Complex
• double _Complex
• long double _Complex

注意：基本数据类型和_Complex之间有一个空格。

float _Complex类型的数据在保存时需要采用两个相邻的float内存空间，实部的值保存在第一个元素中，虚部的值保存在第2个元素中。

C99标准也支持3种虚数类型，分别是：

• float __Imaginary
• double __Imaginary
• long double __Imaginary

2.12 拓展训练

2.12.1 训练一：变量初始化

#include<stdio.h>

int main()
{
	int a, b;
	a = 2;
	b = 1;
	printf("a=%d,b=%d\n", a, b);
	return 0;
}

2.12.2 不同数据类型转换为十进制

#include<stdio.h>

void main()
{
	float a = 3.14;
	char b = 'a';
	printf("a=%d,b=%d\n", (int)a, (int)b);
}

3. C语言代码的基本组成

3.1 表达式

表达式是由操作数和运算符共同组成的，能够返回一个具体数值的式子。表达式中作为运算的数据称为操作数。操作数可以是常量、变量、函数表达式；运算符是介于操作数之间的运算符号，如+、-都是典型的操作符。

3.1.1 简单表达式

C语言中，最简单的表达式就是单独的一个变量、常量。例如：

A
1o
MAX
'c'

在简单的表达式中，字面常量返回的值就是其本身，变量返回的值为该变量的值，符号常量返回的为其定义的值。

注意：在C语言中，更多的表达式是由一个或多个运算符连接的。

例如：

3.14*2*2
PI*2*r

3.1.2 逗号表达式

在C语言中，逗号既可以作为分隔符，又可以用在表达式中。逗号作为分隔符使用时，用于间隔说明语句中的变量或函数中的参数。例如，在变量的声明中或者函数中作为参数的分隔符。

将逗号用在表达式中，可将若干个独立的表达式连接在一起，组成逗号表达式。逗号表达式的一般形式是：

表达式1,表达式2,...,表达式n

逗号表达式的运算过程是，先计算表达式1的值，然后计算表达式2的值，一直计算到最后一个表达式n，并将表达式n的值作为逗号表达式的值返回。逗号表达式的经典型的应用是在for循环中。

以下是逗号表达式的演示：

#include<stdio.h>

int main()
{
    int i;

    printf("%d\n", ((i = 5 * 2, i * 3), i * 5));

    return 0;
}

运行以上代码输出结果为50。

3.2 运算符

运算符是表示一个特定的数学或逻辑运算符号。C语言提供了非常多的运算符，通过数量众多的运算符构成丰富的表达式，使C语言的功能十分完善，这是C语言的主要特点之一。

3.2.1 运算符概括

在数学运算中，运算符是由优先级的，如在同一算式中先乘除后加减。与此类似的，C语言中运算符也是有优先级的。C语言中除算术运算符之外，还有其他很多独立的运算符，一些不同性质的运算采用了相同的运算符，这就为掌握运算符的运算规律带来了一定的难度。

C语言中的运算符不仅具有不同的优先级，而且还有一个特点，就是它的结合性。在表达式中，各运算量参与运算的先后顺序不仅要遵循运算符的优先顺序的规定，还要受运算符结合性的制约，以便确定是从左到右进行运算还是从右到左进行运算。这种结合性是其他高级语言的运算符所没有的，因此也增加了C语言的复杂性。

C语言运算符按其功能分为算数运算符、赋值运算符、逗号运算符、逻辑运算符、关系运算符、位逻辑运算符、条件运算符、括号运算符、地址运算符、成员访问运算符、sizeof()运算符等；按其要求参与运算的操作数的数目可以分为单目运算符、双目运算符、三目运算符(也称多目运算符)。

3.2.2 算数运算符

1. 双目运算符

在C语言的5个双目算数运算符中，加减乘除运算符的操作数都与数学中的含义相同，只是使用*表示乘号，使用/表示除号，这种表示方法在所有程序设计语言中都是相同的。

C语言中增加了一个号求模运算符(%)。所谓的求模运算，是指将第一个操作数除以第二个操作数得到的余数。

注意：求模运算符的两个操作数都必须是整型数据，不能是实型数据。

当除号两侧的操作室整型时，结果也是整型，若是不能整除，那么余数将被舍弃。

若运算符两边的操作室的类型不同，则系统会自动进行转换，使操作数具有相同的类型后进行运算。

十进制数转换为二进制数的方法是除2取余法，即将十进制数反复除以2，取余数作为相应的二进制数最低位，再除以2得到余数作为二进制数的第二位，循环想除即可将其转换为一个二进制数。下面程序将使用求模和整除的方法将十进制数转换为二进制数。

#include<stdio.h>

int main()
{
	int t, t1, b0, b1, b2, b3, b4, b5, b6, b7;
	printf("请输入0-255之间的数字：");
	scanf_s("%d", &t);
	t1 = t;
	b0 = t % 2; //第1位二进制位
	t = t / 2;
	b1 = t % 2; //第2位二进制位
	t = t / 2;
	b2 = t % 2; //第3位二进制位
	t = t / 2;
	b3 = t % 2; //第4位二进制位
	t = t / 2;
	b4 = t % 2; //第5位二进制位
	t = t / 2;
	b5 = t % 2; //第6位二进制位
	t = t / 2;
	b6 = t % 2; //第7位二进制位
	t = t / 2;
	b7 = t % 2; //第8位二进制位
	t = t / 2;
	printf("十进制数：%d", t1);
	printf("转换为二进制数为：%d%d%d%d%d%d%d%d\n", b7, b6, b5, b4, b3, b2, b1, b0);
	return 0;
}

2. 单目运算符

单目运算符只需要一个操作数。比如取负运算符操作数设置为负数，如果操作数为负数，则得到的结果为正数。

C语言中更常用的两个单目运算符是其他高级语言中通常没有的，就是自增运算符和自减运算符。

自增运算符使变量的值自增1，自减运算符使变量的值自减1。例如：

i++;
J--;

使用自增自减运算符可以使代码更加的简单。使用自增自减运算符可以节省代码行，例如：

j=i++;

相当于：

j=i;
i=i+1;

注意：自增运算符和自减运算符的运算对象都只能是变量，不能是常量或表达式。例如：5++或++(i+1)。

自增自减运算符可以通过两种方式来使用：一种是后缀形式，即运算符出现在变量的后面，另一种是前缀模式，即预算符出现在变量前面。这两种模式的区别在于值的增减的时间不同。

• 采用前缀模式时，先执行变量的自增或自减操作，再用计算的结果参与表达式的运算。
• 采用后缀模式时，先使用变量参与表达式的计算，再对变量执行自增或自减的操作。

以下代码演示自增运算符的后缀模式和前缀模式的计算结果：

#include<stdio.h>
int main()
{
	int i = 0, j = 0;
	printf("变量i\t变量j\n");
	printf("%d\t%d\n", i++, ++j);
	printf("%d\t%d\n", i++, ++j);
	printf("%d\t%d\n", i++, ++j);
	printf("%d\t%d\n", i++, ++j);
	return 0;

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J5xX4GvQ-1631880972593)(…/自增运算符的前缀后缀.png)]

3. 算数运算符的优先级

3.2.3 赋值运算符

C语言将赋值作为一种运算，并定义了赋值运算符。他的作用就是把一个表达式的值赋予一个变量。

注意：赋值运算符的左边必须是一个变量。

C语言的赋值运算符分为两类：简单赋值运算符；复合赋值运算符。下面分别介绍这2两类赋值运算符。

1. 简单赋值运算符

简单赋值运算符(=)的语法格式如下：

变量 = 表达式;

赋值运算符的作用是对右侧表达式进行计算，然后将计算结果保存到左侧指定的变量之中。左侧必须是变量，不能是表达式或者常量

赋值运算符“=“与在数学表达式中的符号"="的意义是不同的，赋值运算符表示的是内存空间的复制操作。

在C语言中，赋值运算符是一个运算符，因此可以出现在表达式中。例如：

count = (start = 98) + (end = 208);

以上是现将常量98赋值给start、常量208赋值给end，再将end和start相减的结果赋值给count，最后count的值是306。

2. 复合赋值运算符

C语言提供了许多的精简代码的运算符，在赋值运算符中，又将其他的运算符和赋值运算符组合，提供了复合赋值运算符。

复合赋值运算符是由各种常用运算符与赋值运算符组合而成的运算符，共有十种形式，如下表所示：

每个赋值运算符都由两个或三个字符组成，除赋值号以外，前面的字符都是一个运算符。

提示：在使用符合赋值运算符时，首先将右侧的表达式计算得到一个结果，再用这个结果与左侧变量的值进行相关运算。

复合赋值运算符实例：

#include<stdio.h>
int main()
{
	int i, j;

	i = 3;
	j = 2;
	i *= j + 2;

	printf("%d\t%d\n", i, j);
	return 0;
}

编译这个程序，变量i的值变为12，变量j的值还是初值2。

3.2.4 关系运算符

关系运算符用来判断两个操作数的大小关系。

在数学中，有6种关系运算符：小于、大于、小于或等于、大于或等于、等于、不等于。

在C语言中这六种关系运算符有所改变，如下表所示：

通过关系运算符计算得到的结果只有两种：true或false。其中true表示指定的关系成立，而false表示指定的关系不成立。

在C语言中，true与yes或1相同，false与no或0相同。在以后的程序中可以看出，只要是非0值，C语言都将其解释为true，为0解释为false。

在使用关系运算符进行比较时，还需要注意等于和不等于这两个运算符，一般都只用在整型数据中，而不将其应用到实型数据中。这是因为实型数据保存的值存在误差，有可能两个应该相等的数不相等。

关系运算符的实例：

#include<stdio.h>
int main()
{
	float f;

	f = 1.0 / 3;
	printf("%f\n", 3 * f);
	printf("%d\n", (3 * f == 1));
	return 0;
}

3.2.5 逻辑运算符

使用关系运算符可以对两个操作数进行比较，如果需要多个关系表达式的结果合并在一起，则需要使用逻辑运算符。

i>=0 && i<=10;

如果变量i的值在0-10之间，那么以上表达式的结果就是true，否则为false。

C语言提供了三种逻辑运算符，如下表所示。与关系运算一样，逻辑运算的结果为true或false。

注意：在逻辑运算符中，逻辑与和逻辑或都是双目运算符，逻辑运算的结果为true或false。

设有两个变量a和b，用来保存逻辑量true和false，变量a和b可以进行上表的所列的3种逻辑运算。因逻辑量只有两个值，所以3种逻辑运算的结果也能确定。将这些内容用一张表格来表示，就是逻辑运算的“真值表”，如下表所示：

由此表可以看出：

• 对于逻辑非运算，结果总是与操作数相反。
• 对于逻辑与运算，只有两个操作数都为true时，结果才会是true。
• 对于逻辑或运算，只有两个操作数都是flase时，结果才会是false。

注意：3个逻辑运算符的优先级：! > && >||。

下面程序演示逻辑运算符的使用：

#include<stdio.h>
int main()
{
	float f = 6.18;
	char c = 'h';
	int i = 3, j = 0;

	printf("i&&j=%d\n", i && j);
	printf("i||j+2&&c=%d\n", i || j + 2 && c);
	printf("!f=%d\n", !f);

	return 0;
}

3.2.6 位运算符

与其他高级语言相比较，位运算是C语言一个比较有特色的地方，利用位运算可以实现许多汇编语言才能实现的功能。

所谓位运算，是指进行二进制的运算。C语言提供的位运算符如下表所示：

位运算符中除了~是单目运算符以外，其余都是双目运算符。

警告：位运算所操作的操作数只能是整型或字符型数据以及它们的变体。位运算不能用于float、double、long或其他更复杂的数据类型。

3.2.7 条件运算符

通过条件运算符把3个表达式连接在一起，组成条件表达式。条件表达式的语法格式如下：

表达式1?表达式2:表达式3

由以上格式可以看出这是一个三目运算符，通过问号和冒号将三个表达式分开，这是C语言中唯一一个三目运算符。

条件表达式的运算过程是：先计算表达式1的值，如果它的值为true，则将表达式2的值作为条件表达式的值，若表达式1的值为false，则表达式3的值作为条件表达式的值。

使用条件表达式可以替代简单的if语句，下面程序让用户输入3个整数，求出这3个整数的最大数：

#include<stdio.h>
int main()
{
	int a, b, c;
	int max;

	printf("请输入第一个整数：");
	scanf_s("%d", &a);
	printf("请输入第一个整数：");
	scanf_s("%d", &b);
	printf("请输入第一个整数：");
	scanf_s("%d", &c);

	max = (a > b ? a : b);
	max = (max > c ? max : c);

	printf("最大数是：%d\n", max);
	return 0;
}

在条件表达式中，可能表达式2和表达式3结果值的类型不同，这时C编译器会自动进行转换。例如：

a>0?6.18:3

在以上表达式中，表达式2的类型为实型，而表达式3的类型为整型。这时，C编译器将整数3转换为3.0，最后计算结果返回值为实型。

3.2.9 其他运算符

除了上面介绍的各种运算符，C语言还有以下的运算符。

• sizeof：长度运算符(单目运算符)
• []：下标运算符
• .：结构体成员运算符
• ->：指向结构体成员运算符
• *：指针运算符(单目运算符)
• &：取地址运算符(单目运算符)

1.5 sizeof长度运算符

sizeof长度运算符是C语言中一个比较特殊的运算符。大部分程序设计语言中的运算符都是由一个或几个特殊符号构成的，看起来sizeof不像一个运算符，更像一个函数。但是sizeof确实是C语言中的一个运算符。

简单地说，使用sizeof运算符可以返回一个数据类型所占的内存字节数。其操作数可以是数据类型、变量、常量。例如，以下程序是分别使用sizeof计算数据类型、常量、变量的字节长度。

#include<stdio.h>
int main()
{
	float f = 5;

	printf("%d\n", sizeof(float));
	printf("%d\n", sizeof(5.0f));
	printf("%d\n", sizeof(f));

	return 0;
}

编译运行以上的程序，可以看到输出的数字都是4。

2. []下标运算符

下标运算符在数组中使用。

3. .结构体成员运算符和->指向结构体成员运算符

这两个运算符将在结构总使用。

4. *指针运算符

指针运算符主要对指针进行操作。

5. &取地址运算符

在使用scanf()函数的时候接收用户的输入时，需要在变量名前添加&运算符。

3.3 表达式的运算顺序

在C语言中，表达式可以由各种类型的操作数和运算符组成。对应这种由多个运算符连接的表达式，必须知道C对运算符操作的顺序，才能确切的知道表达式最终的结果。

3.3.1 运算符优先级

前面在介绍算数运算符时提供了运算符的优先级，当表达式中有多种类型的运算符混合在一起时，就需要对C语言的所有运算统一规定优先级。

在C语言中，运算符的运算优先级分为15级，1级最高，15级最低。在表达式中，优先级高的先运算。运算符的优先级如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wIB6tOMs-1631880972593)(file:///C:\Users\26217\AppData\Roaming\Tencent\Users\2621715498\QQ\WinTemp\RichOle\OQFA0@F7T]VQK~Y9YA}YQVD.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sVbolNvl-1631880972595)(file:///C:\Users\26217\AppData\Roaming\Tencent\Users\2621715498\QQ\WinTemp\RichOle\20$4Y@4C00@EW5CVZBK}FUU.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MAXOR0Q9-1631880972596)(file:///C:\Users\26217\AppData\Roaming\Tencent\Users\2621715498\QQ\WinTemp\RichOle%FSUWRVIR(_{ASU_R)]N84}E4.png)

优先级为1的圆括号就是用来改变其他运算符优先级的，即如果需要将具有较低有优先级的运算符先运算，则可以将该运算符及其操作数用圆括号括起来。

3.3.2 运算符的结合性

在表达式中，当一个操作数两侧都有运算符，且两个运算符的优先级相同时，C语言按照什么顺序来运算表达式呢？例如：

a+b-c

操作数b的左侧为加号，右侧为减号，具有相同的优先级。对于这个表达式，都知道是从左到右顺序，先算加法再算减法，这种方式称为左结合，大部分都采用这种方式。

而以下这种表达式：

a=b=c

操作数b的左右两侧都是赋值运算符，在C语言中规定将先运算右侧的赋值操作，这种从右到左的顺序进行运算的方式称为右结合。

3.3.3 自增、自减运算符注意事项

1. 操作数的类型

自增、自减运算符的操作数只能是变量，而不能是常量或表达式。因为自增、自减运算符具有对运算量重新赋值的功能。整型、实型、字符型、枚举型都可以作为这两个运算符的操作数。

2. 操作符产生歧义

在C语言中，操作符的使用想当灵活。但是由于这种灵活性也可能使程序产生歧义，甚至出现在不同的C编译器中运算的结果不相同的现象。

int a, b;
a = 4;
b = a+++a+++a++;

执行以上程序后，变量a和变量b的值各为多少？

• 第一种情况：变量b的值为12(4+4+4)，变量a的值为7。
• 第二种情况：变量b的值为15(4+5+6)，变量啊的值为7。

警告：在程序中，类似于a+++a+++a这种连续自增、自减的运算最好不要使用，以免出现歧义，同时也减少程序出错的可能性。

3.4 语句

语句是C程序的基本成分，一条语句是一条完整的计算机指令。在C语言中，每条语句都必须使用一个分号作为结束符。

3.4.1 语句书写方式

C语言的语句限制条件很少，最基本的一条就是每条语句都必须以一个分号结束。用户可以很随意的、采用符号自己风格的方式排列C语言。与其他的程序设计不同，一条C语句可以排列在多行中。例如，有以下语句：

s=(a+b)*h/2;

也可以写成以下格式：

s=
(a+b)*h/2;

甚至可以写成以下格式：

s=
(a+b)
*h/2;

在C语言中，通过分号标识一条语句的结束，所以上面的两行或三行没有分号，表示这两行或三行为一条语句。

将一行语句按多行写不是一个好习惯，但是这样的语句是合法的。

同样，因语句使用分号作为分隔符，将多条语句写在一行中也是合法的。例如：

a=b;b=c;c=a;

一般情况下，C编译器将忽略语句中的空格、制表符和空行。因此为了使源程序的排列更加的美观，更利于程序的排错，一般使用以下规则输入源代码：

• 在一行内只写一条语句，并采用空格、空行保证清楚的视觉效果
• 每条复合语句使用一个Tab键缩进，复合语句的大括号放在最新的一行，单独成一行，便于检查源程序时进行匹配。

3.4.2 表达式语句

大部分高级程序设计语言中专门有赋值语句，而在C语言中将赋值作为一个操作符，因此只有赋值表达式。在赋值表达式后面添加分号，就成了独立的语句。

以下内容可以作为表达式语句：

10;
3.14*2*2;
2*a*b+3;

以上表达式语句从语法上讲是正确的，能被C编译器顺利编译，但是这些语句不对程序执行有任何有用的操作。一般表达式语句应能完成一个相应的操作，如修改变量的值、给变量赋初值、调用某个函数等。如以下的语句：

a+=10;
s=3.14*2*2;
printf("%d\n",a);

执行以上表达式语句，将对表达式进行求值，并将其赋值给某个变量。

3.4.3 空语句

在C语言中，如果一条语句只有一个分号，则称该语句为空语句。

空语句是什么也不执行的语句。在程序中的主要作用作为空循环体。例如：

while(getch() != '\n');

以上代码的功能是，只要从键盘输入的字符不是回车就要求用户重新输入。即要求用户按回车键才能继续执行后面的程序。在该部分代码中，接收用户按键、判断按键的内容都集中在while的判断中，因此，循环体中不再需要任何功能，就在循环体重输入一个空语句作为循环体。

3.4.4 复合语句

复合语句是由大括号中的0个或多个声明和语句共同构成的。在C99标准中语句和声明可以混合，在早期的C语言中则要求把声明放在语句之前。复合语句也被称为代码块。

复合语句可以放在能够使用语句的任何地方，大多数时候用在if或while等程序控制结构中。例如：

if (a[i]<a[j])
{
    temp=a[i];
    a[i]=a[j];
    a[j]=temp;
}

3.4.5 标号语句

C语言允许用户在每条语句的前面添加一个冒号，其格式如下：

标号：语句;

标号是C语言中的一个标识符，标号后面是一个冒号，冒号后面才是C语言的语句。

警告：标号不能单独出现，而要和语句相联系。

可以使用goto语句或switch分支语句将程序控制转移到编有标号的语句。标号语句有3种：

• 命名标号：可在任何语句前面添加命名标号，使用goto语句可跳转到命名标号处。
• case标号：只能出现在switch语句体中进行分支处理。
• default标号：只能出现在在switch语句中进行分支处理。

3.5 拓展训练

3.5.1 加1和减1运算符

#include<stdio.h>

int main()
{
	int x = 3, y = 5;
	int a = x++;
	int b = y--;
	int c = ++x;
	int d = --y;
	printf("%d,%d,%d,%d\n", a, b, c, d);
	return 0;
}

3.5.2 三目运算符

#include<stdio.h>

int main()
{
	int x = 5;
	int y = ++x ? 0 : 1;
	printf("%d,%d\n", x, y);
	return 0;
}

5.2.3 逗号运算符

注意：逗号运算符可以将多个表达式组合在一起，其返回值为逗号右边的值。

例如：

y=(x=1,x+2);

首先将1赋值给x，再进行加2操作，最后将逗号右边的值赋值给y，即3。

逗号运算符本质上是将多个运算式组合在一起，从左至右逐个运算，然后将逗号右边的值赋给左边的变量。例如

x=1;
y=(x=x+2,x=x*3,x-5);

根据给出的数据，对其进行算术运算和逻辑运算。

#include<stdio.h>

void main()
{
	int x = 0, y = 1, z;
	float a = 5.7;
	char b = 'z';
	z = (++x) && (--y);
	printf("%d\n", z);
	z = a - y;
	printf("%d\n", z);
	z = b;
	printf("%d\n", z);

}

4. 控制输入/输出的形式

4.1 格式化输出----printf()函数

C程序运算的结果保存在内存中，必须将其输出到指定设备，才能让用户了解程序的运行结果。显示器就是计算机的标配设备，将程序的运行结果输出到显示器是最常用的方法。

4.1.1 printf()函数输出格式

在前面已经多次使用到了printf()函数，它的作用是向显示器输出多个任意类型的数据。

该函数包括两部分参数，其作用如下：

• 格式字符串：用双引号括起来的字符串，在该字符串中可以只包含普通字符，这时printf()函数将其原样输出在屏幕上；还可以包含以%开头的格式字符，他它的作用就是将输出的数据转换为指定的格式输出。格式说明总是由%字符开始的，printf()函数的格式字符有很多。
• 输出列表：是需要输出到屏幕的数据，可以是常量、变量或表达式。若为表达式，则将输出表达式的值。

4.1.2 printf()函数的格式化字符

在printf()函数的第一个参数必须是以%开头的格式化字符，才能将输出中的表达式按规定的格式输出。对于输出同一个值，使用不同的格式字符将输出不同的结果。

4.1.3 修饰符

printf()函数的格式字符串用于指定输出格式。格式字符是以%开头的字符串，在%后面接着各种格式字符，以说明输出数据的类型。在%和格式字符之间还可以使用一个或多个修饰符，对输出的格式进行进一步控制，如控制对齐方式、输出长度、小数位数等。

对printf()函数的格式字符进行拓展，加入修饰符后的一般形式如下：

[标志][输出最小宽度][.精度][长度]类型

1. 标志

共有五种标志，可以使用0个或者多个标志。

2. 输出最小宽度

用十进制整数来表示输出的最少位数，有实际位数多余定义的宽度，则按实际位数输出，若实际位数少于定义的宽度，则补以空格或0。

printf()函数输出最小宽度控制实例：

#include<stdio.h>

int main()
{
	int i = -78, j = 65535;

	printf("%d %d\n", i, j);
	printf("%4d %4d\n", i, j);      // 输出至少4个字符宽的整型变量
	printf("%-4d %-4d\n", i, j);    // 输出左对齐的4个字符宽的整型变量
	printf("%+4d %+4d\n", i, j);    // 输出带符号的4个字符宽的整型变量
	printf("%#x %#X\n", i, j);      // 输出带前缀的十六进制整数
	printf("%04d %04d\n", i, j);    // 输出至少4个字符的宽度的整型变量，不足补0
	printf("% d % d\n", i, j);      // 输出修饰符空格输出变量
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VMHqhzM1-1631880972598)(…/printf函数输出最小宽度实例.png)]

3. 精度

精度修饰符以“.”开头，后跟十进制整数。该修饰符的意义：如果输出的是整数，则表示输出的最小位数，若输出的位数小于该值，则将添加前置0；如果输入的是实数，则表示小数点的位数；如果输出的是字符，则表示输出字符的个数，若实际位数大于所定义的位数，则截取超过的部分。

#include<stdio.h>

int main()
{
	int j = 65535;
	float f = 3.1415926;
	printf("j = %.8d\n", j);
	printf("f = %.2f\n", f);
	printf("f = %07.2f\n", f); // 输出至少7个字符宽度且精度为2的实型变量f
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AM2KX813-1631880972599)(file:///C:\Users\26217\AppData\Roaming\Tencent\Users\2621715498\QQ\WinTemp\RichOle\55]SL0SHH1{AV_814}MOVD.png)]

4. 长度

这里所说的长度是指输出数据所占用的内存的长度，其实就是输出指定类型的数据。在正常情况下，使用%d格式字符输出int类型的数据。若要输出long类型的数据，则需要使用%ld，其中l是长度修饰符。可以使用如下表所示的长度修饰符：

现在大部分是32位字长的计算机系统，int和long类型使用相同的字节数，在printf()函数中可以使用%d输出这两种类型的数据，也可以使用%ld输出long类型的数据。使程序在移植到16位字长的计算机系统中也可以正常使用。

对于short类型和char类型的数据，使用%d也可以正常输出。

3.1.4 printf()函数实例

1. 输出字符

使用格式字符"%c"可将整数类型的数据输出为一个对应的ASCII字符。char类型的取值范围为-128~127，正好对应一个ASCII字符。

printf()函数输出字符实例：

#include<stdio.h>

int main()
{
	int i = 75, j = 65535;
	char c = 'w';

	printf("整型数：%d，输出字符：%c\n", i, i);
	printf("整型数：%d，输出字符：%c\n", j, j);
	printf("字符：%c，输出为整型数：%d\n", c, c);

	return 0;

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t0w3dFTJ-1631880972600)(…/…/AppData/Roaming/Typora/typora-user-images/image-20210715210239838.png)]

2. 输出整数

printf()函数输出整数的格式字符有很多个，如%d，%u，%o，%x或%X，对这些格式字符还可以添加标志、宽度、长度等修饰符。

#include<stdio.h>

int main()
{
	int i = 75, j = -65355;

	printf("整型数：%6d和%6d，输出为无符号数：%12u和%12u\n", i, j, i, j);
	printf("整型数：%6d和%6d，输出为八进制数：%#12o和%#12o\n", i, j, i, j);
	printf("整型数：%6d和%6d，输出为十六进制数：%#10x和%#10x\n", i, j, i, j);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3jU4Yhie-1631880972601)(…/printf函数输出整数.png)]

3. 输出实例

printf()函数输出实数的格式字符有很多个，最常用的就是%f、%e(或%E)、%g(%G)。对于这些格式字符也可以添加标志、宽度、长度等修饰符。

#include<stdio.h>

int main()
{
	float f = 130.79069388;
	double d = 13198317000.2682882;
	printf("f=%f,%5.4f,%e,%g\n", f, f, f, f);
	printf("d=%f,%8.4f,%E,%G\n", d, d, d, d);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e84oLFlQ-1631880972603)(…/printf函数输出实数.png)]

4. 输出字符串

在printf()函数中使用%s将字符串原样输出，如果字符串中包含转义字符，则将转义字符的意义进行操作，如果字符串中包含\n则进换行、包含\f则后面的内容将在下一个制表位输出。

可以添加以下修饰字符来控制字符串的输出：

• %ms：输出的字符串占m列。若字符串本身长度大于m，则突破m的限制，将字符串全部输出；若字符串本身长度小于m，则在左侧补空格。
• %-ms：如果字符串本身长度小于m，则在m范围内，字符串向左对齐，右侧补空格。
• %m.ns：输出占m列，但值输出字符串中左侧的n个字符。这n个字符输出在m列右侧，左侧补空格。
• %-m,ns：其中m、n的含义同上，即n个字符输出在m列范围的左侧，右侧补空格。如果n>m，则m自动取n值，即保证n个字符正常输出。

#include<stdio.h>
#define STR "Hello,World!"

int main()
{
	printf("%s*\n", STR);
	printf("%15s*\n", STR);
	printf("%-15s*\n", STR);
	printf("%15.5s*\n", STR);
	printf("%-15.5s*\n", STR);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lKSQ9HL2-1631880972604)(…/…/AppData/Roaming/Typora/typora-user-images/image-20210715215802141.png)]

4.1.5 动态设置输出宽度和精度

在printf()函数中，通过在格式字前面添加相应的修饰符可以控制输出最小宽度和精度。一般情况下，在程序编码阶段就设置好这两个参数，例如：

printf("%15.5f\n",f);

以上语句中设置输出变量f时，至少占用15个字符的宽度，小数位数保留5位。这是常用的表示形式。其实，对于输出宽度和精度，还可以使用"*"来代替，这时，printf()函数将使用输出列表中对应的数据作为输出宽度和精度，格式入下：

printf("%*.*f*\n",m,n,f);

其中的变量m对应第一个星号，设置输出宽度，变量n对应第二个星号，设置输出精度。

#include<stdio.h>

int main()
{
	int m, n;
	float f = 130.79069388;
	
	printf("设置数据最少输出宽度值：");
	scanf_s("%d", &m);
	printf("设置数据输出的小数位数：");
	scanf_s("%d", &n);
	printf("%*.*f\n", m, n, f);
	return 0;

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E5dEhSaw-1631880972605)(…/…/AppData/Roaming/Typora/typora-user-images/image-20210715221518312.png)]

4.1.6 printf()函数的返回值

提示：大多数程序都不处理printf()函数的返回值。在一些特殊情况下，需要检测printf()函数是否执行成功，可使用一个变量来保存其返回值。

C函数一般都只有一个返回值，返回值使用由函数返回给调用程序的一个值。printf()函数也有一个返回值，正常情况下返回打印输出的字符数目。如果printf()函数执行出错，则返回一个负数。

#include<stdio.h>
#define STR "Hello,World!"

int main()
{
	int i;

	i = printf("%s\n", STR);
	printf("上一行代码输出了%d个字符\n", i);
	getch();
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-grmpTiZ9-1631880972606)(…/…/AppData/Roaming/Typora/typora-user-images/image-20210715222252204.png)]

调用printf()函数输出字符串常量STR，并返回输出的字符数量。打印的上一行代码的输出的字符数量。字符常量STR保存的可见字符为12个，C将自动为字符串添加一个结束标志，因此共有13个字符。

4.1.7 理解输出列表

printf()函数的输出列表可以有多个表达式，其数量至少应该与格式字符串中的格式字符相匹配。若多余格式字符的数量，则多余表达式的值不会被输出；若少于格式字符的数量，则可能输出一些无意义的值。

注意：使用printf()函数的时候，编译器将传递给函数printf()的参数存入一个称为堆栈的内存区域。堆栈中的数据采用“后进先出”的方式，即最后保存的数据将最先被读取出来。因此，printf()函数总是将参数按从后往前的顺序放到堆栈中。

例如：

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

调用以上语句的时候，先将变量j的值存入堆栈，再将变量i的值存入堆栈，再将变量f的值存入堆栈，最后将第一个参数(格式字符串)存入堆栈。进入函数printf()执行其代码时，首先对第一个参数(格式字符串)进行分析，每找到一个格式字符就从堆栈中取一个输出值。这样，若格式字符的数量和输出表达式的数量匹配，则函数printf()能够顺利输出所有值；若格式字符的数量比输出表达式的数量多，则函数printf()取完装入堆栈中的值后，还将继续从堆栈中取值，所以将得到一个无意义的值；若格式字符的数量比输出表达式的数量少，则多余的值将被留在堆栈中不进行处理。例如以下程序输出i的值：

#include<stdio.h>

int main()
{
	int i = 3;
	printf("%d\t%d\t%d\t%d\n", ++i, --i, i--, i++ );
	return 0;
}

当格式字符与输出列表中的值的类型不匹配时会输出杂乱的毫无意义的值：

#include<stdio.h>

int main()
{
	int i = 10;
	long l = 90;
	float f = 6.18;
	double d = 9.18;

	printf("%e,%e,%e,%e\n", i, l, f, d);
	printf("%ld,%ld\n", i, l);
	printf("%ld,%ld,%ld,%ld\n", f, d, i, l);

	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BrtLztMe-1631880972607)(…/…/AppData/Roaming/Typora/typora-user-images/image-20210716104004112.png)]

4.2 格式化输入scanf()函数

4.2.1 scanf()函数的格式

scanf()函数被称为格式输入函数，使用该函数可以按指定的格式从键盘上把数据输入到指定变量中。

scanf()函数是一个标准的库函数，他的函数原型在头文件“stdio.h”中。scanf()函数的一般形式为：

scanf("格式字符串",地址列表);

其中格式字符串的作用与printf()函数相同；地址列表中给出各变量的地址。地址是由地址运算符&后面跟上变量名组成的。这个地址是编译系统在内存中给变量分配的地址，用户不用关心具体的地址是多少，只需要在scanf()函数的变量名前面加上&即可。

#include<stdio.h>

int main()
{
	int a, b;

	printf("请输入两个整数：");
	scanf_s("%d %d", &a, &b);

	printf("你输入的两个整数是：%d %d\n", a, b);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-se9Stdgv-1631880972609)(…/…/AppData/Roaming/Typora/typora-user-images/image-20210716110849507.png)]

4.2.2 scanf()函数的格式字符

scanf()函数的格式字符作用与printf()函数的相同，但比printf()函数相比，少了一个精度控制修饰符。

%[*][输入数据宽度][长度]类型

1. 类型

表示输入数据的类型，其格式字符和意义如下：

• d或i：输入十进制数
• o：输入八进制数
• x或X：输入十六进制数
• u：输入无符号十进制数
• f、e、g：输入实型数
• c：输入单个字符
• s：输入字符串

2. 长度

长度格式为l和h，l表示输入长整型数据(如%ld)和双精度浮点数(如%lf)，h表示输入短整型数据。

3. 宽度

注意：用十进制整数指定输入的宽度(字符数)。达到指定宽度后，后面数据将赋值给下一个变量。

例如：

scanf("%4d",a);

如果输入以下内容：

123456789

则scanf()函数只会将1234保存到变量a中，其余部分被舍弃。

如果有多个字符使用宽度限制，如以下代码：

scanf("%3d%3d",&a,&b);

同样输入123456789，则scanf()函数将123保存到变量a当中，456保存到变量b当中，其余部分将被舍弃。

4. 星号

在格式字符中使用星号，表示从输入缓冲区读取该数据项后不赋予相应的变量，即跳过该输入值：

scanf("%d%*d%d",&a,&b);

当输入为“12 34 56”时，scanf()函数将输入的第一个数12保存到变量a当中，将第2个数34跳过，将第3个数56保存到变量b当中。这种方式在处理已有的一批数据而又需要跳过部分数据时很有用。

4.2.3 scanf()函数的注意事项

1. 不能控制输入精度

#include<stdio.h>

int main()
{
	float f1, f2;

	printf("请输入实数f1：");
	scanf_s("%5f", &f1);

	printf("请输入实数f2：");
	scanf_s("%5.5f", &f2);

	printf("f1=%f,f2=%f\n", f1, f2);
	return 0;
}

编译以上代码VS2019在输入第2个变量时直接报错。如果换成其他的编译器可能输入完f1的值之后直接跳过f2的输入，直接printf()输出f1，f2的值，变量f1的值输出可能会有误差，f2的值输出可能为0或者其他不确定的值。

2.在格式字符串中包含非格式字符

前面介绍了在输入多个数值数据时，若格式字符串中没有非格式字符作为输入数据之间的间隔，则可以用空白字符(空格、Tab、回车符)作为间隔。scanf()在碰到空白字符或非法数据时即认为该数据结束。

警告：当格式字符串中包含非格式字符，则要求用户输入数据时也必须原样输入这些非格式字符。

如下：

#include<stdio.h>

int main()
{
	int a, b;
	
	printf("请输入两个整数：");
	scanf_s("a=%d b=%d", &a, &b);

	printf("你输入的整数是：a=%d,b=%d\n",a,b);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DLfcjLof-1631880972610)(…/…/AppData/Roaming/Typora/typora-user-images/image-20210716151225617.png)]

4.2.4 scanf()函数的返回值

scanf()函数的返回值，其返回值为成功读入数据的项目数。若在scanf()函数中需要读取一个整数，而用户却输入一整个字符串时，则scanf()函数将不能获得一个有效的数据，则返回值为0。

#include<stdio.h>

int main()
{
	int a, b, c, i;

	printf("请输入三个整数：");
	i = scanf_s("%d%d%d", &a, &b, &c);

	printf("你输入的整数是：a=%d,b=%d,c=%d\n", a, b, c);
	printf("你一共输入了%d个有效数据\n", i);

	return 0;

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5FLjoyJv-1631880972611)(…/…/AppData/Roaming/Typora/typora-user-images/image-20210716152253489.png)]

4.3 其他常用输入/输出函数

4.3.1 getchar()函数

getchar()函数的功能是接收键盘输入的一个字符。函数原型如下：

int getchar(void);

该函数不需要任何的参数，从输入缓冲区中获取一个字符，并将其ASCII码作为返回值。通常定义一个字符变量来接收getchar()函数的返回值，例如：

char c;
c = getchar();

提示：当调用getchar()函数时，程序就等待用户输入字符，用户输入的字符被存放在输入缓冲区中，直到用户按回车键才结束。

getchar()函数返回用户输入的第一个字符的ASCII码，若执行过程中出错，则该函数返回-1，且将用户输入的字符返回到屏幕上。如果用户在按回车键之前输入了不止一个字符，那么其他的字符会保留在输入缓冲区，供后续函数读取。也就是说，当输入缓冲区中有未被读取完的字符时，后续的函数将不会等待用户输入字符，而直接读取输入缓冲区中的字符，直到输入缓冲区中的字符被读取完，才等待用户输入字符。

例如下面这个程序，等待用户输入字符，按回车键后在显示一个字符。若用户输入多个字符，则也只是显示一个字符。

#include<stdio.h>

int main()
{
	char c;

	printf("输入一个字符：");
	c = getchar();

	printf("你输入的字符是：%c\n", c);
	return 0;
}

4.3.2 getch()函数

getch()函数与getchar()函数的功能基本相同，都是接收用户输入的一个字符。其函数原型如下：

int getch(void);

提示：getch()函数直接从键盘获取键值，不等待用户按回车键，只要用户输入一个键，getch()函数就立刻返回。

getch()函数的返回值是用户输入的ASCII码，出错则返回-1。

使用getch()函数输入的字符不会显示在屏幕上。因此getch()函数常用与程序调试，在调试中，在关键位置显示有关结果以待查看，然后调用getch()函数暂停程序运行，当按任意键后程序继续运行。

注意：getchar()函数的原型位于stdio.h中，而getch()函数的原型位于conio.h头文件中。

#include<stdio.h>
#include<conio.h>

int main()
{
	char c;

	printf("按任意键继续\n");
	c = _getch();

	printf("按下的键是%c\n", c);
	return 0;
}

在vs2019中，getch()使用报错，此段代码中使用_getch()替代了getch()。

4.3.3 gets()函数

gets()函数用来从输入缓冲区中读取字符串，直至接收到换行符时停止，并将读取的结果存放到str指针所指向的字符数组中。换行符不作为读取字符串的内容，读取的换行符被转换为null值，并由此来结束字符串。其函数原型如下：

char *gets(char *string);

函数的参数string可以是一个字符指针或一个字符数组。如果是字符数组，则应该确保string的空间足够大，以便在执行读操作的时候发生溢出。

#include<stdio.h>

int main()
{
	char string[80];

	printf("请输入一个字符串：");
	gets(string);

	printf("输入的字符串是：%s\n", string);
	return 0;
}

用scanf函数的格式字符%s也可以接收用户输入的字符串。但是，如果输入的字符串中包含空格，则scanf()函数将只能接收到空格之前的数据，空格后的数据仍将保留在输入缓冲区中，而gets()函数将接收全部的数据保存到字符数组中。

提示：一般接收用户输入的字符串时，使用gets()函数更好。

4.3.4 putch()函数

putch()函数用于向屏幕中输出字符，其函数原型包含中conio.h头文件中，具体格式如下：

int putch(int ch);

例如：下面的语句输出小写字母a：

putch('a');

而下面的语句输出字符变量c所保存的字符：

putch(c);

使用putch()函数还可以输出控制字符(执行控制功能)。下面的语句执行换行操作

putch('\n');

对于控制字符，putch()函数将执行控制功能，不在屏幕上显示。例如。下面的程序使用多个putch()函数输出一个字符串：

#include<stdio.h>

int main()
{
	char c1 = 'G', c2 = 'o', c3 = 'o', c4 = 'd';

	putch(c1);
	putch(c2);
	putch(c3);
	putch(c4);

	return 0;
}

提示：在stdio.h头文件中还有一个putchar()的函数，也可以用来向屏幕输出一个字符，其在使用上与putch()函数没有什么区别。

4.3.4 puts()函数

puts()函数用来输出一个字符串到屏幕上，使用与printf()函数的格式字符%s完成相同的功能。其函数原型如下：

int puts(char *string);

与gets()函数类似，参数string可为字符数组或字符指针。

#include<stdio.h>

int main()
{
	char str[80];

	printf("请输入一个字符串：");
	gets(str);

	puts("输入的字符串是：");
	puts(str);
	return 0;
}

一个经常容易犯的错如下：

char c='w';
puts(c);

警告：在上面的程序中，打算使用puts()函数输出字符变量c的值。当运行上面的代码时，程序将出现错误。这是因为字符串必须以结束字符’\0’作为结束标志，而字符变量c只包含一个字符，没有结束标志，所以不能使用puts()函数来输出。

4.4 拓展训练

4.4.1 鸡兔同笼问题

鸡兔同笼问题：鸡、兔子关在同一只笼子里面，该笼中有35个头、94只脚，要求编程求出[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dZ2ME1AZ-1631880972613)(file:///C:\Users\26217\AppData\Local\Temp\SGPicFaceTpBq\2440\01906D56.png)]和[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5x4DogJB-1631880972614)(file:///C:\Users\26217\AppData\Local\Temp\SGPicFaceTpBq\2440\01909B0D.png)]各有多少只。

#include<stdio.h>

int main()
{
	int head = 35, feet = 94;
	int Chicken, Rabbit;

	Chicken = (4 * head - feet) / 2;
	Rabbit = (feet - 2 * head) / 2;

	printf("Chicken=%d,Rabbit=%d\n", Chicken, Rabbit);
	return 0;
}

4.4.2 格式化输入

格式化输入/输出函数的使用：从键盘输入圆柱体的底面半径和高，求圆柱体的体积。

#include<stdio.h>

int main()
{
	float r, h, V;

	printf("请输入圆柱体的底面半径：");
	scanf_s("%f", &r);
	printf("请输入圆柱体的高：");
	scanf_s("%f", &h);

	V = 3.14 * r * r * h;
	printf("圆柱体的体积为：%f\n", V);

	return 0;
}

4.4.3 输入两个变量的值，交换输出

#include<stdio.h>

int main()
{
	int a, b, temp;

	printf("请输入两个数：");
	scanf_s("%d%d", &a, &b);
	printf("交换之前两个变量的值为：a=%d,b=%d\n", a, b);
	temp = a;
	a = b;
	b = temp;
	printf("交换之后两个变量的值为：a=%d,b=%d\n", a, b);
	return 0;
}

4.4.4 大小写字母转换器

将键盘输入的小写字母转换为大写字母，并将其输出至屏幕。

分析：字符A_{Z的ASCII码值为65}90，字符a_{z的ASCII码值为97}122。

#include<stdio.h>

int main()
{
	char c;
	int a;
	printf("请输入一个小写字符：");
	scanf_s("%c", &c);
	a = c - 32;
	printf("字符%c对应的大写字母是%c\n", c, a);
	return 0;
}

5. 程序的三大流程控制结构

5.1 顺序结构

顺序结构的程序流程设计是最简单的，只需要按照解决问题的顺序写出相应的语句即可，它的执行顺序是自上而下、依次执行。

顺序结构就是一条一条地从上到下执行语句，它会执行所有语句，而且只要是已经执行过的语句就不会再次执行。

顺序结构就行工厂流水线一样，不需要条件的判断，只会顺序执行。

5.2 条件语句

在前面的程序中，所有程序都是按语句在源代码中排列顺序执行的，写在前面的语句先执行，写在后面的语句后执行。在很多情况下，需要根据用户输入的值决定执行程序的哪一部分，而跳过另一部分，这样的程序结构被称为分支结构

C语言提供了if语句和switch语句来完成这样的功能，他们可以根据条件判断的结果选择所要执行的程序语句。它们就像程序的运行铁路上不同的岔路口，前进的方向是多样的，通过设定条件，在执行程序的时候便可以按照我们设想的方向运行。

5.2.1 if语句

C语言最常用的分支语句就是if语句，它根据给定的表达式的值进行判断，以决定执行某个分支程序段。

if语句的基本语法格式如下：

if (表达式) 语句:

以上语句的含义是：如果表达式的值为真，则执行其后面的语句；否则不执行该语句。

注意：if关键字后面的表达式通常是逻辑表达式或关系表达式，也可以是其他表达式，如赋值表达式，甚至可以是一个变量。

在if语句中，表达式即使是一个变量也必须用括号括起来。又来括号作为分隔符，if关键字与括号之间可以使用空格间隔，也可以不输入空格分隔。表达式与后面的语句之间的间隔与此类似，例如，以下两行语句都是正确的：

if(max<j)max=j;
if (max<j) max=j;

以上两种书写方式都没有语法错误，建议使用后一种方式，使程序的格式更规范。

用if语句求最大值：

#include<stdio.h>

int main()
{
	int i, j, max;

	printf("请输入两个整数：");
	scanf_s("%d %d", &i, &j);

	max = i;
	if (max < j) max = j;
	printf("你输入的数是%d和%d，最大值是%d\n", i, j, max);
	return 0;
}

上面程序的if语句表达式后面是一条语句，在更多情况下，当表达式的值为true时，需要执行读条语句，这时就需要使用代码块。

#include<stdio.h>

int main()
{
	int i, j, temp;

	printf("请输入两个整数：");
	scanf_s("%d %d", &i, &j);

	if (i > j)
	{
		temp = i;
		i = j;
		j = temp;
	}
	printf("你输入的数字从小到大的排序为%d %d\n", i, j);
	return 0;
}

5.2.2 if-else语句

5.2.1介绍的if语句在表达式的值为true时，先执行其后的语句或语句块，然后执行后面的语句，若表达式的值为false，则跳过其后面的语句或语句块，直接执行后面的语句，在更多的时候，针对表达式的值为true或flase的情况，需要先分别执行不同的语句，然后再执行后面的代码。这时，可以使用if-else语句，语法格式如下：

if (表达式) 语句1;
else 语句2;

以上的语句的含义是：如果表达式的值为true，则执行语句1，否则执行语句2。

通过if-else语句可以更方便的对条件进行处理。例如使用if-else语句对上面if语句的排程序进行修改：

#include<stdio.h>

int main()
{
	int i, j;

	printf("请输入两个整数：");
	scanf_s("%d %d", &i, &j);

	if (i>j)
		printf("你输入的数字从小到大的排序为%d %d\n", j, i);
	else
		printf("你输入的数字从小到大的排序为%d %d\n", i, j);

	return 0;
}

5.2.3 if-else-if语句

在5.2.2中使用了if嵌套的范式进行多个不同条件的组合。但如果嵌套的层次太多，则在代码执行的时候很容易出错。对于多个分支结构的情况，可以使用if-else-if语句。

使用前面介绍的if语句，主要用于处理两个分支结构的情况。使用嵌套形式也可以处理多个分支结构。C语言中专门提供了处理多个分支的if-else-if语句(此外还有一个switch语句也可以处理多个分支结构)，表达式如下：

if (表达式1)
    语句1;
else if (表达2)
    语句2;
else if (表达式3)
    语句3;
...
    ...;
else if (表达式n)
    语句n;
else
    语句z；

其执行过程是：从上到下依次判断各表达式的值，当某个表达式的值为true时，则执行其对应的语句，然后跳到整个if-else-if语句之外继续执行程序；如果所有表达式的值都为false，则执行语句z，然后继续执行后续语句。

下面的例子检查用户输入的字符是大写字母、小写字母、数字还是其他字符。用户的输入有四种可能，可以通过字符的ASCII码值进行判断，确定输入字符属于哪种类型。

#include<stdio.h>

int main()
{
	char c;
	
	printf("请输入一个字符：");
	scanf_s("%c", &c);

	if (c >= 65 && c <= 90)
		printf("你输入的是大写字母%c\n",c);
	else if (c >= 97 && c <= 122)
		printf("你输入的是小写字母%c\n",c);
	else if (c >= 48 && c <= 57)
		printf("你输入的是数字%c\n",c);
	else
		printf("你输入的是其他字符%c",c);

	return 0;

}

5.2.4 if语句的嵌套

使用if-else语句语句可以处理有两个分支结构的情况，如果有多个分支结构要处理，就需要使用if语句的嵌套格式。

所谓嵌套，就是在if语句后面执行的语句中又包含if语句。if语句嵌套的一般形式表示如下：

if (表达式1)
{
    if (表达式2) 语句1;
}
else
    if (表达式3) 语句2;

在更加复杂的情况下，在嵌套内的语句又是if-else语句，其结构如下：

if (表达式1)
{
    if (表达式2) 语句1;
	else 语句2;
}
else
    if (表达式3) 语句3;
	else 语句4;

接下来是一个复杂的例子。用户输入3个整数，使用if嵌套的方式对这3个数进行排序，并按从大到下的书序输出。

用户输入3个数字有6种组合：

• 大、中、小
• 大、小、中
• 中、小、大
• 中、大、小
• 小、中、大
• 小、大、中

假设输入的3个整数分别保存在3个变量a、b、c中，使用if嵌套分别判断两个数的大小，的到以上6种组合。

#include<stdio.h>

int main()
{
	int a,b,c;

	printf("请输入3个整数：");
	scanf_s("%d %d %d", &a, &b, &c);

	if (a > b)
		if (b > c)
			printf("%d,%d,%d\n", a, b, c);
		else
			if (a>c)
				printf("%d,%d,%d\n", a, c, b);
			else
				printf("%d,%d,%d\n", c, a, b);
	else
		if (b<c)
			printf("%d,%d,%d\n", c, b, a);
		else 
			if (c>a)
				printf("%d,%d,%d\n", b, c, a);
			else
				printf("%d,%d,%d\n", b, a, c);

	return 0;
}

编译以上程序，输入之前分析的6种输入数据组合，可以看到最后都是输出从大到小排列的3个数据。

以上程序主要为了演示if嵌套语句而编写。在实际过程中，使用一个中间变量对数据进行交换即可，可以很简单的完成以上程序。

#include<stdio.h>

int main()
{
	int a, b, c, temp;

	printf("请输入3个整数：");
	scanf_s("%d %d %d", &a, &b, &c);

	if (a < b)
	{
		temp = a;
		a = b;
		b = temp;
	}
	if (a < c)
	{
		temp = a;
		a = c;
		c = temp;
	}
	if (b < c)
	{
		temp = b;
		b = c;
		c = temp;
	}

	printf("%d > %d > %d\n", a, b, c);

	return 0;
}

提示：以上程序中，也可以将每个语句块中的3条交换数据的语句写在同一行。

5.2.5 布尔表达式

等式是最简单的布尔表达式。这种布尔表达式用于测量两个值是否相等。

布尔表达式是逻辑运算符和布尔运算量按照一定语法规则组成的式子。逻辑运算符通常有与、或、非。在某些语言中，还包括等价(≡)以及蕴含(→)等。

逻辑运算对象可以是逻辑值(true或false)、布尔变量、关系表达式以及由括号括起来的的布尔表达式。

不论是布尔变量或是布尔表达式，都只能去逻辑值true或false。在计算机内真值通常用1来表示，假值通常用0来表示。

关系表达式是形如E1 Rop E2的式子，其中E1、E2为简单算术表达式。Rop为关系表达运算符(<、>、=、<=、>=等等)。若E1和E2的值使该关系式成立，则此关系表达式的值为true，否则为false。

5.2.6 增强后的switch分支语句

一般的if语句只有两个分支可供选择，而实际工作中常常要用到多个分支的选择。使用if-else-if语句也可以处理多个分支的情况，但是多数情况下，使用switch语句处理多个分支更加的方便。

switch语句就像许多扇大门一样，上面标注了符合什么条件才能通过。

使用switch语句可以方便处理同一表达式有多个分支的情况。语法格式如下：

switch (表达式)
{
    case 常量表达式1:
        语句1;
        break;
    case 常量表达式2:
        语句2;
        break;
        ...
    case 常量表达式m:
        语句m;
        break;
    default:
        语句n;
}

其执行过程为：首先计算表达式的值，然后将该值与后面的每个case关键字的常量表达式进行比较，当表达式的值与某个常量表达式的值相等时，即执行其后的语句，然后不再进行判断，继续执行所以case后的语句，直到遇到break语句后退出switch语句。如果表达式的值与所有case后的常量表达式都不等，则执行default后的语句。

switch语句主要应用在同一个表达式有多个分支的情况下。

注意：

• switch关键字后面括号里面的表达式的值必须为整型，不能为实型。

• 每个case关键字的常量表达式后面都添加冒号。

• case关键字后面的值可以是常量，也可以是常量表达式，但表达式中不能有变量。因为case关键字后面的值必须在编译阶段被确定。

• 每个case后的常量表达式值要与switch后面括号内的表达式中的类型一直，且各个case后的常量表达式必须各不相同，否则会出现执行两个分支的矛盾。

• 执行完一个case后面的语句后，看流程控制转移到下一个case继续执行。"case常量表达式"只起语句标号作用，并不是该处进行条件判断。因此，如果在执行完当前case语句后需要跳到switch语句后执行，就需要在case分支的最后加上一条break语句。

• default分支可以省略。如果省略这个分支，则当所有常量表达式与switch后面括号中的表达式值不相等时，switch结构中将没有语句可以执行。

#include<stdio.h>

int main()
{
	int w;

	printf("请输入1个整数：");
	scanf_s("%d", &w);

	switch (w)
	{
	case 0:
		printf("星期日\n");
		break;
	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;
	default:
		printf("输入0-6之间的数字");
	}

	return 0;

}

从以上程序可以看出，与if语句不同，在case后面虽然可以执行很多条语句，但可以不用大括号将这些语句括起来组成语句块，程序会自动顺序执行case语句后面所有的执行语句。这是因为，在switch结构中，每个case相当于一个标号，标号后面可以有很多语句，程序会自动执行这些语句，直到语句break语句才跳出switch结构。

对于switch结构中的最后一个分支，可以不用加break语句。当执行到最后一个分支后，按顺序本来就应该执行switch结构后面的一条语句。当然最后一个分支加上一个break语句也是正确的。

5.3 循环语句

5.3.1 while循环结构

while语句可用于实现入口条件循环，即当循环条件满足时执行循环体内的语句。这是C语言中常用的循环语句之一。

while语句的语法格式很简单，一般形式为：

while (表达式)
    语句;

其中表达式就是循环条件，语句为循环体。

在C语言中，循环条件非常灵活，可以是各种表达式，并不仅限于条件表达式或逻辑表达式，只要表达式的返回值为非0，即认为循环条件为true；表达式的返回值为0，即认为循环条件为false，结束循环。

提示：循环体可以是一条语句，也可以是多条语句。如果是多条语句，则需要使用大括号{}将这些语句括起来，作为一个语句块。

#include<stdio.h>

int main()
{
	int i, n, sum;

	printf("请输入一个整数：");
	scanf_s("%d", &n);

	sum = 0;
	i = 1;

	while (i <= n)
	{
		sum += i;
		i++;
	}

	printf("从1到%d所有自然数之和为%d\n", n, sum);

	return 0;
}

警告：循环条件一定要设置无误，否则程序进入死循环，无法停止。

1. 使用复合语句

在while结构中，循环体可以是一条单独的语句，也可以是一个语句块。

当循环体一条单独的语句时，循环执行的过程不容易出现问题。例如：

while (i)
    printf("执行循环体，变量的值为%d\n",i--);

当i的值不为0的时候，将执行循环体。

当循环体有多条语句的时候，例如：将上面程序的中的循环体拆分为两条语句，写成如下形式：

while (i)
    printf("执行循环体，变量的值为%d\n",i);
	i--;

从书写程序的缩进表示理解，以上3条语句是希望i的值大于0的时候，执行printf()函数输出i的值，再让变量i自减1，然后返回while循环判断是否继续执行循环体。

但是，C编译器将忽略所有空白字符，也就是说，编译器不会按照用户缩进的格式来决定程序执行，只会通过分号来确定语句，缩进只是写给程序员看的。

实际情况是，在以上3行代码中，循环体只是第2行语句，因此第1、2行语句将构成一个死循环，执行printf()函数输出变量i的值，然后又返回第1行用while循环判断条件，第3行语句将不会被执行。

因此，只要循环体中有两条或两条以上一句，必须使用大括号{}将这些语句括起来，构成一条复合语句。当然，只有一条语句也是可以使用大括号将该语句括起来。

2. 空循环体

在while结构中还需要注意分号的用法。例如，有以下循环语句：

while (i--) ;
    sum += i;

在第1行while最后有一个分号，表示while语句语句结束，其循环体为一条空语句，不会将第2行作为循环体。

其实，while语句本身在语法上是作为一条单独的语句，由while判断循环条件和一个循环体组成。对于当行循环体，从while开始，到第一个分号结束为一条语句；对于一个复合语句循环体，从while开始，到复合语句终结的大括号为一条语句。这样就不难理解以上的程序了。

因为C语言的灵活性，所以在while的循环条件表达式中可以完成很多的工作，如将循环体内的语句写到此处，循环体无语句可写，就可以使用一条空语句。例如：

while (sum += i,i--);

在循环条件表达式中使用了一个逗号表达式，逗号表达式从左到右的顺序计算，返回最右侧的值。因此，以上代码现将变量i累加到sum中，再执行i自减1的操作。整个逗号表达式的返回值就是变量i的值，当i等于0时，循环结束。

3. 入口条件循环

此处介绍的while的入口条件循环，即先判断条件，再根据条件决定是否执行循环。例如：

i = 10;

while (i<10)
{
    sum += i;
    i++;
}

在以上代码中，因进入循环测试时，循环的条件为false，所以循环体一次都不执行。

4. 循环条件表达式

因为C语言的灵活性，在while语句的循环条件中，还可以使用赋值表达式，例如：

while (i=1)

在以上语句中，循环条件表达式是一个赋值表达式，将常量1赋值给变量i，同时表达式的值也是1，就与while(1)的意义不同了。

以上语句要与以下语句区分开：

while (i==1)

5.3.2 do-while循环结构

while语句是在循环前判断条件，就像火车选择铁路一样，只有符合路线要求的火车才能进入铁路，而while语句也只有满足条件才能进入循环体。如果一开始条件就不满足，那么循环体一次也不被执行。

而do-while语句适合先循环，然后在循环过程中产生控制条件，第一次循环结束后，再判断条件，以决定是否进行下一次循环。

下面看一个while循环显示菜单的例子：

#include<stdio.h>

int main()
{
    int i;

    printf("1.录入数据\n");
    printf("2.查询资料\n");
    printf("3.输出资料\n");
    printf("0.退出系统\n");
    scanf_s("%d", &i);

    while (i)
    {
        switch (i)
        {
        case 1:
            printf("调用录入数据函数\n\n");
            break;
        case 2:
            printf("调用查询资料函数\n\n");
            break;
        case 3:
            printf("调用输出资料函数\n\n");
            break;
        default:
            printf("输入错误，请选择对应的菜单\n");
            break;
        }

        printf("1.录入数据\n");
        printf("2.查询资料\n");
        printf("3.输出资料\n");
        printf("0.退出系统\n");
        scanf_s("%d", &i);
    }

    return 0;
}

do-while语句先执行循环体，再判断循环条件，其语法格式如下：

do
    语句;
while(表达式);

其中语句是循环体。如果循环体内有多条语句，则需要将这些语句用大括号{}括起来，组成一条复合语句。while后面的表达式是循环条件。

注意：while(表达式)后面必须有一个分号。

do-while语句和while语句的区别在于：do-while语句是先执行后判断，因此do-while语句至少要执行一次循环体；而while语句是先判断后执行，如果条件不满足，则循环体语句一次也不执行。

使用do-while语句改写while语句编写的菜单显示程序如下：

#include<stdio.h>

int main()
{
	int i;

	do
	{
		printf("1.录入数据\n");
		printf("2.查询资料\n");
		printf("3.输出资料\n");
		printf("0.退出系统\n");
		scanf_s("%d", &i);

		switch (i)
		{
		case 0:
			printf("退出系统");
			break;
		case 1:
			printf("调用录入数据函数\n\n");
			break;
		case 2:
			printf("调用查询资料函数\n\n");
			break;
		case 3:
			printf("调用输出资料函数\n\n");
			break;
		default:
			printf("输入错误，请选择对应的菜单\n");
			break;
		}
	} while (i);

	return 0;
}

从以上程序可以看出，使用do-while语句可以节约重复显示的语句，使程序更加简洁。

在do-while循环中，循环体至少要执行一次：而在while和for循环中，循环体可能一次也不执行。除此以外，do-while语句还应注意以下几点：

• 在if语句、while语句中，在表达式后面都不能加分号；而在do-while语句的表达式后面必须加分号，表示该语句的结束。
• 在do和while之间的循环体由多条语组成时，也必须使用大括号括起来组成一条复合语句。

5.3.3 for循环结构

各种高级程序设计语言都提供有for语句(或类似的语句)，但都没有C语言中for语句灵活。C语言中的for语句可有各种各样的用法，下面列出常用的使用样式。

1. 省略初始代码

for语句的“表达式1”用来初始化变量，也可以在表达式中使用逗号表达式来完成多个变量的初始化。

如果在进入for语句之前，各变量已初始化，则在for语句中和可以省略"表达式1"。但是，用来分隔的分号不能省略。例如，以下程序用来计算自然数的一个连续区间内的各数的平方，要求用户输入连续区间的起始数和终止数。

#include<stdio.h>

int main()
{
	int i, j;

	printf("请输入起始数和终止数：");
	scanf_s("%d %d", &i, &j);

	for (; i <= j; i++)
		printf("%d的平方是%d\n", i, i * i);

	return 0;
}

2. 省略判断代码

for语句的“表达式2”作为循环的入口判断条件，决定是否执行循环体。按一般的理解，该表达式是必须给出的，但C语言中规定该表达式也可以省略。如果省略该表达式，则for认为其值为1，与使用while(1)相似，构成一个死循环。例如，以下代码将一直在屏幕上显示信息，直到用户强行终止才结束。

for(i=1;;i++)
    printf("死循环，一直打印这条信息");

在以上程序中，for语句的初始化部分后面跟两个分号，省略了判断部分，此时无论初始化部分和修改部分写的是什么语句，以上程序都是一个死循环。更常见的用for写的死循环就是3个表达式全部省略，如下：

for(;;)
    printf("死循环，一直打印这条信息");

注意：for语句中的两个分号不能省略。

3. 省略修改代码

for语句的“表达式3”用来修改计数器，使判断部分的值在一定条件下能为false，以便退出循环。如果for语句中省略该代码，则需要在循环中修改计数器的值，例如：

for(i=1;i<j;)
{
    printf("%d的平方是%d",i,i*i);
    i++;
}

当然，这种写法就无法体现for语句的简介性，所以很少使用这种方法，而以下的表示方法在C语言中更加常见：

for(i=1;i<j;)
    printf("%d的平方是%d",i++,i*i);

4. 只有判断代码

如果for语句中只写出判断部分的代码，则和while语句的功能完全相同。例如：

i=1;
for(;i<10;)
    sum+=i++;

改写为while格式如下：

i=1;
while(i<10)
    sum+=i++;

5. 循环变量递增方式

在省略初始代码的的程序中，for语句的表达式3为依次递增，最终使表达式2的值变为false，退出循环。也可对表达式3使用递减运算，修改程序代码如下：

for(sum=0,i=n;i>0;i--)

程序依然可以得到正确的结果。

在上面的语句中，for语句的表达式1将变量i的值初始化为累加的最大值n，在表达式3中对变量i进行递减，当变量i的值递减到0时，结束循环。与while语句后的表达式类似，若变量i为0时退出循环。也可以在表达式2中直接写上变量。因此以上语句还可以写成以下形式：

for(sum=0,i=n;i;i--)

因为for修改循环变量的表达式3为一个表达式，因此，可以灵活地修改计数器每次的增量，如下代码使循环变量每次增2，可对奇数或偶数进行累加求和。

for(sum=0,i=1;i>=n;i+=2)
    sum+=i;

同理还可以是计数器每次变动一个比率。比如，计算投资100万元，按年收益12%计算，多少年能达到1000万元，可以用以下代码来实现。

#include<stdio.h>

int main()
{
    float s;
    int i = 1;
    
    for(s=100.0;s<=1000.0;s=s*1.12,i++)
        printf("第%d年收益为%.2f\n", i, s);
    
    return 0;
}

6. 将循环体语句写到for语句中

将上面这个程序的第9行代码改写成如下样式：

for(s=100.0;printf("第%d年收益为%.2f\n", i, s), s<=1000.0;s=s*1.12,i++)

提示：与while语句相似，也可以将循环体语句写到for语句中，从而使循环体变为一条空语句。

在C语言中，保存字符时是保存该字符的ASCII码值，所以可以将字符作为整型数据处理。因此在循环中，也可以使用字符变量作为循环变量。例如以下程序可以输出指定两个字符之间的所有字符：

#include<stdio.h>
#define _CRT_SECURE_NO_WARNINGS

int main()
{
	char c, d;

	printf("请输入起始字符和结束字符：");
	c = getchar();
	d = getchar();

	printf("%c\n", c);
	printf("%c\n", d);

	printf("在ASCII码表中，字符%c和%c之间所有字符如下：\n", c, d);
	for (; c <= d; c++)
	{
		printf("%c", c);
	}

	return 0;
}

用for循环输出ASCII码表：

#include<stdio.h>

int main()
{
	char c;
	int i;

	printf("ASCII表\n");

	for (c = 32, i = 1; c <= 126; c++, i++)
	{
		printf("%4d %2c", c, c);

		if (i == 9)
		{
			printf("\n");
			i = 0;
		}
	}

	return 0;
}

5.3.4 循环嵌套

分支结构也可以嵌套。即一个分支里面又包含一个分支或多个分支。同样，循环结构也可与支持嵌套，即一个循环里面又包含一个循环，也称为多重循环。前面介绍的3种循环语句，每种循环体部分都可以再含有循环语句，所以编写多重循环的程序很简单。

下面是一个例子，要求编写程序输出3行星号，每行20个。

看到这个要求，首先是想到就是使用3个printf()函数分别输出，每个printf()里面20个星号，并换行。

printf("********************\n");
printf("********************\n");
printf("********************\n");

以上的程序可以完成例子中所提出的要求。但是如果对程序的要求进行改变，如果要求输出50个星号，一共输出20行，就需要对以上代码进行大幅度修改，相当于重写代码。因此，使用循环编写以上程序应该是最好的办法。首先想到使用循环输出每一行的星号。例如：

#define COL 20

for(i=1;i<=COL;i++)
{
    printf("*");
}
printf("\n");

以上程序定义每一行输出的星号的数量，下面3行完成输出一行星号的过程。

将以上程序的3-7行重复出入3次就能完成3行星号的输出。如果想要输出50行星号，则将第3-7行重复输入五十次，这样显然是不太理想的。这时就又可以考虑到循环的使用了。

假设有一段程序能够在每一行输出规定的星号，则使用以下程序来输出指定行的星号：

#define ROW 50

for(j=1;j<=ROW;j++)
{	
	for(i=1;i<=COL;i++)
	{
    	printf("*");
	}
	printf("\n");
}

以上程序并不难理解，但上面的代码要真正的执行，需要将第4行代码进行替换。替换的代码如下：

#define ROW 50
#define COL 20

for(j=1;j<=ROW;j++)
{
	输出第j行;
}

对以上程序进行修改，让用户在程序运行时控制每行星号的数量，以及输出显示多少行，程序如下：

#include<stdio.h>

int main()
{
	int r, c, i, j;

	printf("输入每行星星的数量：");
	scanf_s("%d", &c);
	printf("输入行数：");
	scanf_s("%d", &r);

	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++) {
			printf("*");
		}
		printf("\n");
	}

	return 0;
}

循环嵌套的层数是任意的，按照嵌套的层数可以分别叫做双重循环、三重循环、四重循环等。

在多重循环中，处于内部的循环叫做内循环，处于外部的叫做外循环。内循环和外循环可以分别为不同的循环语句。例如：

for()
{
    语句1;
    while()
        语句2;
    语句3;
}

在for循环中嵌入一个while循环。

do
{
    语句1;
    while()
        for()
            语句2;
    语句3;
}

以上程序为一个三重循环，最外层为一个do-while循环，里面为一个while循环和一个for循环。

通常双重循环用的比较多。例如用外循环来控制按行显示数据，用内循环处理每一行的所有列。小学生用的九九乘法表也可以用双重循环来输出，如下程序：

#include<stdio.h>

int main()
{
	int i, j;

	for (i = 1; i <= 9; i++)
	{
		for (j = 1; j <= i; j++)
		{
			printf("%d * %d = %-2d ", j, i, i * j);
		}
		printf("\n");
	}
	return 0;
}

再看一个经典的百钱白鸡问题。中国古代数学家张丘建在他的《算经》中提出了著名的百钱买百鸡问题：公鸡一只价钱为5钱，母鸡一只价钱为3钱，小鸡三只价钱为1钱，用100钱能买多少公鸡、母鸡、小鸡各多少只？

#include<stdio.h>

int main()
{
	int x, y, z;

	for (x = 0; x <= 100; x++)
	{
		for (y = 0; y <= 100; y++)
		{
			for (z = 0; z <= 100; z++)
			{
				if (z % 3 == 0 && x + y + z == 100 && 5 * x + 3 * y + z / 3 == 100)
					printf("公鸡：%d,母鸡：%d,小鸡：%d\n", x, y, z);
			}
		}
	}
	return 0;
}

#include<stdio.h>

int main()
{
	int x, y, z;

	for (x = 0; x <= 12; x+=4)
	{
		y = 25 - (x / 4) * 7;
		z = 100 - x - y;
		printf("公鸡：%d,母鸡：%d,小鸡：%d\n", x, y, z);
	}
	return 0;
}

由以上两个程序可知，在循环嵌套中，尽量减少嵌套的层数，可提高程序的效率。但是由于计算机的运行速度越来越快，程序员也应该注意不要过度追求程序效率，而使程序很难懂。例如，将程序改写成上面第二个程序的形式，虽然也能得到正确的结果，并且只有一层循环，但是看着这个程序能轻松的弄懂其算法吗。

5.4 转向语句

循环语句就像一个圈，，如果没有一个退破口，程序就容易进入死循环，所以我们需要一些语句来跳出循环。对于3种循环语句，C语言都提供了退出循环或短路U型能换的break语句和continue语句。

5.4.1 break中断语句

break语句在switch结构中使用过，用来中断分支的执行，跳到switch的最后一条语句执行。

当循环结构中使用break语句后，可使程序终止循环而执行循环后面的语句。通常break语句和if语句连在一起，即满足条件便跳出循环。

注意：对于多重循环嵌套，使用break语句只能跳出当前循环，而不会跳出所有外层循环。

在某些特殊情况下，需要创建一个死循环结构，这时可能在该结构内部添加break语句，用来跳出该死循环。例如，以下程序要求用户输入多个数据，程序对这些数据进行累加，并输出累加结果。

#include<stdio.h>

int main()
{
	float n, sum = 0;
	int i = 0;

	do
	{
		printf("请输入累加的数(若为0，则完成累加)：");
		scanf_s("%f", &n);
		if (n == 0)
			break;
		i++;
		sum += n;
	} while (1);
	printf("\n你输入了%d个数，所有数之和为：%.2f\n", i, sum);

	return 0;
}

以上程序中，因为不知道用户输入的数据的数量，所以使用了一个do-while的死循环。在死循环中若不设置退出条件，程序将一直循环：若用户强行中断程序的运行，便不能执行第17行的代码输出运行结果。

注意：在死循环结构中都必须设置退出条件。在上面程序中第12、13行对用户输入的数据进行判断，若用户输入的数据为0，则执行break语句跳出循环，转到第17行执行输出操作。

5.4.2 continue条件继续语句

使用break语句可跳出循环，而continue语句的作用则是跳过循环体中剩余的语句，而直接去执行下一次循环。continue语句只能在for、while、do-while等循环体中使用。在循环体中添加break语句后，

例如：对以上break实例程序进行修改，要求只对用户输入的正数进行累加，若用户输入的是负数，则不累加。同样，若用户输入的值为0，则跳出循环，输出累加结果。

#include<stdio.h>

int main()
{
	float n, sum = 0;
	int i = 0;

	do
	{
		printf("请输入累加的数：");
		scanf_s("%f", &n);

		if (n < 0)
			continue;
		if (n == 0)
			break;
		i++;
		sum += n;
	} while (1);
	printf("\n你输入了%d个正数，所有正数之和为：%.2f\n", i, sum);

	return 0;
}

编译运行以上程序，按提示随机输入正数、负数，最后输入0。根据最后的结果可以看出，所输入的复数都被放弃了，程序只统计了用户输入的正数的数量，只累加正数的值。

5.4.3 标签语句

goto语句的语义是改变程序流向，转去执行标号所标识的语句。它通常与条件语句配合使用，可用来实现条件转移、构成循环、跳出循环体等功能。

goto 语句标号;

其中语句标号是按标识符规定书写的符号，放在某一语句行的前面，标号后面加冒号。语句标号起标识语句的作用，与goto语句配合使用。

提示：在switch结构中，case关键字后面就是的常量就是一个标号。

在程序中定义标号的时候，整个程序的标号不能重复。例如：

loop1: if(i<=n)
labe1: sum+=1;

以上两条语句分别为两行程序定义标号，使goto语句能够跳转到该行程序处执行。

不使用for、while、或do-while语句，只使用goto语句也可以构造循环结构。例如：使用goto语句改写之前的程序，累加自然数之和。

#include<stdio.h>

int main()
{
	int n, i, sum = 0;

	printf("请输入一个整数：");
	scanf_s("%d", &n);

	i = 1;
loop: if (i <= n)
{
	sum += i;
	i++;
	goto loop;
}
printf("1到%d的所有自然数的和为：%d\n", n, sum);

return 0;
}

在以上程序中，在11行定义了标号之后，在程序的任何位置都能使用goto语句跳转到该行。这样有可能使程序的流程发生混乱，使理解和调试程序都产生困难。因此，建议在程序中不要使用goto语句。在此简单介绍，只是让大家知道C语言提供了此语句，在一些特殊情况下，可以使用goto语句提高程序的效率。例如，在一个很多层循环嵌套的结果中，要直接跳出最外层循环，就要使用goto语句。若使用break语句来退出，因break语句只能跳出所在层的循环，还需要在每层添加条件判断和break语句，比较麻烦。实例代码如下：

for(a=0;a<10;a++){
    for(b=0;b<10;b++){
        for(c=0;c<10;c++){
            for(d=0;d<10;d++){
                for(e=0;e<10'e++){
                    for(f=0;f<10;f++){
                        if(a+b+c+d+e==50)
                            goto end;
                    }
                }
            }
        }
    }
}
end: printf("ok");

这种跳出多重循环的情况下，goto语句的功能是其他语句所不能替代的。

5.5 返回语句

return表示从被函数返回主函数继执行，其返回值是由return后面的参数所决定的。一般来说，返回一个值是必要的操作，因为函数调用的时候计算结果通常是通过返回值带出的。如果函数执行不需要返回计算结果，则也经常返回一个状态码来表示函数执行是否成功，主函数可以通过返回值来判断被调函数是否已经顺利执行。

如果实在不需要返回什么值，就需要用void声明其类型。

还有一点就是，你的函数是什么类型，就需要返回什么类型的值，比如int类型的函数则需要返回int类型的数据。

1. 非void型

int f1()
{
    int i=1;
    return 1;
    //return (i); 这样也可以
}

2.void型

void f2()
{
    int i=1;
    //return;  这样也可以，不要这一句也可以
}

有时计时被调用函数是void类型，被调函数中的return也不是毫无意义的。

例如：

#include<stdio.h>
void function()
{
    printf("1111");
    return;
    printf("2222");
}
main()
{
    function();
}

运行结果为：屏幕上只输出一串数字1而没有2。但是如果去掉function函数中的return语句，就可以同时输出一串2。

这里的return其实还有一个退出该程序的作用。也就是说，在printf(“1111”)后面加一个return，就表示结束该函数，返回主函数。

5.6 拓展训练

5.6.1 水仙花数

水仙花数是指一个三位数中各个位的数值的立方和等于该数。

#include<stdio.h>

int main()
{
	int i, ge, shi, bai;

	for (i = 100; i <= 999; i++)
	{
		ge = i % 100 % 10;
		shi = i % 100 / 10;
		bai = i / 100;

		if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i)
			printf("%d\n", i);
	}
	return 0;
}

5.6.2 工资提成问题

现有一家公司发放的奖金根据年工资提成，其提成规定如下：

• 工资低于或等于3万元，奖金提成%8。
• 工资高于3万元，低于或等于7万元，奖金提成5%。
• 工资高于7万元，低于或等于10万元，奖金提成3%。
• 工资高于10万元，奖金提成1%。

#include<stdio.h>

int main()
{
	long int a;
	int b;

	printf("请输入年工资：");
	scanf_s("%ld", &a);

	if (a <= 30000)
		b = a * 0.08;
	else if (a <= 70000)
		b = a * 0.05;
	else if (a <= 100000)
		b = a * 0.03;
	else if (a > 100000)
		b = a * 0.01;
	else
		printf("输入错误！");

	printf("奖金为%d\n", b);

	return 0;

}