C/C语言.md

第一卷 编程基础

进制详解：二进制、八进制和十六进制

我们平时使用的数字都是由 0~9 共十个数字组成的，例如 1、9、10、297、952 等，一个数字最多能表示九，如果要表示十、十一、二十九、一百等，就需要多个数字组合起来。

例如表示 5+8 的结果，一个数字不够，只能”进位“，用 13 来表示；这时”进一位“相当于十，”进两位“相当于二十。

因为逢十进一（满十进一），也因为只有 0~9 共十个数字，所以叫做十进制（Decimalism）。十进制是在人类社会发展过程中自然形成的，它符合人们的思维习惯，例如人类有十根手指，也有十根脚趾。

进制也就是进位制。进行加法运算时逢X进一（满X进一），进行减法运算时借一当X，这就是X进制，这种进制也就包含X个数字，基数为X。十进制有 0~9 共10个数字，基数为10，在加减法运算中，逢十进一，借一当十。

二进制

我们不妨将思维拓展一下，既然可以用 0~9 共十个数字来表示数值，那么也可以用0、1两个数字来表示数值，这就是二进制（Binary）。例如，数字 0、1、10、111、100、1000001 都是有效的二进制。

在计算机内部，数据都是以二进制的形式存储的，二进制是学习编程必须掌握的基础。本节我们先讲解二进制的概念，下节讲解数据在内存中的存储，让大家学以致用。

二进制加减法和十进制加减法的思想是类似的：

• 对于十进制，进行加法运算时逢十进一，进行减法运算时借一当十；
• 对于二进制，进行加法运算时逢二进一，进行减法运算时借一当二。

下面两张示意图详细演示了二进制加减法的运算过程。

1. 二进制加法：1+0=1、1+1=10、11+10=101、111+111=1110

​ 图1：二进制加法示意图

2. 二进制减法：1-0=1、10-1=1、101-11=10、1100-111=101

​ 图2：二进制减法示意图

八进制

除了二进制，C语言还会使用到八进制。

八进制有 0~7 共8个数字，基数为8，加法运算时逢八进一，减法运算时借一当八。例如，数字 0、1、5、7、14、733、67001、25430 都是有效的八进制。

下面两张图详细演示了八进制加减法的运算过程。

1. 八进制加法：3+4=7、5+6=13、75+42=137、2427+567=3216

​ 图3：八进制加法示意图

2. 八进制减法：6-4=2、52-27=23、307-141=146、7430-1451=5757

​ 图4：八进制减法示意图

十六进制

除了二进制和八进制，十六进制也经常使用，甚至比八进制还要频繁。

十六进制中，用A来表示10，B表示11，C表示12，D表示13，E表示14，F表示15，因此有 0~F 共16个数字，基数为16，加法运算时逢16进1，减法运算时借1当16。例如，数字 0、1、6、9、A、D、F、419、EA32、80A3、BC00 都是有效的十六进制。

注意，十六进制中的字母不区分大小写，ABCDEF 也可以写作 abcdef。

下面两张图详细演示了十六进制加减法的运算过程。

1. 十六进制加法：6+7=D、18+BA=D2、595+792=D27、2F87+F8A=3F11

​ 图5：十六进制加法示意图

2. 十六进制减法：D-3=A、52-2F=23、E07-141=CC6、7CA0-1CB1=5FEF

​ 图6：十六进制减法示意图

进制转换：二进制、八进制、十六进制、十进制之间的转换

上节我们对二进制、八进制和十六进制进行了说明，本节重点讲解不同进制之间的转换，这在编程中经常会用到，尤其是C语言。

将二进制、八进制、十六进制转换为十进制

二进制、八进制和十六进制向十进制转换都非常容易，就是“按权相加”。所谓“权”，也即“位权”。

假设当前数字是 N 进制，那么：

• 对于整数部分，从右往左看，第 i 位的位权等于Ni-1
• 对于小数部分，恰好相反，要从左往右看，第 j 位的位权为N-j。

更加通俗的理解是，假设一个多位数（由多个数字组成的数）某位上的数字是 1，那么它所表示的数值大小就是该位的位权。

1. 整数部分

例如，将八进制数字 53627 转换成十进制：

53627 = 5×84 + 3×83 + 6×82 + 2×81 + 7×80 = 22423（十进制）

从右往左看，第1位的位权为 80=1，第2位的位权为 81=8，第3位的位权为 82=64，第4位的位权为 83=512，第5位的位权为 84=4096 …… 第n位的位权就为 8n-1。将各个位的数字乘以位权，然后再相加，就得到了十进制形式。

注意，这里我们需要以十进制形式来表示位权。

再如，将十六进制数字 9FA8C 转换成十进制：

9FA8C = 9×164 + 15×163 + 10×162 + 8×161 + 12×160 = 653964（十进制）

从右往左看，第1位的位权为 160=1，第2位的位权为 161=16，第3位的位权为 162=256，第4位的位权为 163=4096，第5位的位权为 164=65536 …… 第n位的位权就为 16n-1。将各个位的数字乘以位权，然后再相加，就得到了十进制形式。

将二进制数字转换成十进制也是类似的道理：

11010 = 1×24 + 1×23 + 0×22 + 1×21 + 0×20 = 26（十进制）

从右往左看，第1位的位权为 20=1，第2位的位权为 21=2，第3位的位权为 22=4，第4位的位权为 23=8，第5位的位权为 24=16 …… 第n位的位权就为 2n-1。将各个位的数字乘以位权，然后再相加，就得到了十进制形式。

2) 小数部分

例如，将八进制数字 423.5176 转换成十进制：

423.5176 = 4×82 + 2×81 + 3×80 + 5×8-1 + 1×8-2 + 7×8-3 + 6×8-4 = 275.65576171875（十进制）

小数部分和整数部分相反，要从左往右看，第1位的位权为 8-1=1/8，第2位的位权为 8-2=1/64，第3位的位权为 8-3=1/512，第4位的位权为 8-4=1/4096 …… 第m位的位权就为 8-m。

再如，将二进制数字 1010.1101 转换成十进制：

1010.1101 = 1×23 + 0×22 + 1×21 + 0×20 + 1×2-1 + 1×2-2 + 0×2-3 + 1×2-4 = 10.8125（十进制）

小数部分和整数部分相反，要从左往右看，第1位的位权为 2-1=1/2，第2位的位权为 2-2=1/4，第3位的位权为 2-3=1/8，第4位的位权为 2-4=1/16 …… 第m位的位权就为 2-m。

更多转换成十进制的例子：

• 二进制：1001 = 1×23 + 0×22 + 0×21 + 1×20 = 8 + 0 + 0 + 1 = 9（十进制）
• 二进制：101.1001 = 1×22 + 0×21 + 1×20 + 1×2-1 + 0×2-2 + 0×2-3 + 1×2-4 = 4 + 0 + 1 + 0.5 + 0 + 0 + 0.0625 = 5.5625（十进制）
• 八进制：302 = 3×82 + 0×81 + 2×80 = 192 + 0 + 2 = 194（十进制）
• 八进制：302.46 = 3×82 + 0×81 + 2×80 + 4×8-1 + 6×8-2 = 192 + 0 + 2 + 0.5 + 0.09375= 194.59375（十进制）
• 十六进制：EA7 = 14×162 + 10×161 + 7×160 = 3751（十进制）

将十进制转换为二进制、八进制、十六进制

将十进制转换为其它进制时比较复杂，整数部分和小数部分的算法不一样，下面我们分别讲解。

1) 整数部分

十进制整数转换为 N 进制整数采用“除 N 取余，逆序排列”法。具体做法是：

• 将 N 作为除数，用十进制整数除以 N，可以得到一个商和余数；
• 保留余数，用商继续除以 N，又得到一个新的商和余数；
• 仍然保留余数，用商继续除以 N，还会得到一个新的商和余数；
• ……
• 如此反复进行，每次都保留余数，用商接着除以 N，直到商为 0 时为止。

把先得到的余数作为 N 进制数的低位数字，后得到的余数作为 N 进制数的高位数字，依次排列起来，就得到了 N 进制数字。

下图演示了将十进制数字 36926 转换成八进制的过程：

从图中得知，十进制数字 36926 转换成八进制的结果为 110076。

下图演示了将十进制数字 42 转换成二进制的过程：

从图中得知，十进制数字 42 转换成二进制的结果为 101010。

2) 小数部分

十进制小数转换成 N 进制小数采用“乘 N 取整，顺序排列”法。具体做法是：

• 用 N 乘以十进制小数，可以得到一个积，这个积包含了整数部分和小数部分；
• 将积的整数部分取出，再用 N 乘以余下的小数部分，又得到一个新的积；
• 再将积的整数部分取出，继续用 N 乘以余下的小数部分；
• ……
• 如此反复进行，每次都取出整数部分，用 N 接着乘以小数部分，直到积中的小数部分为 0，或者达到所要求的精度为止。

把取出的整数部分按顺序排列起来，先取出的整数作为 N 进制小数的高位数字，后取出的整数作为低位数字，这样就得到了 N 进制小数。

下图演示了将十进制小数 0.930908203125 转换成八进制小数的过程：

从图中得知，十进制小数 0.930908203125 转换成八进制小数的结果为 0.7345。

下图演示了将十进制小数 0.6875 转换成二进制小数的过程：

从图中得知，十进制小数 0.6875 转换成二进制小数的结果为 0.1011。

如果一个数字既包含了整数部分又包含了小数部分，那么将整数部分和小数部分开，分别按照上面的方法完成转换，然后再合并在一起即可。例如：

• 十进制数字 36926.930908203125 转换成八进制的结果为 110076.7345；
• 十进制数字 42.6875 转换成二进制的结果为 101010.1011。

下表列出了前 17 个十进制整数与二进制、八进制、十六进制的对应关系：

十进制	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
二进制	0	1	10	11	100	101	110	111	1000	1001	1010	1011	1100	1101	1110	1111	10000
八进制	0	1	2	3	4	5	6	7	10	11	12	13	14	15	16	17	20
十六进制	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F	10

注意，十进制小数转换成其他进制小数时，结果有可能是一个无限位的小数。请看下面的例子：

• 十进制 0.51 对应的二进制为 0.100000101000111101011100001010001111010111...，是一个循环小数；
• 十进制 0.72 对应的二进制为 0.1011100001010001111010111000010100011110...，是一个循环小数；
• 十进制 0.625 对应的二进制为 0.101，是一个有限小数。

二进制和八进制、十六进制的转换

其实，任何进制之间的转换都可以使用上面讲到的方法，只不过有时比较麻烦，所以一般针对不同的进制采取不同的方法。将二进制转换为八进制和十六进制时就有非常简洁的方法，反之亦然。

1) 二进制整数和八进制整数之间的转换

二进制整数转换为八进制整数时，每三位二进制数字转换为一位八进制数字，运算的顺序是从低位向高位依次进行，高位不足三位用零补齐。下图演示了如何将二进制整数 1110111100 转换为八进制：

从图中可以看出，二进制整数 1110111100 转换为八进制的结果为 1674。

八进制整数转换为二进制整数时，思路是相反的，每一位八进制数字转换为三位二进制数字，运算的顺序也是从低位向高位依次进行。下图演示了如何将八进制整数 2743 转换为二进制：

从图中可以看出，八进制整数 2743 转换为二进制的结果为 10111100011。

2) 二进制整数和十六进制整数之间的转换

二进制整数转换为十六进制整数时，每四位二进制数字转换为一位十六进制数字，运算的顺序是从低位向高位依次进行，高位不足四位用零补齐。下图演示了如何将二进制整数 10 1101 0101 1100 转换为十六进制：

从图中可以看出，二进制整数 10 1101 0101 1100 转换为十六进制的结果为 2D5C。

十六进制整数转换为二进制整数时，思路是相反的，每一位十六进制数字转换为四位二进制数字，运算的顺序也是从低位向高位依次进行。下图演示了如何将十六进制整数 A5D6 转换为二进制：

从图中可以看出，十六进制整数 A5D6 转换为二进制的结果为 1010 0101 1101 0110。

在C语言编程中，二进制、八进制、十六进制之间几乎不会涉及小数的转换，所以这里我们只讲整数的转换，大家学以致用足以。另外，八进制和十六进制之间也极少直接转换，这里我们也不再讲解了。

总结

本节前面两部分讲到的转换方法是通用的，任何进制之间的转换都可以采用，只是有时比较麻烦而已。二进制和八进制、十六进制之间的转换有非常简洁的方法，所以没有采用前面的方法。

数据在内存中的存储（二进制形式存储）

计算机要处理的信息是多种多样的，如数字、文字、符号、图形、音频、视频等，这些信息在人们的眼里是不同的。但对于计算机来说，它们在内存中都是一样的，都是以二进制的形式来表示。

要想学习编程，就必须了解二进制，它是计算机处理数据的基础。

内存条是一个非常精密的部件，包含了上亿个电子元器件，它们很小，达到了纳米级别。这些元器件，实际上就是电路；电路的电压会变化，要么是 0V，要么是 5V，只有这两种电压。5V 是通电，用1来表示，0V 是断电，用0来表示。所以，一个元器件有2种状态，0 或者 1。

我们通过电路来控制这些元器件的通断电，会得到很多0、1的组合。例如，8个元器件有 28=256 种不同的组合，16个元器件有 216=65536 种不同的组合。虽然一个元器件只能表示2个数值，但是多个结合起来就可以表示很多数值了。

我们可以给每一种组合赋予特定的含义，例如，可以分别用 1101000、00011100、11111111、00000000、01010101、10101010 来表示 C、语、言、中、文、网 这几个字，那么结合起来 1101000 00011100 11111111 00000000 01010101 10101010 就表示”C语言中文网“。

一般情况下我们不一个一个的使用元器件，而是将8个元器件看做一个单位，即使表示很小的数，例如 1，也需要8个，也就是 00000001。

1个元器件称为1比特（Bit）或1位，8个元器件称为1字节（Byte），那么16个元器件就是2Byte，32个就是4Byte，以此类推：

• 8×1024个元器件就是1024Byte，简写为1KB；
• 8×1024×1024个元器件就是1024KB，简写为1MB；
• 8×1024×1024×1024个元器件就是1024MB，简写为1GB。

现在，你知道1GB的内存有多少个元器件了吧。我们通常所说的文件大小是多少 KB、多少 MB，就是这个意思。

单位换算：

• 1Byte = 8 Bit
• 1KB = 1024Byte = 210Byte
• 1MB = 1024KB = 220Byte
• 1GB = 1024MB = 230Byte
• 1TB = 1024GB = 240Byte
• 1PB = 1024TB = 250Byte
• 1EB = 1024PB = 260Byte

我们平时使用计算机时，通常只会设计到 KB、MB、GB、TB 这几个单位，PB 和 EB 这两个高级单位一般在大数据处理过程中才会用到。

你看，在内存中没有abc这样的字符，也没有gif、jpg这样的图片，只有0和1两个数字，计算机也只认识0和1。所以，计算机使用二进制，而不是我们熟悉的十进制，写入内存中的数据，都会被转换成0和1的组合。

我们将在《C语言调试》中的《查看、修改运行时的内存》一节教大家如何操作C语言程序的内存。

程序员的幽默

为了加深印象，最后给大家看个笑话。

程序员A：“哥们儿，最近手头紧，借点钱？”

程序员B：“成啊，要多少？”

程序员A：“一千行不？”

程序员B：“咱俩谁跟谁！给你凑个整，1024，拿去吧。”

你看懂这个笑话了吗？请选出正确答案。

A) 因为他同情程序员A，多给他24块 B) 这个程序员不会数数，可能是太穷饿晕了 C) 这个程序员故意的，因为他独裁的老婆规定1024是整数 D) 就像100是10的整数次方一样，1024是2的整数次方，对于程序员就是整数

载入内存，让程序运行起来

如果你的电脑上安装了QQ，你希望和好友聊天，会双击QQ图标，打开QQ软件，输入账号和密码，然后登录就可以了。

那么，QQ是怎么运行起来的呢？

首先，有一点你要明确，你安装的QQ软件是保存在硬盘中的。

双击QQ图标，操作系统就会知道你要运行这个软件，它会在硬盘中找到你安装的QQ软件，将数据（安装的软件本质上就是很多数据的集合）复制到内存。对！就是复制到内存！QQ不是在硬盘中运行的，而是在内存中运行的。

为什么呢？因为内存的读写速度比硬盘快很多。

对于读写速度，内存 > 固态硬盘 > 机械硬盘。机械硬盘是靠电机带动盘片转动来读写数据的，而内存条通过电路来读写数据，电机的转速肯定没有电的传输速度（几乎是光速）快。虽然固态硬盘也是通过电路来读写数据，但是因为与内存的控制方式不一样，速度也不及内存。

所以，不管是运行QQ还是编辑Word文档，都是先将硬盘上的数据复制到内存，才能让CPU来处理，这个过程就叫作载入内存（Load into Memory）。完成这个过程需要一个特殊的程序（软件），这个程序就叫做加载器（Loader）。

CPU直接与内存打交道，它会读取内存中的数据进行处理，并将结果保存到内存。如果需要保存到硬盘，才会将内存中的数据复制到硬盘。

例如，打开Word文档，输入一些文字，虽然我们看到的不一样了，但是硬盘中的文档没有改变，新增的文字暂时保存到了内存，Ctrl+S才会保存到硬盘。因为内存断电后会丢失数据，所以如果你编辑完Word文档忘记保存就关机了，那么你将永远无法找回这些内容。

虚拟内存

如果我们运行的程序较多，占用的空间就会超过内存（内存条）容量。例如计算机的内存容量为2G，却运行着10个程序，这10个程序共占用3G的空间，也就意味着需要从硬盘复制 3G 的数据到内存，这显然是不可能的。

操作系统（Operating System，简称 OS）为我们解决了这个问题：当程序运行需要的空间大于内存容量时，会将内存中暂时不用的数据再写回硬盘；需要这些数据时再从硬盘中读取，并将另外一部分不用的数据写入硬盘。这样，硬盘中就会有一部分空间用来存放内存中暂时不用的数据。这一部分空间就叫做虚拟内存（Virtual Memory）。

3G - 2G = 1G，上面的情况需要在硬盘上分配 1G 的虚拟内存。

硬盘的读写速度比内存慢很多，反复交换数据会消耗很多时间，所以如果你的内存太小，会严重影响计算机的运行速度，甚至会出现”卡死“现象，即使CPU强劲，也不会有大的改观。如果经济条件允许，建议将内存升级为 4G，在 win7、win8、win10 下运行软件就会比较流畅了。

关于内存的更多知识，大家可以阅读《C语言内存精讲》，我敢保证你将会顿悟。

总结：CPU直接从内存中读取数据，处理完成后将结果再写入内存。

​ 图1：CPU、内存、硬盘和主板的关系

ASCII编码，将英文存储到计算机

前面我们已经讲到，计算机是以二进制的形式来存储数据的，它只认识 0 和 1 两个数字，我们在屏幕上看到的文字，在存储之前都被转换成了二进制（0和1序列），在显示时也要根据二进制找到对应的字符。

可想而知，特定的文字必然对应着固定的二进制，否则在转换时将发生混乱。那么，怎样将文字与二进制对应起来呢？这就需要有一套规范，计算机公司和软件开发者都必须遵守，这样的一套规范就称为字符集（Character Set）或者字符编码（Character Encoding）。

严格来说，字符集和字符编码不是一个概念，字符集定义了文字和二进制的对应关系，为字符分配了唯一的编号，而字符编码规定了如何将文字的编号存储到计算机中。我们暂时先不讨论这些细节，姑且认为它们是一个概念，本节中我也混用了这两个概念，未做区分。

字符集为每个字符分配一个唯一的编号，类似于学生的学号，通过编号就能够找到对应的字符。

可以将字符集理解成一个很大的表格，它列出了所有字符和二进制的对应关系，计算机显示文字或者存储文字，就是一个查表的过程。

在计算机逐步发展的过程中，先后出现了几十种甚至上百种字符集，有些还在使用，有些已经淹没在了历史的长河中，本节我们要讲解的是一种专门针对英文的字符集——ASCII编码。

拉丁字母（开胃小菜）

在正式介绍 ASCII 编码之前，我们先来说说什么是拉丁字母。估计也有不少读者和我一样，对于拉丁字母、英文字母和汉语拼音中的字母的关系不是很清楚。

拉丁字母也叫罗马字母，它源自希腊字母，是当今世界上使用最广的字母系统。基本的拉丁字母就是我们经常见到的 ABCD 等26个英文字母。

拉丁字母、阿拉伯字母、斯拉夫字母（西里尔字母）被称为世界三大字母体系。

拉丁字母原先是欧洲人使用的，后来由于欧洲殖民主义，导致这套字母体系在全球范围内开始流行，美洲、非洲、澳洲、亚洲都没有逃过西方文化的影响。中国也是，我们现在使用的拼音其实就是拉丁字母，是不折不扣的舶来品。

后来，很多国家对 26 个基本的拉丁字母进行了扩展，以适应本地的语言文化。最常见的扩展方式就是加上变音符号，例如汉语拼音中的ü，就是在u的基础上加上两个小点演化而来；再如，áà就是在a的上面标上音调。

总起来说：

• 基本拉丁字母就是 26 个英文字母；
• 扩展拉丁字母就是在基本的 26 个英文字母的基础上添加变音符号、横线、斜线等演化而来，每个国家都不一样。

ASCII 编码

计算机是美国人发明的，他们首先要考虑的问题是，如何将二进制和英文字母（也就是拉丁文）对应起来。

当时，各个厂家或者公司都有自己的做法，编码规则并不统一，这给不同计算机之间的数据交换带来不小的麻烦。但是相对来说，能够得到普遍认可的有 IBM 发明的 EBCDIC 和此处要谈的 ASCII。

我们先说 ASCII。ASCII 是“American Standard Code for Information Interchange”的缩写，翻译过来是“美国信息交换标准代码”。看这个名字就知道，这套编码是美国人给自己设计的，他们并没有考虑欧洲那些扩展的拉丁字母，也没有考虑韩语和日语，我大中华几万个汉字更是不可能被重视。

但这也无可厚非，美国人自己发明的计算机，当然要先解决自己的问题

ASCII 的标准版本于 1967 年第一次发布，最后一次更新则是在 1986 年，迄今为止共收录了 128 个字符，包含了基本的拉丁字母（英文字母）、阿拉伯数字（也就是 1234567890）、标点符号（,.!等）、特殊符号（@#$%^&等）以及一些具有控制功能的字符（往往不会显示出来）。

在 ASCII 编码中，大写字母、小写字母和阿拉伯数字都是连续分布的（见下表），这给程序设计带来了很大的方便。例如要判断一个字符是否是大写字母，就可以判断该字符的 ASCII 编码值是否在 65~90 的范围内。

EBCDIC 编码正好相反，它的英文字母不是连续排列的，中间出现了多次断续，给编程带来了一些困难。现在连 IBM 自己也不使用 EBCDIC 了，转而使用更加优秀的 ASCII。

ASCII 编码已经成了计算机的通用标准，没有人再使用 EBCDIC 编码了，它已经消失在历史的长河中了。

ASCII 编码一览表

标准 ASCII 编码共收录了 128 个字符，其中包含了 33 个控制字符（具有某些特殊功能但是无法显示的字符）和 95 个可显示字符。

二进制	十进制	十六进制	字符/缩写	解释
00000000	0	00	NUL (NULL)	空字符
00000001	1	01	SOH (Start Of Headling)	标题开始
00000010	2	02	STX (Start Of Text)	正文开始
00000011	3	03	ETX (End Of Text)	正文结束
00000100	4	04	EOT (End Of Transmission)	传输结束
00000101	5	05	ENQ (Enquiry)	请求
00000110	6	06	ACK (Acknowledge)	回应/响应/收到通知
00000111	7	07	BEL (Bell)	响铃
00001000	8	08	BS (Backspace)	退格
00001001	9	09	HT (Horizontal Tab)	水平制表符
00001010	10	0A	LF/NL(Line Feed/New Line)	换行键
00001011	11	0B	VT (Vertical Tab)	垂直制表符
00001100	12	0C	FF/NP (Form Feed/New Page)	换页键
00001101	13	0D	CR (Carriage Return)	回车键
00001110	14	0E	SO (Shift Out)	不用切换
00001111	15	0F	SI (Shift In)	启用切换
00010000	16	10	DLE (Data Link Escape)	数据链路转义
00010001	17	11	DC1/XON (Device Control 1/Transmission On)	设备控制1/传输开始
00010010	18	12	DC2 (Device Control 2)	设备控制2
00010011	19	13	DC3/XOFF (Device Control 3/Transmission Off)	设备控制3/传输中断
00010100	20	14	DC4 (Device Control 4)	设备控制4
00010101	21	15	NAK (Negative Acknowledge)	无响应/非正常响应/拒绝接收
00010110	22	16	SYN (Synchronous Idle)	同步空闲
00010111	23	17	ETB (End of Transmission Block)	传输块结束/块传输终止
00011000	24	18	CAN (Cancel)	取消
00011001	25	19	EM (End of Medium)	已到介质末端/介质存储已满/介质中断
00011010	26	1A	SUB (Substitute)	替补/替换
00011011	27	1B	ESC (Escape)	逃离/取消
00011100	28	1C	FS (File Separator)	文件分割符
00011101	29	1D	GS (Group Separator)	组分隔符/分组符
00011110	30	1E	RS (Record Separator)	记录分离符
00011111	31	1F	US (Unit Separator)	单元分隔符
00100000	32	20	(Space)	空格
00100001	33	21	!
00100010	34	22	"
00100011	35	23	#
00100100	36	24	$
00100101	37	25	%
00100110	38	26	&
00100111	39	27	'
00101000	40	28	(
00101001	41	29	)
00101010	42	2A	*
00101011	43	2B	+
00101100	44	2C	,
00101101	45	2D	-
00101110	46	2E	.
00101111	47	2F	/
00110000	48	30	0
00110001	49	31	1
00110010	50	32	2
00110011	51	33	3
00110100	52	34	4
00110101	53	35	5
00110110	54	36	6
00110111	55	37	7
00111000	56	38	8
00111001	57	39	9
00111010	58	3A	:
00111011	59	3B	;
00111100	60	3C	<
00111101	61	3D	=
00111110	62	3E	>
00111111	63	3F	?
01000000	64	40	@
01000001	65	41	A
01000010	66	42	B
01000011	67	43	C
01000100	68	44	D
01000101	69	45	E
01000110	70	46	F
01000111	71	47	G
01001000	72	48	H
01001001	73	49	I
01001010	74	4A	J
01001011	75	4B	K
01001100	76	4C	L
01001101	77	4D	M
01001110	78	4E	N
01001111	79	4F	O
01010000	80	50	P
01010001	81	51	Q
01010010	82	52	R
01010011	83	53	S
01010100	84	54	T
01010101	85	55	U
01010110	86	56	V
01010111	87	57	W
01011000	88	58	X
01011001	89	59	Y
01011010	90	5A	Z
01011011	91	5B	[
01011100	92	5C	\
01011101	93	5D	]
01011110	94	5E	^
01011111	95	5F	_
01100000	96	60	`
01100001	97	61	a
01100010	98	62	b
01100011	99	63	c
01100100	100	64	d
01100101	101	65	e
01100110	102	66	f
01100111	103	67	g
01101000	104	68	h
01101001	105	69	i
01101010	106	6A	j
01101011	107	6B	k
01101100	108	6C	l
01101101	109	6D	m
01101110	110	6E	n
01101111	111	6F	o
01110000	112	70	p
01110001	113	71	q
01110010	114	72	r
01110011	115	73	s
01110100	116	74	t
01110101	117	75	u
01110110	118	76	v
01110111	119	77	w
01111000	120	78	x
01111001	121	79	y
01111010	122	7A	z
01111011	123	7B	{
01111100	124	7C	|
01111101	125	7D	}
01111110	126	7E	~
01111111	127	7F	DEL (Delete)	删除

上表列出的是标准的 ASCII 编码，它共收录了 128 个字符，用一个字节中较低的 7 个比特位（Bit）足以表示（27 = 128），所以还会空闲下一个比特位，它就被浪费了。

如果您还想了解每个控制字符的含义，请转到：完整的ASCII码对照表以及各个字符的解释

ASCII 编码和C语言

稍微有点C语言基本功的读者可能认为C语言使用的就是 ASCII 编码，字符在存储时会转换成对应的 ASCII 码值，在读取时也是根据 ASCII 码找到对应的字符。这句话是错误的，严格来说，你可能被大学老师和C语言教材给误导了。

C语言有时候使用 ASCII 编码，有时候却不是，而是使用后面两节中即将讲到的 GBK 编码和 Unicode 字符集，我们将在《C语言到底使用什么编码？谁说C语言使用ASCII码，真是荒谬！》一节中展开讲解。

GB2312编码和GBK编码，将中文存储到计算机

计算机是一种改变世界的发明，很快就从美国传到了全球各地，得到了所有国家的认可，成为了一种不可替代的工具。计算机在广泛流行的过程中遇到的一个棘手问题就是字符编码，计算机是美国人发明的，它使用的是 ASCII 编码，只能显示英文字符，对汉语、韩语、日语、法语、德语等其它国家的字符无能为力。

为了让本国公民也能使用上计算机，各个国家（地区）也开始效仿 ASCII，开发了自己的字符编码。这些字符编码和 ASCII 一样，只考虑本国的语言文化，不兼容其它国家的文字。这样做的后果就是，一台计算机上必须安装多套字符编码，否则就不能正确地跨国传递数据，例如在中国编写的文本文件，拿到日本的电脑上就无法打开，或者打开后是一堆乱码。

下表列出了常见的字符编码：

字符编码	说明
ISO/IEC 8859	欧洲字符集，支持丹麦语、荷兰语、德语、意大利语、拉丁语、挪威语、葡萄牙语、西班牙语，瑞典语等，1987 年首次发布。 ASCII 编码只包含了基本的拉丁字母，没有包含欧洲很多国家所用到的一些扩展的拉丁字母，比如一些重音字母，带音标的字母等，ISO/IEC 8859 主要是在 ASCII 的基础上增加了这些衍生的拉丁字母。
Shift_Jis	日语字符集，包含了全角及半角拉丁字母、平假名、片假名、符号及日语汉字，1978 年首次发布。
Big5	繁体中文字符集，1984 年发布，通行于台湾、香港等地区，收录了 13053 个中文字、408个普通字符以及 33 个控制字符。
GB2312	简体中文字符集，1980 年发布，共收录了 6763 个汉字，其中一级汉字 3755 个，二级汉字 3008 个；同时收录了包括拉丁字母、希腊字母、日文平假名及片假名字母、俄语西里尔字母在内的 682 个字符。
GBK	中文字符集，是在 GB2312 的基础上进行的扩展，1995 年发布。 GB2312 收录的汉字虽然覆盖了中国大陆 99.75% 的使用频率，满足了基本的输入输出要求，但是对于人名、古汉语等方面出现的罕用字（例如朱镕基的“镕”就没有被 GB2312 收录），GB2312 并不能处理，所以后来又对 GBK 进行了一次扩展，形成了一种新的字符集，就是 GBK。 GBK 共收录了 21886 个汉字和图形符号，包括 GB2312 中的全部汉字、非汉字符号，以及 BIG5 中的全部繁体字，还有一些生僻字。
GB18030	中文字符集，是对 GBK 和 GB2312 的又一次扩展，2000 年发布。 GB18030 共收录 70244 个汉字，支持中国国内少数民族的文字，以及日语韩语中的汉字。

由于 ASCII 先入为主，已经使用了十来年了，现有的很多软件和文档都是基于 ASCII 的，所以后来的这些字符编码都是在 ASCII 基础上进行的扩展，它们都兼容 ASCII，以支持既有的软件和文档。

兼容 ASCII 的含义是，原来 ASCII 中已经包含的字符，在国家编码（地区编码）中的位置不变（也就是编码值不变），只是在这些字符的后面增添了新的字符。

如何存储

标准 ASCII 编码共包含了 128 个字符，用一个字节就足以存储（实际上是用一个字节中较低的 7 位来存储），而日文、中文、韩文等包含的字符非常多，有成千上万个，一个字节肯定是不够的（一个字节最多存储 28 = 256 个字符），所以要进行扩展，用两个、三个甚至四个字节来表示。

在制定字符编码时还要考虑内存利用率的问题。我们经常使用的字符，其编码值一般都比较小，例如字母和数字都是 ASCII 编码，其编码值不会超过 127，用一个字节存储足以，如果硬要用多个字节存储，就会浪费很多内存空间。

为了达到「既能存储本国字符，又能节省内存」的目的，Shift-Jis、Big5、GB2312 等都采用变长的编码方式：

• 对于原来的 ASCII 编码部分，用一个字节存储足以；
• 对于本国的常用字符（例如汉字、标点符号等），一般用两个字节存储；
• 对于偏远地区，或者极少使用的字符（例如藏文、蒙古文等），才使用三个甚至四个字节存储。

总起来说，越常用的字符占用的内存越少，越罕见的字符占用的内存越多。

具体讲一下中文编码方案

GB2312 --> GBK --> GB18030 是中文编码的三套方案，出现的时间从早到晚，收录的字符数目依次增加，并且向下兼容。GB2312 和 GBK 收录的字符数目较少，用 1~2个字节存储；GB18030 收录的字符最多，用1、2、4 个字节存储。

1. 从整体上讲，GB2312 和 GBK 的编码方式一致，具体为：

• 对于 ASCII 字符，使用一个字节存储，并且该字节的最高位是 0，这和 ASCII 编码是一致的，所以说 GB2312 完全兼容 ASCII。
• 对于中国的字符，使用两个字节存储，并且规定每个字节的最高位都是 1。

例如对于字母A，它在内存中存储为 01000001；对于汉字中，它在内存中存储为 11010110 11010000。由于单字节和双字节的最高位不一样，所以字符处理软件很容易区分一个字符到底用了几个字节。

2. GB18030 为了容纳更多的字符，并且要区分两个字节和四个字节，所以修改了编码方案，具体为：

• 对于 ASCII 字符，使用一个字节存储，并且该字节的最高位是 0，这和 ASCII、GB2312、GBK 编码是一致的。
• 对于常用的中文字符，使用两个字节存储，并且规定第一个字节的最高位是 1，第二个字节的高位最多只能有一个连续的 0（第二个字节的最高位可以是 1 也可以是 0，但是当它是 0 时，次高位就不能是 0 了）。注意对比 GB2312 和 GBK，它们要求两个字节的最高位为都必须为 1。
• 对于罕见的字符，使用四个字节存储，并且规定第一个和第三个字节的最高位是 1，第二个和第四个字节的高位必须有两个连续的 0。

例如对于字母A，它在内存中存储为 01000001；对于汉字中，它在内存中存储为 11010110 11010000；对于藏文གྱུ，它在内存中的存储为 10000001 00110010 11101111 00110000。

字符处理软件在处理文本时，从左往右依次扫描每个字节：

• 如果遇到的字节的最高位是 0，那么就会断定该字符只占用了一个字节；
• 如果遇到的字节的最高位是 1，那么该字符可能占用了两个字节，也可能占用了四个字节，不能妄下断论，所以还要继续往后扫描：
  • 如果第二个字节的高位有两个连续的 0，那么就会断定该字符占用了四个字节；
  • 如果第二个字节的高位没有连续的 0，那么就会断定该字符占用了两个字节。

可见，当字符占用两个或者四个字节时，GB18030 编码要检测两次，处理效率比 GB2312 和 GBK 都低。

GBK 编码最牛掰

GBK 于 1995 年发布，这一年也是互联网爆发的元年，国人使用电脑越来越多，也许是 GBK 这头猪正好站在风口上，它就飞起来了，后来的中文版 Windows 都将 GBK 作为默认的中文编码方案。

注意，这里我说 GBK 是默认的中文编码方案，并没有说 Windows 默认支持 GBK。Windows 在内核层面使用的是 Unicode 字符集（严格来说是 UTF-16 编码），但是它也给用户留出了选择的余地，如果用户不希望使用 Unicode，而是希望使用中文编码方案，那么这个时候 Windows 默认使用 GBK（当然，你可以选择使用 GB2312 或者 GB18030，不过一般没有这个必要）。

下节我们会讲解 Unicode 字符集和 UTF-16 编码方案。

实际上，中文版 Windows 下的很多程序默认使用的就是 GBK 编码，例如用记事本程序创建一个 txt 文档、在 cmd 或者控制台程序（最常见的C语言程序）中显示汉字、用 Visual Studio 创建的源文件等，使用的都是 GBK 编码。

可以说，GBK 编码在中文版的 Windows 中大行其道。

Unicode字符集，将全世界的文字存储到计算机

ASCII、GB2312、GBK、Shift_Jis、ISO/IEC 8859 等地区编码都是各个国家为了自己的语言文化开发的，不具有通用性，在一种编码下开发的软件或者编写的文档，拿到另一种编码下就会失效，必须提前使用程序转码，非常麻烦。

人们迫切希望有一种编码能够统一世界各地的字符，计算机只要安装了这一种字编码，就能支持使用世界上所有的文字，再也不会出现乱码，再也不需要转码了，这对计算机的数据传递来说是多么的方便呀！

就在这种呼吁下，Unicode 诞生了。Unicode 也称为统一码、万国码；看名字就知道，Unicode 希望统一所有国家的字符编码。

Unicode 于 1994 年正式公布第一个版本，现在的规模可以容纳 100 多万个符号，是一个很大的集合。

有兴趣的读取可以转到 https://unicode-table.com/cn/ 查看 Unicode 包含的所有字符，以及各个国家的字符是如何分布的。

这个网站不太稳定，随时可能无法访问，不要问我为什么，访问不了也不要找我，没有比它更好的网站了。

Windows、Linux、Mac OS 等常见操作系统都已经从底层（内核层面）开始支持 Unicode，大部分的网页和软件也使用 Unicode，Unicode 是大势所趋。

不过由于历史原因，目前的计算机仍然安装了 ASCII 编码以及 GB2312、GBK、Big5、Shift-JIS 等地区编码，以支持不使用 Unicode 的软件或者文档。内核在处理字符时，一般会将地区编码先转换为 Unicode，再进行下一步处理。

Unicode 字符集是如何存储的

本节我们多次说 Unicode 是一套字符集，而不是一套字符编码，它们之间究竟有什么区别呢？

严格来说，字符集和字符编码不是一个概念：

• 字符集定义了字符和二进制的对应关系，为每个字符分配了唯一的编号。可以将字符集理解成一个很大的表格，它列出了所有字符和二进制的对应关系，计算机显示文字或者存储文字，就是一个查表的过程。
• 而字符编码规定了如何将字符的编号存储到计算机中。如果使用了类似 GB2312 和 GBK 的变长存储方案（不同的字符占用的字节数不一样），那么为了区分一个字符到底使用了几个字节，就不能将字符的编号直接存储到计算机中，字符编号在存储之前必须要经过转换，在读取时还要再逆向转换一次，这套转换方案就叫做字符编码。

有的字符集在制定时就考虑到了编码的问题，是和编码结合在一起的，例如 ASCII、GB2312、GBK、BIG5 等，所以无论称作字符集还是字符编码都无所谓，也不好区分两者的概念。而有的字符集只管制定字符的编号，至于怎么存储，那是字符编码的事情，Unicode 就是一个典型的例子，它只是定义了全球文字的唯一编号，我们还需要 UTF-8、UTF-16、UTF-32 这几种编码方案将 Unicode 存储到计算机中。

Unicode 可以使用的编码方案有三种，分别是：

• UTF-8：一种变长的编码方案，使用 1~6 个字节来存储；
• UTF-32：一种固定长度的编码方案，不管字符编号大小，始终使用 4 个字节来存储；
• UTF-16：介于 UTF-8 和 UTF-32 之间，使用 2 个或者 4 个字节来存储，长度既固定又可变。

UTF 是 Unicode Transformation Format 的缩写，意思是“Unicode转换格式”，后面的数字表明至少使用多少个比特位（Bit）来存储字符。

1) UTF-8

UTF-8 的编码规则很简单：

• 如果只有一个字节，那么最高的比特位为 0，这样可以兼容 ASCII；
• 如果有多个字节，那么第一个字节从最高位开始，连续有几个比特位的值为 1，就使用几个字节编码，剩下的字节均以 10 开头。

具体的表现形式为：

• 0xxxxxxx：单字节编码形式，这和 ASCII 编码完全一样，因此 UTF-8 是兼容 ASCII 的；
• 110xxxxx 10xxxxxx：双字节编码形式（第一个字节有两个连续的 1）；
• 1110xxxx 10xxxxxx 10xxxxxx：三字节编码形式（第一个字节有三个连续的 1）；
• 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx：四字节编码形式（第一个字节有四个连续的 1）。

xxx 就用来存储 Unicode 中的字符编号。

下面是一些字符的 UTF-8 编码实例（绿色部分表示本来的 Unicode 编号）：

字符	字母N	符号æ	中文⻬
Unicode 编号（二进制）	01001110	11100110	00101110 11101100
Unicode 编号（十六进制）	4E	E6	2E EC
UTF-8 编码（二进制）	01001110	11000011 10100110	11100010 10111011 10101100
UTF-8 编码（十六进制）	4E	C3 A6	E2 BB AC

对于常用的字符，它的 Unicode 编号范围是 0 ~ FFFF，用 1~3 个字节足以存储，只有及其罕见，或者只有少数地区使用的字符才需要 4~6个字节存储。

2) UTF-32

UTF-32 是固定长度的编码，始终占用 4 个字节，足以容纳所有的 Unicode 字符，所以直接存储 Unicode 编号即可，不需要任何编码转换。浪费了空间，提高了效率。

3) UTF-16

UFT-16 比较奇葩，它使用 2 个或者 4 个字节来存储。

对于 Unicode 编号范围在 0 ~ FFFF 之间的字符，UTF-16 使用两个字节存储，并且直接存储 Unicode 编号，不用进行编码转换，这跟 UTF-32 非常类似。

对于 Unicode 编号范围在 10000~10FFFF 之间的字符，UTF-16 使用四个字节存储，具体来说就是：将字符编号的所有比特位分成两部分，较高的一些比特位用一个值介于 D800~DBFF 之间的双字节存储，较低的一些比特位（剩下的比特位）用一个值介于 DC00~DFFF 之间的双字节存储。

如果你不理解什么意思，请看下面的表格：

Unicode 编号范围 （十六进制）	具体的 Unicode 编号 （二进制）	UTF-16 编码	编码后的 字节数
0000 0000 ~ 0000 FFFF	xxxxxxxx xxxxxxxx	xxxxxxxx xxxxxxxx	2
0001 0000---0010 FFFF	yyyy yyyy yyxx xxxx xxxx	110110yy yyyyyyyy 110111xx xxxxxxxx	4

位于 D800~0xDFFF 之间的 Unicode 编码是特别为四字节的 UTF-16 编码预留的，所以不应该在这个范围内指定任何字符。如果你真的去查看 Unicode 字符集，会发现这个区间内确实没有收录任何字符。

UTF-16 要求在制定 Unicode 字符集时必须考虑到编码问题，所以真正的 Unicode 字符集也不是随意编排字符的。

对比以上三种编码方案

首先，只有 UTF-8 兼容 ASCII，UTF-32 和 UTF-16 都不兼容 ASCII，因为它们没有单字节编码。

1. UTF-8 使用尽量少的字节来存储一个字符，不但能够节省存储空间，而且在网络传输时也能节省流量，所以很多纯文本类型的文件（例如各种编程语言的源文件、各种日志文件和配置文件等）以及绝大多数的网页（例如百度、新浪、163等）都采用 UTF-8 编码。

UTF-8 的缺点是效率低，不但在存储和读取时都要经过转换，而且在处理字符串时也非常麻烦。例如，要在一个 UTF-8 编码的字符串中找到第 10 个字符，就得从头开始一个一个地检索字符，这是一个很耗时的过程，因为 UTF-8 编码的字符串中每个字符占用的字节数不一样，如果不从头遍历每个字符，就不知道第 10 个字符位于第几个字节处，就无法定位。

不过，随着算法的逐年精进，UTF-8 字符串的定位效率也越来越高了，往往不再是槽点了。

2. UTF-32 是“以空间换效率”，正好弥补了 UTF-8 的缺点，UTF-32 的优势就是效率高：UTF-32 在存储和读取字符时不需要任何转换，在处理字符串时也能最快速地定位字符。例如，在一个 UTF-32 编码的字符串中查找第 10 个字符，很容易计算出它位于第 37 个字节处，直接获取就行，不用再逐个遍历字符了，没有比这更快的定位字符的方法了。

但是，UTF-32 的缺点也很明显，就是太占用存储空间了，在网络传输时也会消耗很多流量。我们平常使用的字符编码值一般都比较小，用一两个字节存储足以，用四个字节简直是暴殄天物，甚至说是不能容忍的，所以 UTF-32 在应用上不如 UTF-8 和 UTF-16 广泛。

3. UTF-16 可以看做是 UTF-8 和 UTF-32 的折中方案，它平衡了存储空间和处理效率的矛盾。对于常用的字符，用两个字节存储足以，这个时候 UTF-16 是不需要转换的，直接存储字符的编码值即可。

Windows 内核、.NET Framework、Cocoa、Java String 内部采用的都是 UTF-16 编码。UTF-16 是幕后的功臣，我们在编辑源代码和文档时都是站在前台，所以一般感受不到，其实很多文本在后台处理时都已经转换成了 UTF-16 编码。

不过，UNIX 家族的操作系统（Linux、Mac OS、iOS 等）内核都采用 UTF-8 编码，我们就不去争论谁好谁坏了。

宽字符和窄字符（多字节字符）

有的编码方式采用 1~n 个字节存储，是变长的，例如 UTF-8、GB2312、GBK 等；如果一个字符使用了这种编码方式，我们就将它称为多字节字符，或者窄字符。

有的编码方式是固定长度的，不管字符编号大小，始终采用 n 个字节存储，例如 UTF-32、UTF-16 等；如果一个字符使用了这种编码方式，我们就将它称为宽字符。

Unicode 字符集可以使用窄字符的方式存储，也可以使用宽字符的方式存储；GB2312、GBK、Shift-JIS 等国家编码一般都使用窄字符的方式存储；ASCII 只有一个字节，无所谓窄字符和宽字符。

说了这么多，C语言到底使用哪种字编码方式呢？其实这个问题有点复杂，我们将在《C语言到底使用什么编码？谁说C语言使用ASCII码，真是荒谬！》一节中展开讲解。

第二卷 C 语言初探

第一个 C 语言程序

我们有两种方式从计算机获得信息：一是看屏幕上的文字、图片、视频等，二是听从喇叭发出来的声音。让喇叭发出声音目前还比较麻烦，我们先来看看如何在屏幕上显示一些文字吧。

在屏幕上显示文字非常简单，只需要一个语句，例如，下面的代码会让屏幕显示出Hello world：

puts("Hello world");

这里有一个生疏的词汇puts，用来让计算机在屏幕上显示文字。

更加专业的称呼：

• "在屏幕上显示文字"叫做输出（Output）；

• 每个文字都是一个字符（Character）；

• 多个字符组合起来，就是一个字符序列，叫做字符串（String）。

puts 是 output string 的缩写，意思是: 输出字符串。

在C语言中，字符串需要用双引号" "包围起来，Hello world什么也不是，计算机不认识它，"Hello world"才是字符串。

puts 在输出字符串的时候，需要将字符串放在( )内。

在汉语和英语中，分别使用。和.表示一句话的结束，而在C语言中，使用;表示一个语句的结束。puts("C语言中文网")表达了完整的意思，是一个完整的语句，需要在最后加上;，表示当前语句结束了。

总结起来，上面的语句可以分为三个部分：

• puts( )命令计算机输出字符串；
• "C语言中文网"是要输出的内容；
• ;表示语句结束。

C 语言程序的整体框架

puts 可以在显示器上输出内容，但是仅有 puts 是不够的，程序不能运行，还需要添加其他代码，构成一个完整的框架。完整的程序如下：

#include <stdio.h>
int main()
{
    puts("Hello world");
    return 0;
}

第 1~3 行、第 5~6 行是固定的，所有C语言源代码都必须有这几行。你暂时不需要理解它们是什么意思，反正有这个就是了，以后会慢慢讲解。

但是请记住，今后我们写的所有类似 puts 这样的语句，都必须放在{ }之间才有效。

这就是我们的第一个C语言程序，它非常简单，带领我们进入了C语言的大门。

编程时请选择正确的输入法，严格区分中英文

计算机起源于美国，C语言、C++、Java、JavaScript 等很多流行的编程语言都是美国人发明的，所以在编写代码的时候必须使用英文半角输入法，尤其是标点符号，初学者一定要引起注意。

例如，上节我们使用 puts 语句在显示器上输出内容：

puts("Hello world");

这里的括号、双引号、分号都必须是英文符号，而且是半角的。下图演示了如何将搜狗输入法切换到英文半角状态：

​ 图1：搜狗输入法

一些相似的中英文标点符号：

• 中文分号；和英文分号;；
• 中文逗号，和英文逗号,；
• 中文冒号：和英文冒号:；
• 中文括号（）和英文括号()；
• 中文问号？和英文问号?；
• 中文单引号’‘和英文单引号' '；
• 中文双引号“ ”和英文双引号" "。

初学者请务必注意标点符号的问题，它们在视觉上的差别很小，一旦将英文符号写成中文符号就会导致错误，而且往往不容易发现，经常会遇到类似的错误，有些同学甚至会在这里跌倒好几次。

全角和半角输入法的区别

全角和半角的区别主要在于除汉字以外的其它字符，比如标点符号、英文字母、阿拉伯数字等，全角字符和半角字符所占用的位置的大小不同。

在计算机屏幕上，一个汉字要占两个英文字符的位置，人们把一个英文字符所占的位置称为“半角”，相对地把一个汉字所占的位置称为“全角”。

标点符号、英文字母、阿拉伯数字等这些字符不同于汉字，在半角状态它们被作为英文字符处理，而在全角状态作为中文字符处理，请看下面的例子。

半角输入：Hello C,I like!

全角输入：Ｈｅｌｌｏ　Ｃ，Ｉ　ｌｉｋｅ！

另外最重要的一点是：“相同”字符在全角和半角状态下对应的编码值（例如 Unicode 编码、GBK 编码等）不一样，所以它们是不同的字符。

​ 图：搜狗输入法半角和全角

我们知道，在编程时要使用英文半角输入法。为了加强练习，出个选择题，请大家判断下面哪一种描述是正确的：

A) 编程的时候不用在意中英文符号的区别。 B) 在源代码的任何地方都不能出现中文汉字、字符等。 C) 感叹号没有中文和英文的区别。 D) 编程时，使用的英文引号，也有左引号和右引号的区别。 E) 中文和英文模式下的制表符（键盘tab键)输入效果一致。

答案：E 选项正确。

什么是源文件？

在开发软件的过程中，我们需要将编写好的代码（Code）保存到一个文件中，这样代码才不会丢失，才能够被编译器找到，才能最终变成可执行文件。这种用来保存代码的文件就叫做源文件（Source File）。

我们将在《编译和链接》一节中讲解编译器的概念。

每种编程语言的源文件都有特定的后缀，以方便被编译器识别，被程序员理解。源文件后缀大都根据编程语言本身的名字来命名，例如：

• C 语言源文件的后缀是.c；
• C++ 语言（C Plus Plus）源文件的后缀是.cpp；
• Java 源文件的后缀是.java；
• Python 源文件的后缀是.py；
• JavaScript 源文件后置是.js。

源文件其实就是纯文本文件，它的内部并没有特殊格式，能证明这一结论的典型例子是：在 Windows 下用记事本程序新建一个文本文档，并命名为demo.txt，输入一段C语言代码并保存，然后将该文件强制重命名为demo.c（后缀从.txt变成了.c），发现编译器依然能够正确识别其中的C语言代码，并顺利生成可执行文件。

源文件的后缀仅仅是为了表明该文件中保存的是某种语言的代码（例如.c文件中保存的是C语言代码），这样程序员更加容易区分，编译器也更加容易识别，它并不会导致该文件的内部格式发生改变。

C++ 是站在C语言的肩膀上发展起来的，是在C语言的基础上进行的扩展，C++ 包含了C语言的全部内容（请猛击《C语言和C++到底有什么关系》一文了解更多），将C语言代码放在.cpp文件中不会有错，很多初学者都是这么做的，很多大学老师也是这么教的。但是，我还是强烈建议将C语言代码放在.c文件中，这样能够更加严格地遵循C语言的语法，也能够更加清晰地了解C语言和C++的区别。

C 语言编译和链接详解（通俗易懂，深入本质）

我们平时所说的程序，是指双击后就可以直接运行的程序，这样的程序被称为可执行程序（Executable Program）。在 Windows 下，可执行程序的后缀有.exe和.com（其中.exe比较常见）；在类 UNIX 系统（Linux、Mac OS 等）下，可执行程序没有特定的后缀，系统根据文件的头部信息来判断是否是可执行程序。

可执行程序的内部是一系列计算机指令和数据的集合，它们都是二进制形式的，CPU 可以直接识别，毫无障碍；但是对于程序员，它们非常晦涩，难以记忆和使用。

例如，在屏幕上输出“VIP会员”，C语言的写法为：

puts("VIP会员");

二进制的写法为：

你感受一下，直接使用二进制是不是想撞墙，是不是受到一吨重的伤害？

在计算机发展的初期，程序员就是使用这样的二进制指令来编写程序的，那个拓荒的年代还没有编程语言。

直接使用二进制指令编程对程序员来说简直是噩梦，尤其是当程序比较大的时候，不但编写麻烦，需要频繁查询指令手册，而且除错会异常苦恼，要直接面对一堆二进制数据，让人眼花缭乱。另外，用二进制指令编程步骤繁琐，要考虑各种边界情况和底层问题，开发效率十分低下。

这就倒逼程序员开发出了编程语言，提高自己的生产力，例如汇编、C语言、C++、Java、Python、Go语言等，都是在逐步提高开发效率。至此，编程终于不再是只有极客能做的事情了，不了解计算机的读者经过一定的训练也可以编写出有模有样的程序。

编译（Compile）

C语言代码由固定的词汇按照固定的格式组织起来，简单直观，程序员容易识别和理解，但是对于CPU，C语言代码就是天书，根本不认识，CPU只认识几百个二进制形式的指令。这就需要一个工具，将C语言代码转换成CPU能够识别的二进制指令，也就是将代码加工成 .exe 程序的格式；这个工具是一个特殊的软件，叫做编译器（Compiler）。

编译器能够识别代码中的词汇、句子以及各种特定的格式，并将他们转换成计算机能够识别的二进制形式，这个过程称为编译（Compile）。

编译也可以理解为“翻译”，类似于将中文翻译成英文、将英文翻译成象形文字，它是一个复杂的过程，大致包括词法分析、语法分析、语义分析、性能优化、生成可执行文件五个步骤，期间涉及到复杂的算法和硬件架构。对于学计算机或者软件的大学生，“编译原理”是一门专业课程，有兴趣的读者请自行阅读《编译原理》一书，这里我们不再展开讲解。

注意：不了解编译原理并不影响我们学习C语言，我也不建议初学者去钻研编译原理，贪多嚼不烂，不要把自己绕进去。

C语言的编译器有很多种，不同的平台下有不同的编译器，例如：

• Windows 下常用的是微软开发的 Visual C++，它被集成在 Visual Studio 中，一般不单独使用；
• Linux 下常用的是 GUN 组织开发的 GCC，很多 Linux 发行版都自带 GCC；
• Mac 下常用的是 LLVM/Clang，它被集成在 Xcode 中（Xcode 以前集成的是 GCC，后来由于 GCC 的不配合才改为 LLVM/Clang，LLVM/Clang 的性能比 GCC 更加强大）。

你的代码语法正确与否，编译器说了才算，我们学习C语言，从某种意义上说就是学习如何使用编译器。

编译器可以 100% 保证你的代码从语法上讲是正确的，因为哪怕有一点小小的错误，编译也不能通过，编译器会告诉你哪里错了，便于你的更改。

链接（Link）

C语言代码经过编译以后，并没有生成最终的可执行文件（.exe 文件），而是生成了一种叫做目标文件（Object File）的中间文件（或者说临时文件）。目标文件也是二进制形式的，它和可执行文件的格式是一样的。对于 Visual C++，目标文件的后缀是.obj；对于 GCC，目标文件的后缀是.o。

目标文件经过链接（Link）以后才能变成可执行文件。既然目标文件和可执行文件的格式是一样的，为什么还要再链接一次呢，直接作为可执行文件不行吗？

不行的！因为编译只是将我们自己写的代码变成了二进制形式，它还需要和系统组件（比如标准库、动态链接库等）结合起来，这些组件都是程序运行所必须的。

链接（Link）其实就是一个“打包”的过程，它将所有二进制形式的目标文件和系统组件组合成一个可执行文件。完成链接的过程也需要一个特殊的软件，叫做链接器（Linker）。

随着我们学习的深入，我们编写的代码越来越多，最终需要将它们分散到多个源文件中，编译器每次只能编译一个源文件，生成一个目标文件，这个时候，链接器除了将目标文件和系统组件组合起来，还需要将编译器生成的多个目标文件组合起来。

再次强调，编译是针对一个源文件的，有多少个源文件就需要编译多少次，就会生成多少个目标文件。

总结

不管我们编写的代码有多么简单，都必须经过「编译 --> 链接」的过程才能生成可执行文件：

• 编译就是将我们编写的源代码“翻译”成计算机可以识别的二进制格式，它们以目标文件的形式存在；
• 链接就是一个“打包”的过程，它将所有的目标文件以及系统组件组合成一个可执行文件。

如果不是特别强调，一般情况下我们所说的“编译器”实际上也包括了链接器，比如，你使用了哪种编译器？去哪里下载C语言编译器？我的编译器为什么报错了呢？

C 语言的三套标准：C89、C99和C11

我们今天使用的 Windows、Linux、Mac OS 等操作系统都是由一种叫做 Unix 的系统演化而来。Unix 作为80年代主流的操作系统，是整个软件工业的基础，是现代操作系统的开山鼻祖，C语言就是为 Unix 而生的。

Unix 和C语言的开发者是同一人，名字叫丹尼斯·里奇（Dennis MacAlistair Ritchie）。

​ C语言和 Unix 之父——丹尼斯·里奇

2011年10月12日（北京时间为10月13日），丹尼斯·里奇去世，享年70岁。

C 语言的诞生

1967年，26岁的丹尼斯·里奇进入贝尔实验室开发 Unix，并于 1969 年圣诞节前推出第一个试运行版本。这个时候的 Unix 是用汇编语言写的，移植性非常差，要想让 Unix 运行在不同型号的机器上，就得针对每个型号的机器重写一遍操作系统，这显然是一个不可能完成的任务。

为了提高通用性和开发效率，丹尼斯·里奇决定发明一种新的编程语言——C语言。紧接着，丹尼斯·里奇就用C语言改写了 Unix 上的C语言编译器，他的同事汤姆森则使用C语言重写了 Unix，使它成为一种通用性强、移植简单的操作系统，从此开创了计算机编程史上的新篇章，C语言也成为了操作系统专用语言。

C89 标准

到了80年代，C语言越来越流行，广泛被业界使用，从大型主机到小型微机，各个厂商群雄并起，推出了多款C语言的编译器。这些编译器根据行业和厂商自己的需求，进行了各种扩展，C语言进入了春秋战国时代，逐渐演变成一个松散杂乱的大家族。

为统一C语言版本，1983 年美国国家标准局（American National Standards Institute，简称 ANSI）成立了一个委员会，专门来制定C语言标准。1989 年C语言标准被批准，被称为 ANSI X3.159-1989 "Programming Language C"。这个版本的C语言标准通常被称为 ANSI C。又由于这个版本是 89 年完成制定的，因此也被称为 C89。

后来 ANSI 把这个标准提交到 ISO（国际化标准组织），1990 年被 ISO 采纳为国际标准，称为 ISO C。又因为这个版本是1990年发布的，因此也被称为 C90。

ANSI C（C89）与 ISO C（C90）内容基本相同，主要是格式组织不一样。

因为 ANSI 与 ISO 的C标准内容基本相同，所以对于C标准，可以称为 ANSI C，也可以说是 ISO C，或者 ANSI / ISO C。以后大家看到 ANSI C、ISO C、C89、C90，要知道这些标准的内容都是一样的。

目前常用的编译器，例如微软编译器、GCC、LLVM/Clang 等，都能很好地支持 ANSI C 的内容。

C99 标准

在 ANSI C 标准确立之后，C语言的规范在很长一段时间内都没有大的变动。1995 年C程序设计语言工作组对C语言进行了一些修改，增加了新的关键字，编写了新的库，取消了原有的限制，并于 1999 年形成新的标准——ISO/IEC 9899:1999 标准，通常被成为 C99。

但是这个时候的C语言编译器基本已经成熟，各个组织对 C99 的支持所表现出来的兴趣不同。当 GCC 和其它一些商业编译器支持 C99 的大部分特性的時候，微软和 Borland 却似乎对此不感兴趣，或者说没有足够的资源和动力来改进编译器，最终导致不同的编译器在部分语法上存在差异。

例如，ANSI C 规定，局部变量要在函数开头定义，而 C99 取消了这个限制，变量可以在任意位置定义，我们将在《C语言变量的定义位置以及初始值》一节中详细介绍。

C11 标准

C11 标准由国际标准化组织（ISO）和国际电工委员会（IEC） 旗下的C语言标准委员会于 2011 年底正式发布，支持此标准的主流C语言编译器有 GCC、LLVM/Clang、Intel C++ Compile 等。

C11 标准主要增加了以下内容：

• 增加了安全函数，例如 gets_s()、fopen_s() 等；
• 增加了 <threads.h> 头文件以支持多线程；
• 增加了 <uchar.h> 头文件以支持 Unicode 字符集；
• 以及其它一些细节。

总结

现有的教程（包括书籍、视频、大学课程等）大都是针对 C89 编写的，这是C语言的核心，后来的 C99、C11 新增的特性并不多，只是在“打补丁”。本教程虽然基于 C99 标准，但是绝大部分内容还是 C89 的，我会在 C89 和 C99 有差异的语法上给出重点说明。

分析第一个 C 语言程序

前面我们给出了一段最简单的C语言代码，并演示了如何在不同的平台下进行编译，这节我们来分析一下这段代码，让读者有个整体的认识。代码如下：

#include <stdio.h>
int main(){
    puts("C语言中文网");
    return 0;
}

函数的概念

先来看第 4 行代码，这行代码会在显示器上输出“C语言中文网”。前面我们已经讲过，puts 后面要带( )，字符串也要放在( )中。

在C语言中，有的语句使用时不能带括号，有的语句必须带括号。带括号的称为函数（Function）。

C语言提供了很多功能，例如输入输出、获得日期时间、文件操作等，我们只需要一句简单的代码就能够使用。但是这些功能的底层都比较复杂，通常是软件和硬件的结合，还要要考虑很多细节和边界，如果将这些功能都交给程序员去完成，那将极大增加程序员的学习成本，降低编程效率。

好在C语言的开发者们为我们做了一件好事，他们已经编写了大量代码，将常见的基本功能都完成了，我们可以直接拿来使用。但是现在问题来了，那么多代码，如何从中找到自己需要的呢？一股脑将所有代码都拿来显然是非常不明智的。

这些代码，早已被分门别类地放在了不同的文件中，并且每一段代码都有唯一的名字。使用代码时，只要在对应的名字后面加上( )就可以。这样的一段代码能够独立地完成某个功能，一次编写完成后可以重复使用，被称为函数（Function）。读者可以认为，函数就是一段可以重复使用的代码。

函数的一个明显特征就是使用时必须带括号( )，必要的话，括号中还可以包含待处理的数据。例如puts("C语言中文网")就使用了一段具有输出功能的代码，这段代码的名字是 puts，"C语言中文网" 是要交给这段代码处理的数据。使用函数在编程中有专业的称呼，叫做函数调用（Function Call）。

如果函数需要处理多个数据，那么它们之间使用逗号,分隔，例如：

pow(10, 2);

该函数用来求10的2次方。

需要注意的是，C语言中的函数和数学中的函数不是同一个概念，不要拿两者对比。函数的英文名称是 Function，它还有“功能”的意思。大陆将 Function 翻译为“函数”，而台湾地区翻译为“函式”，读者要注意区分。

自定义函数和main函数

C语言自带的函数称为库函数（Library Function）。库（Library）是编程中的一个基本概念，可以简单地认为它是一些列函数的集合，在磁盘上往往是一个文件夹。C语言自带的库称为标准库（Standard Library），其他公司或个人开发的库称为第三方库（Third-Party Library）。

除了库函数，我们还可以编写自己的函数，拓展程序的功能。自己编写的函数称为自定义函数。自定义函数和库函数在编写和使用方式上完全相同，只是由不同的机构来编写。

示例中第2~6行代码就是我们自己编写的一个函数。main 是函数的名字，( ) 表明这是函数定义，{ } 之间的代码是函数要实现的功能。

函数可以接收待处理的数据，同样可以将处理结果告诉我们；使用return可以告知处理结果。示例中第5行代码表明，main 函数的处理结果是整数 0。return 可以翻译为“返回”，所以函数的处理结果被称为返回值（Return Value）。

第2行代码中，int 是 integer 的简写，意为“整数”。它告诉我们，函数的返回值是整数。

需要注意的是，示例中的自定义函数必须命名为 main。C语言规定，一个程序必须有且只有一个 main 函数。main 被称为主函数，是程序的入口函数，程序运行时从 main 函数开始，直到 main 函数结束（遇到 return 或者执行到函数末尾时，函数才结束）。

也就是说，没有 main 函数程序将不知道从哪里开始执行，运行时会报错。

综上所述：第2~6行代码定义了主函数 main，它的返回值是整数 0，程序将从这里开始执行。main 函数的返回值在程序运行结束时由系统接收。

关于自定义函数的更多内容，我们将在《C语言函数》一章中详细讲解，这里不再展开讨论。

有的教材中将 main 函数写作：

void main()
{
    // Some Code...
}

这在 VC6.0 下能够通过编译，但在 C-Free、GCC 中却会报错，因为这不是标准的 main 函数的写法，大家不要被误导，最好按照示例中的格式来写。

头文件的概念

还有最后一个问题，示例中第1行的#include <stdio.h>是什么意思呢？

C语言开发者们编写了很多常用函数，并分门别类的放在了不同的文件，这些文件就称为头文件（header file）。每个头文件中都包含了若干个功能类似的函数，调用某个函数时，要引入对应的头文件，否则编译器找不到函数。

实际上，头文件往往只包含函数的说明，也就是告诉我们函数怎么用，而函数本身保存在其他文件中，在链接时才会找到。对于初学者，可以暂时理解为头文件中包含了若干函数。

引入头文件使用#include命令，并将文件名放在< >中，#include 和 < > 之间可以有空格，也可以没有。

头文件以.h为后缀，而C语言代码文件以.c为后缀，它们都是文本文件，没有本质上的区别，#include 命令的作用也仅仅是将头文件中的文本复制到当前文件，然后和当前文件一起编译。你可以尝试将头文件中的内容复制到当前文件，那样也可以不引入头文件。

.h中代码的语法规则和.c中是一样的，你也可以#include <xxx.c>，这是完全正确的。不过实际开发中没有人会这样做，这样看起来非常不专业，也不规范。

较早的C语言标准库包含了15个头文件，stdio.h 和 stdlib.h 是最常用的两个：

• stdio 是 standard input output 的缩写，stdio.h 被称为“标准输入输出文件”，包含的函数大都和输入输出有关，puts() 就是其中之一。
• stdlib 是 standard library 的缩写，stdlib.h 被称为“标准库文件”，包含的函数比较杂乱，多是一些通用工具型函数，system() 就是其中之一。

最后的总结

初学编程，有很多基本概念需要了解，本节就涉及到很多，建议大家把上面的内容多读几遍，必将有所收获。

本节开头的示例是一个C语言程序的基本结构，我们不妨整理一下思路，从整体上再分析一遍：

1. 第1行引入头文件 stdio.h，这是编程中最常用的一个头文件。头文件不是必须要引入的，我们用到了 puts 函数，所以才引入 stdio.h。例如下面的代码完全正确：

int main(){
    return 0;
}

我们没有调用任何函数，所以不必引入头文件。

2. 第2行开始定义主函数 main。main 是程序的入口函数，一个C程序必须有 main 函数，而且只能有一个。

3. 第4行调用 puts 函数向显示器输出字符串。

4. 第5行是 main 函数的返回值。程序运行正确一般返回 0。

C 语言代码中的空白符

空格、制表符、换行符等统称为空白符（space character），它们只用来占位，并没有实际的内容，也显示不出具体的字符。

制表符分为水平制表符和垂直制表符，它们的 ASCII 编码值分别是 9 和 11。

• 垂直制表符在现代计算机中基本不再使用了，也没法在键盘上直接输入，它已经被换行符取代了。
• 水平制表符相当于四个空格，对于大部分编辑器，按下 Tab 键默认就是输入一个水平制表符；如果你进行了个性化设置，按下 Tab 键也可能会输入四个或者两个空格。

对于编译器，有的空白符会被忽略，有的却不能。请看下面几种 puts 的写法：

#include<stdio.h>
int main()
{
    puts("C语言");
    puts("中文网");
   
    puts
    ("C语言中文网");
   
    puts
    (
    "C语言中文网"
    )
    ;
   
    puts   ("C语言中文网");

    puts    (    "C语言中文网"    )    ;

    return 0;
}

运行结果：

看到输出结果，说明代码没有错误，以上几种 puts 的用法是正确的。puts和()之间、" "和()之间可以有任意的空白符，它们会被编译器忽略，编译器不认为它们是代码的一部分，它们的存在只是在编辑器中呈现一定的格式，让程序员阅读方便。

需要注意的是，由" "包围起来的字符串中的空白符不会被忽略，它们会被原样输出到控制台上；并且字符串中间不能换行，否则会产生编译错误。请看下面的代码：

#include<stdio.h>
int main()
{
    puts("C语  言 中文网");
    puts("C语言
    中文网");
    return 0;
}

第 5~6 行代码是错误的，字符串必须在一行内结束，不能换行。把这两行代码删除，运行结果为：

程序员要善于利用空白符：缩进（制表符）和换行可以让代码结构更加清晰，空格可以让代码看起来不那么拥挤。专业的程序员同样追求专业的代码格式，大家在以后的学习中可以慢慢体会。

第三卷 C 语言变量和数据类型

大话 C 语言变量和数据类型

在《数据在内存中的存储》一节中讲到：

• 计算机要处理的数据（诸如数字、文字、符号、图形、音频、视频等）是以二进制的形式存放在内存中的；
• 我们将8个比特（Bit）称为一个字节（Byte），并将字节作为最小的可操作单元。

我们不妨先从最简单的整数说起，看看它是如何放到内存中去的。

变量（Variable）

现实生活中我们会找一个小箱子来存放物品，一来显得不那么凌乱，二来方便以后找到。计算机也是这个道理，我们需要先在内存中找一块区域，规定用它来存放整数，并起一个好记的名字，方便以后查找。这块区域就是“小箱子”，我们可以把整数放进去了。

C语言中这样在内存中找一块区域：

int a;

int又是一个新单词，它是 Integer 的简写，意思是整数。a 是我们给这块区域起的名字；当然也可以叫其他名字，例如 abc、mn123 等。

这个语句的意思是：在内存中找一块区域，命名为 a，用它来存放整数。

注意 int 和 a 之间是有空格的，它们是两个词。也注意最后的分号，int a表达了完整的意思，是一个语句，要用分号来结束。

不过int a;仅仅是在内存中找了一块可以保存整数的区域，那么如何将 123、100、999 这样的数字放进去呢？

C语言中这样向内存中放整数：

a = 123;

=是一个新符号，它在数学中叫“等于号”，例如 1+2=3，但在C语言中，这个过程叫做赋值（Assign）。赋值是指把数据放到内存的过程。

把上面的两个语句连起来：

int a;
a = 123;

就把 123 放到了一块叫做 a 的内存区域。你也可以写成一个语句：

int a = 123;

a 中的整数不是一成不变的，只要我们需要，随时可以更改。更改的方式就是再次赋值，例如：

int a = 123;
a = 1000;
a = 9999;

第二次赋值，会把第一次的数据覆盖（擦除）掉，也就是说，a 中最后的值是9999，123、1000 已经不存在了，再也找不回来了。

因为 a 的值可以改变，所以我们给它起了一个形象的名字，叫做变量（Variable）。

int a;创造了一个变量 a，我们把这个过程叫做变量定义。a=123;把 123 交给了变量 a，我们把这个过程叫做给变量赋值；又因为是第一次赋值，也称变量的初始化，或者赋初值。

你可以先定义变量，再初始化，例如：

int abc;
abc=999;

也可以在定义的同时进行初始化，例如：

int abc=999;

这两种方式是等价的。

数据类型（Data Type）

数据是放在内存中的，变量是给这块内存起的名字，有了变量就可以找到并使用这份数据。但问题是，该如何使用呢？

我们知道，诸如数字、文字、符号、图形、音频、视频等数据都是以二进制形式存储在内存中的，它们并没有本质上的区别，那么，00010000 该理解为数字16呢，还是图像中某个像素的颜色呢，还是要发出某个声音呢？如果没有特别指明，我们并不知道。

也就是说，内存中的数据有多种解释方式，使用之前必须要确定；上面的int a;就表明，这份数据是整数，不能理解为像素、声音等。int 有一个专业的称呼，叫做数据类型（Data Type）。

顾名思义，数据类型用来说明数据的类型，确定了数据的解释方式，让计算机和程序员不会产生歧义。在C语言中，有多种数据类型，例如：

说 明	字符型	短整型	整型	长整型	单精度浮点型	双精度浮点型	无类型
数据类型	char	short	int	long	float	double	void

这些是最基本的数据类型，是C语言自带的，如果我们需要，还可以通过它们组成更加复杂的数据类型，后面我们会一一讲解。

连续定义多个变量

为了让程序的书写更加简洁，C语言支持多个变量的连续定义，例如：

int a, b, c;
float m = 10.9, n = 20.56;
char p, q = '@';

连续定义的多个变量以逗号,分隔，并且要拥有相同的数据类型；变量可以初始化，也可以不初始化。

数据的长度（Length）

所谓数据长度（Length），是指数据占用多少个字节。占用的字节越多，能存储的数据就越多，对于数字来说，值就会更大，反之能存储的数据就有限。

多个数据在内存中是连续存储的，彼此之间没有明显的界限，如果不明确指明数据的长度，计算机就不知道何时存取结束。例如我们保存了一个整数 1000，它占用4个字节的内存，而读取时却认为它占用3个字节或5个字节，这显然是不正确的。

所以，在定义变量时还要指明数据的长度。而这恰恰是数据类型的另外一个作用。数据类型除了指明数据的解释方式，还指明了数据的长度。因为在C语言中，每一种数据类型所占用的字节数都是固定的，知道了数据类型，也就知道了数据的长度。

在32位环境中，各种数据类型的长度一般如下：

说 明	字符型	短整型	整型	长整型	单精度浮点型	双精度浮点型
数据类型	char	short	int	long	float	double
长 度	1	2	4	4	4	8

C语言有多少种数据类型，每种数据类型长度是多少、该如何使用，这是每一位C程序员都必须要掌握的，后续我们会一一讲解。

最后的总结

数据是放在内存中的，在内存中存取数据要明确三件事情：数据存储在哪里、数据的长度以及数据的处理方式。

变量名不仅仅是为数据起了一个好记的名字，还告诉我们数据存储在哪里，使用数据时，只要提供变量名即可；而数据类型则指明了数据的长度和处理方式。所以诸如int n;、char c;、float money;这样的形式就确定了数据在内存中的所有要素。

C语言提供的多种数据类型让程序更加灵活和高效，同时也增加了学习成本。而有些编程语言，例如PHP、JavaScript等，在定义变量时不需要指明数据类型，编译器会根据赋值情况自动推演出数据类型，更加智能。

除了 C 语言，Java、C++、C# 等在定义变量时也必须指明数据类型，这样的编程语言称为强类型语言。而PHP、JavaScript等在定义变量时不必指明数据类型，编译系统会自动推演，这样的编程语言称为弱类型语言。

强类型语言一旦确定了数据类型，就不能再赋给其他类型的数据，除非对数据类型进行转换。弱类型语言没有这种限制，一个变量，可以先赋给一个整数，然后再赋给一个字符串。

最后需要说明的是：数据类型只在定义变量时指明，而且必须指明；使用变量时无需再指明，因为此时的数据类型已经确定了。

在屏幕上输出各种类型的数据

在《第一个C语言程序》一节中，我们使用 puts 来输出字符串。puts 是 output string 的缩写，只能用来输出字符串，不能输出整数、小数、字符等，我们需要用另外一个函数，那就是 printf。

printf 比 puts 更加强大，不仅可以输出字符串，还可以输出整数、小数、单个字符等，并且输出格式也可以自己定义，例如：

• 以十进制、八进制、十六进制形式输出；
• 要求输出的数字占 n 个字符的位置；
• 控制小数的位数。

printf 是 print format 的缩写，意思是“格式化打印”。这里所谓的“打印”就是在屏幕上显示内容，与“输出”的含义相同，所以我们一般称 printf 是用来格式化输出的。

先来看一个简单的例子：

printf("Hello world");

这个语句可以在屏幕上显示“C语言中文网”，与puts("Hello world");的效果类似。

输出变量 abc 的值：

int abc = 999;
printf("%d", abc);

这里就比较有趣了。先来看%d，d 是 decimal 的缩写，意思是十进制数，%d 表示以十进制整数的形式输出。输出什么呢？输出变量 abc 的值。%d 与 abc 是对应的，也就是说，会用 abc 的值来替换 %d。

再来看个复杂点的：

int abc = 999;
printf("The value of abc is %d !", abc);

会在屏幕上显示：The value of abc is 999 !

你看，字符串 "The value of abc is %d !" 中的 %d 被替换成了 abc 的值，其他字符没有改变。这说明 %d 比较特殊，不会原样输出，会被替换成对应的变量的值。

再来看：

int a=100;
int b=200;
int c=300;
printf("a=%d, b=%d, c=%d", a, b, c);

会在屏幕上显示：a=100, b=200, c=300

再次证明了 %d 与后面的变量是一一对应的，第一个 %d 对应第一个变量，第二个 %d 对应第二个变量……

%d称为格式控制符，它指明了以何种形式输出数据。格式控制符均以%开头，后跟其他字符。%d 表示以十进制形式输出一个整数。除了 %d，printf 支持更多的格式控制，例如：

• %c：输出一个字符。c 是 character 的简写。
• %s：输出一个字符串。s 是 string 的简写。
• %f：输出一个小数。f 是 float 的简写。

除了这些，printf 支持更加复杂和优美的输出格式，考虑到读者的基础暂时不够，我们将在《C语言数据输出大汇总以及轻量进阶》一节中展开讲解。

我们把代码补充完整，体验一下：

#include <stdio.h>
int main(){
    int n = 100;
    char c = '@';  //字符用单引号包围，字符串用双引号包围
    float money = 93.96;
    printf("n=%d, c=%c, money=%f\n", n, c, money);
    return 0;
}

输出结果：n=100, c=@, money=93.959999

要点提示：

1. \n是一个整体，组合在一起表示一个换行字符。换行符是 ASCII 编码中的一个控制字符，无法在键盘上直接输入，只能用这种特殊的方法表示，被称为转义字符，我们将在《C语言转义字符》一节中有具体讲解，请大家暂时先记住\n的含义。

所谓换行，就是让文本从下一行的开头输出，相当于在编辑 Word 或者 TXT 文档时按下回车键。

puts 输出完成后会自动换行，而 printf 不会，要自己添加换行符，这是 puts 和 printf 在输出字符串时的一个区别。

2. //后面的为注释。注释用来说明代码是什么意思，起到提示的作用，可以帮助我们理解代码。注释虽然也是代码的一部分，但是它并不会给程序带来任何影响，编译器在编译阶段会忽略注释的内容，或者说删除注释的内容。我们将在《C语言标识符、关键字和注释》一节中详细讲解。

3. money 的输出值并不是 93.96，而是一个非常接近的值，这与小数本身的存储机制有关，这种机制导致很多小数不能被精确地表示，即使像 93.96 这种简单的小数也不行。我们将在《小数在内存中是如何存储的，揭秘诺贝尔奖级别的设计（长篇神文）》一节详细介绍。

我们也可以不用变量，将数据直接输出：

#include <stdio.h>
int main(){
    float money = 93.96;
    printf("n=%d, c=%c, money=%f\n", 100, '@', money);
    return 0;
}

输出结果与上面相同。

在以后的编程中，我们会经常使用 printf，说它是C语言中使用频率最高的一个函数一点也不为过，每个C语言程序员都应该掌握 printf 的用法，这是最基本的技能。

不过 printf 的用法比较灵活，也比较复杂，初学者知识储备不足，不能一下子掌握，目前大家只需要掌握最基本的用法，以后随着编程知识的学习，我们会逐步介绍更加高级的用法，最终让大家完全掌握 printf。

【脑筋急转弯】%ds输出什么

%d 输出整数，%s 输出字符串，那么 %ds 输出什么呢？

我们不妨先来看一个例子：

#include <stdio.h>
int main(){
    int a=1234;
    printf("a=%ds\n", a);
    return 0;
}

运行结果：a=1234s

从输出结果可以发现，%d被替换成了变量 a 的值，而s没有变，原样输出了。这是因为， %d才是格式控制符，%ds在一起没有意义，s仅仅是跟在%d后面的一个普通字符，所以会原样输出。

【拓展】如何在字符串中书写长文本

假设现在我们要输出一段比较长的文本，它的内容为：

C 语言中文网，一个学习 C 语言和 C++ 的网站，他们坚持用工匠的精神来打磨每一套教程。坚持做好一件事情，做到极致，让自己感动，让用户心动，这就是足以传世的作品！C语言中文网的网址是：http://c.biancheng.net

如果将这段文本放在一个字符串中，会显得比较臃肿，格式也不好看，就像下面这样：

​ 超出编辑窗口宽度的文本换行

​ 超出编辑窗口宽度的文本隐藏

当文本超出编辑窗口的宽度时，可以选择将文本换行，也可以选择将文本隐藏（可以在编辑器里面自行设置），但是不管哪种形式，在一个字符串里书写长文本总是不太美观。

当然，你可以多写几个 puts 函数，就像下面这样：

我不否认这种写法也比较美观，但是这里我要讲的是另外一种写法：

#include <stdio.h>
int main(){
    puts(
        "C语言中文网，一个学习C语言和C++的网站，他们坚持用工匠的精神来打磨每一套教程。"
        "坚持做好一件事情，做到极致，让自己感动，让用户心动，这就是足以传世的作品！"
        "C语言中文网的网址是：http://c.biancheng.net"    
    );
    return 0;
}

在 puts 函数中，可以将一个较长的字符串分割成几个较短的字符串，这样会使得长文本的格式更加整齐。

注意，这只是形式上的分割，编译器在编译阶段会将它们合并为一个字符串，它们放在一块连续的内存中。

多个字符串并不一定非得换行，也可以将它们写在一行中，例如：

#include <stdio.h>
int main(){
    puts("C语言中文网！"  "C语言和C++！"  "http://c.biancheng.net");
    return 0;
}

本节讲到的 puts、printf，以及后面要讲到的 fprintf、fputs 等与字符串输出有关的函数，都支持这种写法。

C 语言中的整数（short,int,long）

整数是编程中常用的一种数据，C语言通常使用int来定义整数（int 是 integer 的简写），这在《大话C语言变量和数据类型》中已经进行了详细讲解。

在现代操作系统中，int 一般占用 4 个字节（Byte）的内存，共计 32 位（Bit）。如果不考虑正负数，当所有的位都为 1 时它的值最大，为 232-1 = 4,294,967,295 ≈ 43亿，这是一个很大的数，实际开发中很少用到，而诸如 1、99、12098 等较小的数使用频率反而较高。

使用 4 个字节保存较小的整数绰绰有余，会空闲出两三个字节来，这些字节就白白浪费掉了，不能再被其他数据使用。现在个人电脑的内存都比较大了，配置低的也有 2G，浪费一些内存不会带来明显的损失；而在C语言被发明的早期，或者在单片机和嵌入式系统中，内存都是非常稀缺的资源，所有的程序都在尽力节省内存。

反过来说，43 亿虽然已经很大，但要表示全球人口数量还是不够，必须要让整数占用更多的内存，才能表示更大的值，比如占用 6 个字节或者 8 个字节。

让整数占用更少的内存可以在 int 前边加 short，让整数占用更多的内存可以在 int 前边加 long，例如：

short int a = 10; short int b, c = 99; long int m = 102023; long int n, p = 562131;

这样 a、b、c 只占用 2 个字节的内存，而 m、n、p 可能会占用 8 个字节的内存。

也可以将 int 省略，只写 short 和 long，如下所示：

short a = 10; short b, c = 99; long m = 102023; long n, p = 562131;

这样的写法更加简洁，实际开发中常用。

int 是基本的整数类型，short 和 long 是在 int 的基础上进行的扩展，short 可以节省内存，long 可以容纳更大的值。

short、int、long 是C语言中常见的整数类型，其中 int 称为整型，short 称为短整型，long 称为长整型。

整型的长度

细心的读者可能会发现，上面我们在描述 short、int、long 类型的长度时，只对 short 使用肯定的说法，而对 int、long 使用了“一般”或者“可能”等不确定的说法。这种描述的言外之意是，只有 short 的长度是确定的，是两个字节，而 int 和 long 的长度无法确定，在不同的环境下有不同的表现。

一种数据类型占用的字节数，称为该数据类型的长度。例如，short 占用 2 个字节的内存，那么它的长度就是 2。

实际情况也确实如此，C语言并没有严格规定 short、int、long 的长度，只做了宽泛的限制：

• short 至少占用 2 个字节。
• int 建议为一个机器字长。32 位环境下机器字长为 4 字节，64 位环境下机器字长为 8 字节。
• short 的长度不能大于 int，long 的长度不能小于 int。

总结起来，它们的长度（所占字节数）关系为：

2 ≤ short ≤ int ≤ long

这就意味着，short 并不一定真的 短，long 也并不一定真的 长，它们有可能和 int 占用相同的字节数。

在 16 位环境下，short 的长度为 2 个字节，int 也为 2 个字节，long 为 4 个字节。16 位环境多用于单片机和低级嵌入式系统，在PC和服务器上已经见不到了。

对于 32 位的 Windows、Linux 和 Mac OS，short 的长度为 2 个字节，int 为 4 个字节，long 也为 4 个字节。PC和服务器上的 32 位系统占有率也在慢慢下降，嵌入式系统使用 32 位越来越多。

在 64 位环境下，不同的操作系统会有不同的结果，如下所示：

操作系统	short	int	long
Win64（64位 Windows）	2	4	4
类Unix系统（包括 Unix、Linux、Mac OS、BSD、Solaris 等）	2	4	8

目前我们使用较多的PC系统为 Win XP、Win 7、Win 8、Win 10、Mac OS、Linux，在这些系统中，short 和 int 的长度都是固定的，分别为 2 和 4，大家可以放心使用，只有 long 的长度在 Win64 和类 Unix 系统下会有所不同，使用时要注意移植性。

sizeof 操作符

获取某个数据类型的长度可以使用 sizeof 操作符，如下所示：

#include <stdio.h>
int main(){
    short a = 10;
    int b = 100;
    int short_length = sizeof a;
    int int_length = sizeof(b);
    int long_length = sizeof(long);
    int char_length = sizeof(char);
    printf("short=%d, int=%d, long=%d, char=%d\n", short_length, int_length, long_length, char_length);
    return 0;
}

在 32 位环境以及 Win64 环境下的运行结果为：short=2, int=4, long=4, char=1

在 64 位 Linux 和 Mac OS 下的运行结果为：short=2, int=4, long=8, char=1

sizeof 用来获取某个数据类型或变量所占用的字节数，如果后面跟的是变量名称，那么可以省略( )，如果跟的是数据类型，就必须带上( )。

需要注意的是，sizeof 是C语言中的操作符，不是函数，所以可以不带( )，后面会详细讲解。

不同整型的输出

使用不同的格式控制符可以输出不同类型的整数，它们分别是：

• %hd用来输出 short int 类型，hd 是 short decimal 的简写；
• %d用来输出 int 类型，d 是 decimal 的简写；
• %ld用来输出 long int 类型，ld 是 long decimal 的简写。

下面的例子演示了不同整型的输出：

#include <stdio.h>
int main(){
    short a = 10;
    int b = 100;
    long c = 9437;
    printf("a=%hd, b=%d, c=%ld\n", a, b, c);
    return 0;
}

运行结果：a=10, b=100, c=9437

在编写代码的过程中，我建议将格式控制符和数据类型严格对应起来，养成良好的编程习惯。当然，如果你不严格对应，一般也不会导致错误，例如，很多初学者都使用%d输出所有的整数类型，请看下面的例子：

#include <stdio.h>
int main(){
    short a = 10;
    int b = 100;
    long c = 9437;
    printf("a=%d, b=%d, c=%d\n", a, b, c);
    return 0;
}

运行结果仍然是：a=10, b=100, c=9437

当使用%d输出 short，或者使用%ld输出 short、int 时，不管值有多大，都不会发生错误，因为格式控制符足够容纳这些值。

当使用%hd输出 int、long，或者使用%d输出 long 时，如果要输出的值比较小（就像上面的情况），一般也不会发生错误，如果要输出的值比较大，就很有可能发生错误，例如：

#include <stdio.h>
int main(){
    int m = 306587;
    long n = 28166459852;
    printf("m=%hd, n=%hd\n", m, n);
    printf("n=%d\n", n);
    return 0;
}

在 64 位 Linux 和 Mac OS 下（long 的长度为 8）的运行结果为： m=-21093, n=4556 n=-1898311220

输出结果完全是错误的，这是因为%hd容纳不下 m 和 n 的值，%d也容纳不下 n 的值。

读者需要注意，当格式控制符和数据类型不匹配时，编译器会给出警告，提示程序员可能会存在风险。

编译器的警告是分等级的，不同程度的风险被划分成了不同的警告等级，而使用%d输出 short 和 long 类型的风险较低，如果你的编译器设置只对较高风险的操作发出警告，那么此处你就看不到警告信息。

C 语言中的二进制数、八进制数和十六进制数

C语言中的整数除了可以使用十进制，还可以使用二进制、八进制和十六进制。

二进制数、八进制数和十六进制数的表示

一个数字默认就是十进制的，表示一个十进制数字不需要任何特殊的格式。但是，表示一个二进制、八进制或者十六进制数字就不一样了，为了和十进制数字区分开来，必须采用某种特殊的写法，具体来说，就是在数字前面加上特定的字符，也就是加前缀。

1) 二进制

二进制由 0 和 1 两个数字组成，使用时必须以0b或0B（不区分大小写）开头，例如：

//合法的二进制
int a = 0b101;  //换算成十进制为 5
int b = -0b110010;  //换算成十进制为 -50
int c = 0B100001;  //换算成十进制为 33
//非法的二进制
int m = 101010;  //无前缀 0B，相当于十进制
int n = 0B410;  //4不是有效的二进制数字

读者请注意，标准的C语言并不支持上面的二进制写法，只是有些编译器自己进行了扩展，才支持二进制数字。换句话说，并不是所有的编译器都支持二进制数字，只有一部分编译器支持，并且跟编译器的版本有关系。

下面是实际测试的结果：

• Visual C++ 6.0 不支持。
• Visual Studio 2015 支持，但是 Visual Studio 2010 不支持；可以认为，高版本的 Visual Studio 支持二进制数字，低版本的 Visual Studio 不支持。
• GCC 4.8.2 支持，但是 GCC 3.4.5 不支持；可以认为，高版本的 GCC 支持二进制数字，低版本的 GCC 不支持。
• LLVM/Clang 支持（内嵌于 Mac OS 下的 Xcode 中）。

2) 八进制

八进制由 0~7 八个数字组成，使用时必须以0开头（注意是数字 0，不是字母 o），例如：

//合法的八进制数
int a = 015;  //换算成十进制为 13
int b = -0101;  //换算成十进制为 -65
int c = 0177777;  //换算成十进制为 65535
//非法的八进制
int m = 256;  //无前缀 0，相当于十进制
int n = 03A2;  //A不是有效的八进制数字

3) 十六进制

十六进制由数字 0~9、字母 A~F 或 a~f（不区分大小写）组成，使用时必须以0x或0X（不区分大小写）开头，例如：

//合法的十六进制
int a = 0X2A;  //换算成十进制为 42
int b = -0XA0;  //换算成十进制为 -160
int c = 0xffff;  //换算成十进制为 65535
//非法的十六进制
int m = 5A;  //没有前缀 0X，是一个无效数字
int n = 0X3H;  //H不是有效的十六进制数字

4) 十进制

十进制由 0~9 十个数字组成，没有任何前缀，和我们平时的书写格式一样，不再赘述。

二进制数、八进制数和十六进制数的输出

C语言中常用的整数有 short、int 和 long 三种类型，通过 printf 函数，可以将它们以八进制、十进制和十六进制的形式输出。上节我们讲解了如何以十进制的形式输出，这节我们重点讲解如何以八进制和十六进制的形式输出，下表列出了不同类型的整数、以不同进制的形式输出时对应的格式控制符：

	short	int	long
八进制	%ho	%o	%lo
十进制	%hd	%d	%ld
十六进制	%hx 或者 %hX	%x 或者 %X	%lx 或者 %lX

十六进制数字的表示用到了英文字母，有大小写之分，要在格式控制符中体现出来：

• %hx、%x 和 %lx 中的x小写，表明以小写字母的形式输出十六进制数；
• %hX、%X 和 %lX 中的X大写，表明以大写字母的形式输出十六进制数。

八进制数字和十进制数字不区分大小写，所以格式控制符都用小写形式。如果你比较叛逆，想使用大写形式，那么行为是未定义的，请你慎重：

• 有些编译器支持大写形式，只不过行为和小写形式一样；
• 有些编译器不支持大写形式，可能会报错，也可能会导致奇怪的输出。

注意，虽然部分编译器支持二进制数字的表示，但是却不能使用 printf 函数输出二进制，这一点比较遗憾。当然，通过转换函数可以将其它进制数字转换成二进制数字，并以字符串的形式存储，然后在 printf 函数中使用%s输出即可。考虑到读者的基础还不够，这里就先不讲这种方法了。

【实例】以不同进制的形式输出整数：

#include <stdio.h>
int main(){
    short a = 0b1010110;  //二进制数字    
    int b = 02713;  //八进制数字    
    long c = 0X1DAB83;  //十六进制数字       
    printf("a=%ho, b=%o, c=%lo\n", a, b, c);  //以八进制形似输出    
    printf("a=%hd, b=%d, c=%ld\n", a, b, c);  //以十进制形式输出    
    printf("a=%hx, b=%x, c=%lx\n", a, b, c);  //以十六进制形式输出（字母小写）    
    printf("a=%hX, b=%X, c=%lX\n", a, b, c);  //以十六进制形式输出（字母大写）    
    return 0;
}

运行结果： a=126, b=2713, c=7325603 a=86, b=1483, c=1944451 a=56, b=5cb, c=1dab83 a=56, b=5CB, c=1DAB83

从这个例子可以发现，一个数字不管以何种进制来表示，都能够以任意进制的形式输出。数字在内存中始终以二进制的形式存储，其它进制的数字在存储前都必须转换为二进制形式；同理，一个数字在输出时要进行逆向的转换，也就是从二进制转换为其他进制。

输出时加上前缀

请读者注意观察上面的例子，会发现有一点不完美，如果只看输出结果：

• 对于八进制数字，它没法和十进制、十六进制区分，因为八进制、十进制和十六进制都包含 0~7 这几个数字。
• 对于十进制数字，它没法和十六进制区分，因为十六进制也包含 0~9 这几个数字。如果十进制数字中还不包含 8 和 9，那么也不能和八进制区分了。
• 对于十六进制数字，如果没有包含 a~f 或者 A~F，那么就无法和十进制区分，如果还不包含 8 和 9，那么也不能和八进制区分了。

区分不同进制数字的一个简单办法就是，在输出时带上特定的前缀。在格式控制符中加上#即可输出前缀，例如 %#x、%#o、%#lX、%#ho 等，请看下面的代码：

#include <stdio.h>
int main(){
    short a = 0b1010110;  //二进制数字
    int b = 02713;  //八进制数字
    long c = 0X1DAB83;  //十六进制数字
    printf("a=%#ho, b=%#o, c=%#lo\n", a, b, c);  //以八进制形似输出
    printf("a=%hd, b=%d, c=%ld\n", a, b, c);  //以十进制形式输出
    printf("a=%#hx, b=%#x, c=%#lx\n", a, b, c);  //以十六进制形式输出（字母小写）
    printf("a=%#hX, b=%#X, c=%#lX\n", a, b, c);  //以十六进制形式输出（字母大写）
    return 0;
}

运行结果： a=0126, b=02713, c=07325603 a=86, b=1483, c=1944451 a=0x56, b=0x5cb, c=0x1dab83 a=0X56, b=0X5CB, c=0X1DAB83

十进制数字没有前缀，所以不用加#。如果你加上了，那么它的行为是未定义的，有的编译器支持十进制加#，只不过输出结果和没有加#一样，有的编译器不支持加#，可能会报错，也可能会导致奇怪的输出；但是，大部分编译器都能正常输出，不至于当成一种错误。

C 语言中的正负数及其输出

在数学中，数字有正负之分。在C语言中也是一样，short、int、long 都可以带上正负号，例如：

//负数
short a1 = -10;
short a2 = -0x2dc9;  //十六进制
//正数
int b1 = +10;
int b2 = +0174;  //八进制
int b3 = 22910;
//负数和正数相加
long c = (-9) + (+12);

如果不带正负号，默认就是正数。

符号也是数字的一部分，也要在内存中体现出来。符号只有正负两种情况，用1位（Bit）就足以表示；C语言规定，把内存的最高位作为符号位。以 int 为例，它占用 32 位的内存，0~30 位表示数值，31 位表示正负号。如下图所示：

在编程语言中，计数往往是从0开始，例如字符串 "abc123"，我们称第 0 个字符是 a，第 1 个字符是 b，第 5 个字符是 3。这和我们平时从 1 开始计数的习惯不一样，大家要慢慢适应，培养编程思维。

C语言规定，在符号位中，用 0 表示正数，用 1 表示负数。例如 int 类型的 -10 和 +16 在内存中的表示如下：

short、int 和 long 类型默认都是带符号位的，符号位以外的内存才是数值位。如果只考虑正数，那么各种类型能表示的数值范围（取值范围）就比原来小了一半。

但是在很多情况下，我们非常确定某个数字只能是正数，比如班级学生的人数、字符串的长度、内存地址等，这个时候符号位就是多余的了，就不如删掉符号位，把所有的位都用来存储数值，这样能表示的数值范围更大（大一倍）。

C语言允许我们这样做，如果不希望设置符号位，可以在数据类型前面加上 unsigned 关键字，例如：

unsigned short a = 12;
unsigned int b = 1002;
unsigned long c = 9892320;

这样，short、int、long 中就没有符号位了，所有的位都用来表示数值，正数的取值范围更大了。这也意味着，使用了 unsigned 后只能表示正数，不能再表示负数了。

如果将一个数字分为符号和数值两部分，那么不加 unsigned 的数字称为有符号数，能表示正数和负数，加了 unsigned 的数字称为无符号数，只能表示正数。

请读者注意一个小细节，如果是unsigned int类型，那么可以省略 int ，只写 unsigned，例如：

unsigned n = 100;

它等价于：

unsigned int n = 100;

无符号数的输出

无符号数可以以八进制、十进制和十六进制的形式输出，它们对应的格式控制符分别为：

	unsigned short	unsigned int	unsigned long
八进制	%ho	%o	%lo
十进制	%hu	%u	%lu
十六进制	%hx 或者 %hX	%x 或者 %X	%lx 或者 %lX

上节我们也讲到了不同进制形式的输出，但是上节我们还没有讲到正负数，所以也没有关心这一点，只是“笼统”地介绍了一遍。现在本节已经讲到了正负数，那我们就再深入地说一下。

严格来说，格式控制符和整数的符号是紧密相关的，具体就是：

• %d 以十进制形式输出有符号数；
• %u 以十进制形式输出无符号数；
• %o 以八进制形式输出无符号数；
• %x 以十六进制形式输出无符号数。

那么，如何以八进制和十六进制形式输出有符号数呢？很遗憾，printf 并不支持，也没有对应的格式控制符。在实际开发中，也基本没有“输出负的八进制数或者十六进制数”这样的需求，我想可能正是因为这一点，printf 才没有提供对应的格式控制符。

下表全面地总结了不同类型的整数，以不同进制的形式输出时对应的格式控制符（--表示没有对应的格式控制符）。

	short	int	long	unsigned short	unsigned int	unsigned long
八进制	--	--	--	%ho	%o	%lo
十进制	%hd	%d	%ld	%hu	%u	%lu
十六进制	--	--	--	%hx 或者 %hX	%x 或者 %X	%lx 或者 %lX

有读者可能会问，上节我们也使用 %o 和 %x 来输出有符号数了，为什么没有发生错误呢？这是因为：

• 当以有符号数的形式输出时，printf 会读取数字所占用的内存，并把最高位作为符号位，把剩下的内存作为数值位；
• 当以无符号数的形式输出时，printf 也会读取数字所占用的内存，并把所有的内存都作为数值位对待。

对于一个有符号的正数，它的符号位是 0，当按照无符号数的形式读取时，符号位就变成了数值位，但是该位恰好是 0 而不是 1，所以对数值不会产生影响，这就好比在一个数字前面加 0，有多少个 0 都不会影响数字的值。

如果对一个有符号的负数使用 %o 或者 %x 输出，那么结果就会大相径庭，读者可以亲试。

可以说，“有符号正数的最高位是 0”这个巧合才使得 %o 和 %x 输出有符号数时不会出错。

再次强调，不管是以 %o、%u、%x 输出有符号数，还是以 %d 输出无符号数，编译器都不会报错，只是对内存的解释不同了。%o、%d、%u、%x 这些格式控制符不会关心数字在定义时到底是有符号的还是无符号的：

• 你让我输出无符号数，那我在读取内存时就不区分符号位和数值位了，我会把所有的内存都看做数值位；
• 你让我输出有符号数，那我在读取内存时会把最高位作为符号位，把剩下的内存作为数值位。

说得再直接一些，我管你在定义时是有符号数还是无符号数呢，我只关心内存，有符号数也可以按照无符号数输出，无符号数也可以按照有符号数输出，至于输出结果对不对，那我就不管了，你自己承担风险。

下面的代码进行了全面的演示：

#include <stdio.h>
int main(){
    short a = 0100;  //八进制    
    int b = -0x1;  //十六进制    
    long c = 720;  //十进制
    unsigned short m = 0xffff;  //十六进制
    unsigned int n = 0x80000000;  //十六进制
    unsigned long p = 100;  //十进制
    //以无符号的形式输出有符号数
    printf("a=%#ho, b=%#x, c=%ld\n", a, b, c);    //以有符号数的形式输出无符号类型（只能以十进制形式输出）
    printf("m=%hd, n=%d, p=%ld\n", m, n, p);    
    return 0;
}

运行结果： a=0100, b=0xffffffff, c=720 m=-1, n=-2147483648, p=100

对于绝大多数初学者来说，b、m、n 的输出结果看起来非常奇怪，甚至不能理解。按照一般的推理，b、m、n 这三个整数在内存中的存储形式分别是：

当以 %x 输出 b 时，结果应该是 0x80000001；当以 %hd、%d 输出 m、n 时，结果应该分别是 -7fff、-0。但是实际的输出结果和我们推理的结果却大相径庭，这是为什么呢？

注意，-7fff 是十六进制形式。%d 本来应该输出十进制，这里只是为了看起来方便，才改为十六进制。

其实这跟整数在内存中的存储形式以及读取方式有关。b 是一个有符号的负数，它在内存中并不是像上图演示的那样存储，而是要经过一定的转换才能写入内存；m、n 的内存虽然没有错误，但是当以 %d 输出时，并不是原样输出，而是有一个逆向的转换过程（和存储时的转换过程恰好相反）。

也就是说，整数在写入内存之前可能会发生转换，在读取时也可能会发生转换，而我们没有考虑这种转换，所以才会导致推理错误。那么，整数在写入内存前，以及在读取时究竟发生了怎样的转换呢？为什么会发生这种转换呢？我们将在《整数在内存中是如何存储的，为什么它堪称天才般的设计》一节中揭开谜底。

整数在内存中是如何存储的，为什么它堪称天才般的设计

加法和减法是计算机中最基本的运算，计算机时时刻刻都离不开它们，所以它们由硬件直接支持。为了提高加减法的运算效率，硬件电路要设计得尽量简单。

对于有符号数，内存要区分符号位和数值位，对于人脑来说，很容易辨别，但是对于计算机来说，就要设计专门的电路，这无疑增加了硬件的复杂性，增加了计算的时间。要是能把符号位和数值位等同起来，让它们一起参与运算，不再加以区分，这样硬件电路就变得简单了。

另外，加法和减法也可以合并为一种运算，就是加法运算，因为减去一个数相当于加上这个数的相反数，例如，5 - 3 等价于 5 + (-3)，10 - (-9) 等价于 10 + 9。

相反数是指数值相同，符号不同的两个数，例如，10 和 -10 就是一对相反数，-98 和 98 也是一对相反数。

如果能够实现上面的两个目标，那么只要设计一种简单的、不用区分符号位和数值位的加法电路，就能同时实现加法和减法运算，并且非常高效。实际上，这两个目标都已经实现了，真正的计算机硬件电路就是如此简单。

然而，简化硬件电路是有代价的，这个代价就是有符号数在存储和读取时都要进行转化。那么，这个转换过程究竟是怎样的呢？接下来我们就详细地讲解一下。

首先，请读者先记住下面的几个概念。

1) 原码

将一个整数转换成二进制形式，就是其原码。例如short a = 6;，a 的原码就是0000 0000 0000 0110；更改 a 的值a = -18;，此时 a 的原码就是1000 0000 0001 0010。

通俗的理解，原码就是一个整数本来的二进制形式。

2) 反码

谈到反码，正数和负数要区别对待，因为它们的反码不一样。

对于正数，它的反码就是其原码（原码和反码相同）；负数的反码是将原码中除符号位以外的所有位（数值位）取反，也就是 0 变成 1，1 变成 0。例如short a = 6;，a 的原码和反码都是0000 0000 0000 0110；更改 a 的值a = -18;，此时 a 的反码是1111 1111 1110 1101。

3) 补码

正数和负数的补码也不一样，也要区别对待。

对于正数，它的补码就是其原码（原码、反码、补码都相同）；负数的补码是其反码加 1。例如short a = 6;，a 的原码、反码、补码都是0000 0000 0000 0110；更改 a 的值a = -18;，此时 a 的补码是1111 1111 1110 1110。

可以认为，补码是在反码的基础上打了一个补丁，进行了一下修正，所以叫“补码”。

原码、反码、补码的概念只对负数有实际意义，对于正数，它们都一样。

最后我们总结一下 6 和 -18 从原码到补码的转换过程：

在计算机内存中，整数一律采用补码的形式来存储。这意味着，当读取整数时还要采用逆向的转换，也就是将补码转换为原码。将补码转换为原码也很简单：先减去 1，再将数值位取反即可。

补码到底是如何简化硬件电路的

假设 6 和 18 都是 short 类型的，现在我们要计算 6 - 18 的结果，根据运算规则，它等价于 6 + (-18)。

如果采用原码计算，那么运算过程为：

6 - 18 = 6 + (-18) = [0000 0000 0000 0110]原 + [1000 0000 0001 0010]原 = [1000 0000 0001 1000]原 = -24

直接用原码表示整数，让符号位也参与运算，对于类似上面的减法来说，结果显然是不正确的。

于是人们开始继续探索，不断试错，后来设计出了反码。下面就演示了反码运算的过程：

6 - 18 = 6 + (-18) = [0000 0000 0000 0110]反 + [1111 1111 1110 1101]反 = [1111 1111 1111 0011]反 = [1000 0000 0000 1100]原 = -12

这样一来，计算结果就正确了。

然而，这样还不算万事大吉，我们不妨将减数和被减数交换一下位置，也就是计算 18 - 6 的结果：

18 - 6 = 18 + (-6) = [0000 0000 0001 0010]反 + [1111 1111 1111 1001]反 = [1 0000 0000 0000 1011]反 = [0000 0000 0000 1011]反 = [0000 0000 0000 1011]原 = 11

按照反码计算的结果是 11，而真实的结果应该是 12 才对，它们相差了 1。

蓝色的 1 是加法运算过程中的进位，它溢出了，内存容纳不了了，所以直接截掉。

6 - 18 的结果正确，18 - 6 的结果就不正确，相差 1。按照反码来计算，是不是小数减去大数正确，大数减去小数就不对了，始终相差 1 呢？我们不妨再看两个例子，分别是 5 - 13 和 13 - 5。

5 - 13 的运算过程为：

5 - 13 = 5 + (-13) = [0000 0000 0000 0101]原 + [1000 0000 0000 1101]原 = [0000 0000 0000 0101]反 + [1111 1111 1111 0010]反 = [1111 1111 1111 0111]反 = [1000 0000 0000 1000]原 = -8

13 - 5 的运算过程为：

13 - 5 = 13 + (-5) = [0000 0000 0000 1101]原 + [1000 0000 0000 0101]原 = [0000 0000 0000 1101]反 + [1111 1111 1111 1010]反 = [1 0000 0000 0000 0111]反 = [0000 0000 0000 0111]反 = [0000 0000 0000 0111]原 = 7

这足以证明，刚才的猜想是正确的：小数减去大数不会有问题，而大数减去小数的就不对了，结果始终相差 1。

相差的这个 1 要进行纠正，但是又不能影响小数减去大数，怎么办呢？于是人们又绞尽脑汁设计出了补码，给反码打了一个“补丁”，终于把相差的 1 给纠正过来了。

下面演示了按照补码计算的过程：

6 - 18 = 6 + (-18) = [0000 0000 0000 0110]补 + [1111 1111 1110 1110]补 = [1111 1111 1111 0100]补 = [1111 1111 1111 0011]反 = [1000 0000 0000 1100]原 = -12

18 - 6 = 18 + (-6) = [0000 0000 0001 0010]补 + [1111 1111 1111 1010]补 = [1 0000 0000 0000 1100]补 = [0000 0000 0000 1100]补 = [0000 0000 0000 1100]反 = [0000 0000 0000 1100]原 = 12

5 - 13 = 5 + (-13) = [0000 0000 0000 0101]补 + [1111 1111 1111 0011]补 = [1111 1111 1111 1000]补 = [1111 1111 1111 0111]反 = [1000 0000 0000 1000]原 = -8

13 - 5 = 13 + (-5) = [0000 0000 0000 1101]补 + [1111 1111 1111 1011]补 = [1 0000 0000 0000 1000]补 = [0000 0000 0000 1000]补 = [0000 0000 0000 1000]反 = [0000 0000 0000 1000]原 = 8

你看，采用补码的形式正好把相差的 1 纠正过来，也没有影响到小数减去大数，这个“补丁”真是巧妙。

小数减去大数，结果为负数，之前（负数从反码转换为补码要加 1）加上的 1，后来（负数从补码转换为反码要减 1）还要减去，正好抵消掉，所以不会受影响。

而大数减去小数，结果为正数，之前（负数从反码转换为补码要加 1）加上的 1，后来（正数的补码和反码相同，从补码转换为反码不用减 1）就没有再减去，不能抵消掉，这就相当于给计算结果多加了一个 1。

补码这种天才般的设计，一举达成了本文开头提到的两个目标，简化了硬件电路。

除了整数的存储，小数的存储也非常巧妙，也堪称天才般的设计，它的设计者还因此获得了图灵奖（计算机界的诺贝尔奖），我们将在《小数在内存中是如何存储的，揭秘诺贝尔奖级别的设计（长篇神文）》一节中介绍。

实例分析

上一节我们还留下了一个谜团，就是有符号数以无符号的形式输出，或者无符号数以有符号的形式输出时，会得到一个奇怪的值，请看下面的代码：

#include <stdio.h>
int main(){    
    short a = 0100;  //八进制    
    int b = -0x1;  //十六进制    
    long c = 720;  //十进制      
    unsigned short m = 0xffff;  //十六进制    
    unsigned int n = 0x80000000;  //十六进制    
    unsigned long p = 100;  //十进制      
    //以无符号的形式输出有符号数    
    printf("a=%#ho, b=%#x, c=%lu\n", a, b, c);    
    //以有符号数的形式输出无符号类型（只能以十进制形式输出）    
    printf("m=%hd, n=%d, p=%ld\n", m, n, p);    
    return 0;
}

运行结果： a=0100, b=0xffffffff, c=720 m=-1, n=-2147483648, p=100

其中，b、m、n 的输出结果看起来非常奇怪。

b 是有符号数，它在内存中的存储形式（也就是补码）为：

b = -0x1 = [1000 0000 …… 0000 0001]原 = [1111 1111 …… 1111 1110]反 = [1111 1111 …… 1111 1111]补 = [0xffffffff]补

%#x表示以无符号的形式输出，而无符号数的补码和原码相同，所以不用转换了，直接输出 0xffffffff 即可。

m 和 n 是无符号数，它们在内存中的存储形式为：

m = 0xffff = [1111 1111 1111 1111]补

n = 0x80000000 = [1000 0000 …… 0000 0000]补

%hd和%d表示以有符号的形式输出，所以还要经过一个逆向的转换过程：

[1111 1111 1111 1111]补 = [1111 1111 1111 1110]反 = [1000 0000 0000 0001]原 = -1

[1000 0000 …… 0000 0000]补 = -231 = -2147483648

由此可见，-1 和 -2147483648 才是最终的输出值。

注意，[1000 0000 …… 0000 0000]补是一个特殊的补码，无法按照本节讲到的方法转换为原码，所以计算机直接规定这个补码对应的值就是 -231，至于为什么，下节我们会详细分析。

C 语言整数的取值范围以及数值溢出

short、int、long 是 C 语言中常用的三种整数类型，分别称为短整型、整型、长整型。

在现代操作系统中，short、int、long 的长度分别是 2、4、4 或者 8，它们只能存储有限的数值，当数值过大或者过小时，超出的部分会被直接截掉，数值就不能正确存储了，我们将这种现象称为溢出（Overflow）。

溢出的简单理解就是，向木桶里面倒入了过量的水，木桶盛不了了，水就流出来了。

要想知道数值什么时候溢出，就得先知道各种整数类型的取值范围。

无符号数的取值范围

计算无符号数（unsigned 类型）的取值范围（或者说最大值和最小值）很容易，将内存中的所有位（Bit）都置为 1 就是最大值，都置为 0 就是最小值。

以 unsigned char 类型为例，它的长度是 1，占用 8 位的内存，所有位都置为 1 时，它的值为 28 - 1 = 255，所有位都置为 0 时，它的值很显然为 0。由此可得，unsigned char 类型的取值范围是 0~255。

前面我们讲到，char 是一个字符类型，是用来存放字符的，但是它同时也是一个整数类型，也可以用来存放整数，请大家暂时先记住这一点，更多细节我们将在《在C语言中使用英文字符》一节中介绍。

有读者可能会对 unsigned char 的最大值有疑问，究竟是怎么计算出来的呢？下面我就讲解一下这个小技巧。

将 unsigned char 的所有位都置为 1，它在内存中的表示形式为1111 1111，最直接的计算方法就是：

20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 = 1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255

这种“按部就班”的计算方法虽然有效，但是比较麻烦，如果是 8 个字节的 long 类型，那足够你计算半个小时的了。

我们不妨换一种思路，先给 1111 1111 加上 1，然后再减去 1，这样一增一减正好抵消掉，不会影响最终的值。

给 1111 1111 加上 1 的计算过程为：

0B1111 1111 + 0B1 = 0B1 0000 0000 = 28 = 256

可以发现，1111 1111 加上 1 后需要向前进位（向第 9 位进位），剩下的 8 位都变成了 0，这样一来，只有第 9 位会影响到数值的计算，剩下的 8 位对数值都没有影响。第 9 位的权值计算起来非常容易，就是：

29-1 = 28 = 256

然后再减去 1：

28 - 1 = 256 - 1 = 255

加上 1 是为了便于计算，减去 1 是为了还原本来的值；当内存中所有的位都是 1 时，这种“凑整”的技巧非常实用。

按照这种巧妙的方法，我们可以很容易地计算出所有无符号数的取值范围（括号内为假设的长度）：

	unsigned char	unsigned short	unsigned int（4字节）	unsigned long（8字节）
最小值	0	0	0	0
最大值	28 - 1 = 255	216 - 1 = 65,535 ≈ 6.5万	232 - 1 = 4,294,967,295 ≈ 42亿	264 - 1 ≈ 1.84×1019

有符号数的取值范围

有符号数以补码的形式存储，计算取值范围也要从补码入手。我们以 char 类型为例，从下表中找出它的取值范围：

补码	反码	原码	值
1111 1111	1111 1110	1000 0001	-1
1111 1110	1111 1101	1000 0010	-2
1111 1101	1111 1100	1000 0011	-3
……	……	……	……
1000 0011	1000 0010	1111 1101	-125
1000 0010	1000 0001	1111 1110	-126
1000 0001	1000 0000	1111 1111	-127
1000 0000	--	--	-128
0111 1111	0111 1111	0111 1111	127
0111 1110	0111 1110	0111 1110	126
0111 1101	0111 1101	0111 1101	125
……	……	……	……
0000 0010	0000 0010	0000 0010	2
0000 0001	0000 0001	0000 0001	1
0000 0000	0000 0000	0000 0000	0

我们按照从大到小的顺序将补码罗列出来，很容易发现最大值和最小值。

淡黄色背景的那一行是我要重点说明的。如果按照传统的由补码计算原码的方法，那么 1000 0000 是无法计算的，因为计算反码时要减去 1，1000 0000 需要向高位借位，而高位是符号位，不能借出去，所以这就很矛盾。

是不是该把 1000 0000 作为无效的补码直接丢弃呢？然而，作为无效值就不如作为特殊值，这样还能多存储一个数字。计算机规定，1000 0000 这个特殊的补码就表示 -128。

为什么偏偏是 -128 而不是其它的数字呢？

首先，-128 使得 char 类型的取值范围保持连贯，中间没有“空隙”。

其次，我们再按照“传统”的方法计算一下 -128 的补码：

• -128 的数值位的原码是 1000 0000，共八位，而 char 的数值位只有七位，所以最高位的 1 会覆盖符号位，数值位剩下 000 0000。最终，-128 的原码为 1000 0000。
• 接着很容易计算出反码，为 1111 1111。
• 反码转换为补码时，数值位要加上 1，变为 1000 0000，而 char 的数值位只有七位，所以最高位的 1 会再次覆盖符号位，数值位剩下 000 0000。最终求得的 -128 的补码是 1000 0000。

-128 从原码转换到补码的过程中，符号位被 1 覆盖了两次，而负数的符号位本来就是 1，被 1 覆盖多少次也不会影响到数字的符号。

你看，虽然从 1000 0000 这个补码推算不出 -128，但是从 -128 却能推算出 1000 0000 这个补码，这么多么的奇妙，-128 这个特殊值选得恰到好处。

负数在存储之前要先转换为补码，“从 -128 推算出补码 1000 0000”这一点非常重要，这意味着 -128 能够正确地转换为补码，或者说能够正确的存储。

关于零值和最小值

仔细观察上表可以发现，在 char 的取值范围内只有一个零值，没有+0和-0的区别，并且多存储了一个特殊值，就是 -128，这也是采用补码的另外两个小小的优势。

如果直接采用原码存储，那么0000 0000和1000 0000将分别表示+0和-0，这样在取值范围内就存在两个相同的值，多此一举。另外，虽然最大值没有变，仍然是 127，但是最小值却变了，只能存储到 -127，不能存储 -128 了，因为 -128 的原码为 1000 0000，这个位置已经被-0占用了。

按照上面的方法，我们可以计算出所有有符号数的取值范围（括号内为假设的长度）：

	char	short	int（4个字节）	long（8个字节）
最小值	-27 = -128	-215 = -32,768 ≈ -3.2万	-231 = -2,147,483,648 ≈ -21亿	-263 ≈ -9.22×1018
最大值	27 - 1= 127	215 - 1 = 32,767 ≈ 3.2万	231 - 1 = 2,147,483,647 ≈ 21亿	263 - 1≈ 9.22×1018

上节我们还留下了一个疑问，[1000 0000 …… 0000 0000]补这个 int 类型的补码为什么对应的数值是 -231，有了本节对 char 类型的分析，相信聪明的你会举一反三，自己解开这个谜团。

数值溢出

char、short、int、long 的长度是有限的，当数值过大或者过小时，有限的几个字节就不能表示了，就会发生溢出。发生溢出时，输出结果往往会变得奇怪，请看下面的代码：

#include <stdio.h>
int main(){    
    unsigned int a = 0x100000000;    
    int b = 0xffffffff;    
    printf("a=%u, b=%d\n", a, b);    
    return 0;
}

运行结果： a=0, b=-1

变量 a 为 unsigned int 类型，长度为 4 个字节，能表示的最大值为 0xFFFFFFFF，而 0x100000000 = 0xFFFFFFFF + 1，占用33位，已超出 a 所能表示的最大值，所以发生了溢出，导致最高位的 1 被截去，剩下的 32 位都是0。也就是说，a 被存储到内存后就变成了 0，printf 从内存中读取到的也是 0。

变量 b 是 int 类型的有符号数，在内存中以补码的形式存储。0xffffffff 的数值位的原码为 1111 1111 …… 1111 1111，共 32 位，而 int 类型的数值位只有 31 位，所以最高位的 1 会覆盖符号位，数值位只留下 31 个 1，所以 b 的原码为：

1111 1111 …… 1111 1111

这也是 b 在内存中的存储形式。

当 printf 读取到 b 时，由于最高位是 1，所以会被判定为负数，要从补码转换为原码：

[1111 1111 …… 1111 1111]补 = [1111 1111 …… 1111 1110]反 = [1000 0000 …… 0000 0001]原 = -1

最终 b 的输出结果为 -1。

C 语言中的小数（float,double）

小数分为整数部分和小数部分，它们由点号.分隔，例如 0.0、75.0、4.023、0.27、-937.198 -0.27 等都是合法的小数，这是最常见的小数形式，我们将它称为十进制形式。

此外，小数也可以采用指数形式，例如 7.25×102、0.0368×105、100.22×10-2、-27.36×10-3 等。任何小数都可以用指数形式来表示。

C语言同时支持以上两种形式的小数。但是在书写时，C语言中的指数形式和数学中的指数形式有所差异。

C语言中小数的指数形式为：

aEn 或 aen

a 为尾数部分，是一个十进制数；n 为指数部分，是一个十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分。整个表达式等价于 a×10n。

指数形式的小数举例：

• 2.1E5 = 2.1×105，其中 2.1 是尾数，5 是指数。
• 3.7E-2 = 3.7×10-2，其中 3.7 是尾数，-2 是指数。
• 0.5E7 = 0.5×107，其中 0.5 是尾数，7 是指数。

C语言中常用的小数有两种类型，分别是 float 或 double；float 称为单精度浮点型，double 称为双精度浮点型。

不像整数，小数没有那么多幺蛾子，小数的长度是固定的，float 始终占用4个字节，double 始终占用8个字节。

小数的输出

小数也可以使用 printf 函数输出，包括十进制形式和指数形式，它们对应的格式控制符分别是：

• %f 以十进制形式输出 float 类型；
• %lf 以十进制形式输出 double 类型；
• %e 以指数形式输出 float 类型，输出结果中的 e 小写；
• %E 以指数形式输出 float 类型，输出结果中的 E 大写；
• %le 以指数形式输出 double 类型，输出结果中的 e 小写；
• %lE 以指数形式输出 double 类型，输出结果中的 E 大写。

下面的代码演示了小数的表示以及输出：

#include <stdio.h>
#include <stdlib.h>
int main(){    
    float a = 0.302;    
    float b = 128.101;    
    double c = 123;    
    float d = 112.64E3;    
    double e = 0.7623e-2;    
    float f = 1.23002398;    
    printf("a=%e \nb=%f \nc=%lf \nd=%lE \ne=%lf \nf=%f\n", a, b, c, d, e, f);       
    return 0;
}

运行结果： a=3.020000e-01 b=128.100998 c=123.000000 d=1.126400E+05 e=0.007623 f=1.230024

对代码的说明：

1. %f 和 %lf 默认保留六位小数，不足六位以 0 补齐，超过六位按四舍五入截断。
2. 将整数赋值给 float 变量时会变成小数。
3. 以指数形式输出小数时，输出结果为科学计数法；也就是说，尾数部分的取值为：0 ≤ 尾数 < 10。
4. b 的输出结果让人费解，才三位小数，为什么不能精确输出，而是输出一个近似值呢？这和小数在内存中的存储形式有关，很多简单的小数压根不能精确存储，所以也就不能精确输出，我们将在下节《小数在内存中是如何存储的，揭秘诺贝尔奖级别的设计（长篇神文）》中详细讲解。

另外，小数还有一种更加智能的输出方式，就是使用%g。%g 会对比小数的十进制形式和指数形式，以最短的方式来输出小数，让输出结果更加简练。所谓最短，就是输出结果占用最少的字符。

%g 使用示例：

#include <stdio.h>
#include <stdlib.h>
int main(){    
    float a = 0.00001;    
    float b = 30000000;    
    float c = 12.84;    
    float d = 1.229338455;    
    printf("a=%g \nb=%g \nc=%g \nd=%g\n", a, b, c, d);       
    return 0;
}

运行结果： a=1e-05 b=3e+07 c=12.84 d=1.22934

对各个小数的分析：

• a 的十进制形式是 0.00001，占用七个字符的位置，a 的指数形式是 1e-05，占用五个字符的位置，指数形式较短，所以以指数的形式输出。
• b 的十进制形式是 30000000，占用八个字符的位置，b 的指数形式是 3e+07，占用五个字符的位置，指数形式较短，所以以指数的形式输出。
• c 的十进制形式是 12.84，占用五个字符的位置，c 的指数形式是 1.284e+01，占用九个字符的位置，十进制形式较短，所以以十进制的形式输出。
• d 的十进制形式是 1.22934，占用七个字符的位置，d 的指数形式是 1.22934e+00，占用十一个字符的位置，十进制形式较短，所以以十进制的形式输出。

读者需要注意的两点是：

• %g 默认最多保留六位有效数字，包括整数部分和小数部分；%f 和 %e 默认保留六位小数，只包括小数部分。
• %g 不会在最后强加 0 来凑够有效数字的位数，而 %f 和 %e 会在最后强加 0 来凑够小数部分的位数。

总之，%g 要以最短的方式来输出小数，并且小数部分表现很自然，不会强加零，比 %f 和 %e 更有弹性，这在大部分情况下是符合用户习惯的。

除了 %g，还有 %lg、%G、%lG：

• %g 和 %lg 分别用来输出 float 类型和 double 类型，并且当以指数形式输出时，e小写。
• %G 和 %lG 也分别用来输出 float 类型和 double 类型，只是当以指数形式输出时，E大写。

数字的后缀

一个数字，是有默认类型的：对于整数，默认是 int 类型；对于小数，默认是 double 类型。

请看下面的例子：

long a = 100;
int b = 294;
float x = 52.55;
double y = 18.6;

100 和 294 这两个数字默认都是 int 类型的，将 100 赋值给 a，必须先从 int 类型转换为 long 类型，而将 294 赋值给 b 就不用转换了。

52.55 和 18.6 这两个数字默认都是 double 类型的，将 52.55 赋值给 x，必须先从 double 类型转换为 float 类型，而将 18.6 赋值给 y 就不用转换了。

如果不想让数字使用默认的类型，那么可以给数字加上后缀，手动指明类型：

• 在整数后面紧跟 l 或者 L（不区分大小写）表明该数字是 long 类型；
• 在小数后面紧跟 f 或者 F（不区分大小写）表明该数字是 float 类型。

请看下面的代码：

long a = 100l;
int b = 294;
short c = 32L;   
float x = 52.55f;
double y = 18.6F;
float z = 0.02;

加上后缀，虽然数字的类型变了，但这并不意味着该数字只能赋值给指定的类型，它仍然能够赋值给其他的类型，只要进行了一下类型转换就可以了。

对于初学者，很少会用到数字的后缀，加不加往往没有什么区别，也不影响实际编程，但是既然学了C语言，还是要知道这个知识点的，万一看到别人的代码这么用了，而你却不明白怎么回事，那就尴尬了。

关于数据类型的转换，我们将在《C语言数据类型转换》一节中深入探讨。

小数和整数相互赋值

在C语言中，整数和小数之间可以相互赋值：

• 将一个整数赋值给小数类型，在小数点后面加 0 就可以，加几个都无所谓。
• 将一个小数赋值给整数类型，就得把小数部分丢掉，只能取整数部分，这会改变数字本来的值。注意是直接丢掉小数部分，而不是按照四舍五入取近似值。

请看下面的代码：

#include <stdio.h>
int main(){    
    float f = 251;    
    int w = 19.427;    
    int x = 92.78;    
    int y = 0.52;    
    int z = -87.27;       
    printf("f = %f, w = %d, x = %d, y = %d, z = %d\n", f, w, x, y, z);    
    return 0;
}

运行结果：f = 251.000000, w = 19, x = 92, y = 0, z = -87

由于将小数赋值给整数类型时会“失真”，所以编译器一般会给出警告，让大家引起注意。

小数在内存中是如何存储的，揭秘诺贝尔奖级别的设计（长篇神文）

小数在内存中是以浮点数的形式存储的。浮点数并不是一种数值分类，它和整数、小数、实数等不是一个层面的概念。浮点数是数字（或者说数值）在内存中的一种存储格式，它和定点数是相对的。

C语言使用定点数格式来存储 short、int、long 类型的整数，使用浮点数格式来存储 float、double 类型的小数。整数和小数在内存中的存储格式不一样。

我们在学习C语言时，通常认为浮点数和小数是等价的，并没有严格区分它们的概念，这也并没有影响到我们的学习，原因就是浮点数和小数是绑定在一起的，只有小数才使用浮点格式来存储。

其实，整数和小数可以都使用定点格式来存储，也可以都使用浮点格式来存储，但实际情况却是，C语言使用定点格式存储整数，使用浮点格式存储小数，这是在“数值范围”和“数值精度”两项重要指标之间追求平衡的结果，稍后我会给大家带来深入的剖析。

计算机的设计是一门艺术，很多实用技术都是权衡和妥协的结果。

浮点数和定点数中的“点”指的就是小数点！对于整数，可以认为小数点后面都是零，小数部分是否存在并不影响整个数字的值，所以干脆将小数部分省略，只保留整数部分。

定点数

所谓定点数，就是指小数点的位置是固定的，不会向前或者向后移动。

假设我们用4个字节（32位）来存储无符号的定点数，并且约定，前16位表示整数部分，后16位表示小数部分，如下图所示：

如此一来，小数点就永远在第16位之后，整数部分和小数部分一目了然，不管什么时候，整数部分始终占用16位（不足16位前置补0），小数部分也始终占用16位（不足16位后置补0）。例如，在内存中存储了 10101111 00110001 01011100 11000011，那么对应的小数就是 10101111 00110001 . 01011100 11000011，非常直观。

精度

小数部分的最后一位可能是精确数字，也可能是近似数字（由四舍五入、向零舍入等不同方式得到）；除此以外，剩余的31位都是精确数字。从二进制的角度看，这种定点格式的小数，最多有 32 位有效数字，但是能保证的是 31 位；也就是说，整体的精度为 31~32 位。

数值范围

将内存中的所有位（Bit）都置为 1，小数的值最大，为 216 - 2-16，极其接近 216，换算成十进制为 65 536。将内存中最后一位（第32位）置1，其它位都置0，小数的值最小，为2-16。

这里所说的最小值不是 0 值，而是最接近 0 的那个值。

综述

用定点格式来存储小数，优点是精度高，因为所有的位都用来存储有效数字了，缺点是取值范围太小，不能表示很大或者很小的数字。

反面例子

在科学计算中，小数的取值范围很大，最大值和最小值的差距有上百个数量级，使用定点数来存储将变得非常困难。

例如，电子的质量为：

0.0000000000000000000000000009 克 = 9 × 10-28 克

太阳的质量为：

2000000000000000000000000000000000 克 = 2 × 1033 克

如果使用定点数，那么只能按照=前面的格式来存储，这将需要很大的一块内存，大到需要几十个字节。

更加科学的方案是按照=后面的指数形式来存储，这样不但节省内存，也非常直观。这种以指数的形式来存储小数的解决方案就叫做浮点数。浮点数是对定点数的升级和优化，克服了定点数取值范围太小的缺点。

浮点数

C语言标准规定，小数在内存中以科学计数法的形式来存储，具体形式为： $$ flt = (-1)sign \times mantissa \times basee \times ponent $$ 对各个部分的说明：

• flt 是要表示的小数。
• sign 用来表示 flt 的正负号，它的取值只能是 0 或 1：取值为 0 表示 flt 是正数，取值为 1 表示 flt 是负数。
• base 是基数，或者说进制，它的取值大于等于 2（例如，2 表示二进制、10 表示十进制、16 表示十六进制……）。数学中常见的科学计数法是基于十进制的，例如 6.93 × 1013；计算机中的科学计数法可以基于其它进制，例如 1.001 × 27 就是基于二进制的，它等价于 1001 0000。
• mantissa 为尾数，或者说精度，是 base 进制的小数，并且 1 ≤ mantissa ＜ base，这意味着，小数点前面只能有一位数字；
• exponent 为指数，是一个整数，可正可负，并且为了直观一般采用十进制表示。

下面我们以 19.625 为例来演示如何将小数转换为浮点格式。

当 base 取值为 10 时，19.625 的浮点形式为：

19.625 = 1.9625 × 101

当 base 取值为 2 时，将 19.625 转换成二进制为 10011.101，用浮点形式来表示为：

19.625 = 10011.101 = 1.0011101×24

19.625 整数部分的二进制形式为： 19 = 1×24 + 0×23 + 0×22 + 1×21 + 1×20 = 10011 小数部分的二进制形式为： 0.625 = 1×2-1 + 0×2-2 + 1×2-3 = 101 将整数部分和小数部分合并在一起： 19.625 = 10011.101

可以看出，当基数（进制）base 确定以后，指数 exponent 实际上就成了小数点的移动位数：

• exponent 大于零，mantissa 中的小数点右移 exponent 位即可还原小数的值；
• exponent 小于零，mantissa 中的小数点左移 exponent 位即可还原小数的值。

换句话说，将小数转换成浮点格式后，小数点的位置发生了浮动（移动），并且浮动的位数和方向由 exponent 决定，所以我们将这种表示小数的方式称为浮点数。

二进制形式的浮点数的存储

虽然C语言标准没有规定 base 使用哪种进制，但是在实际应用中，各种编译器都将 base 实现为二进制，这样不仅贴近计算机硬件（任何数据在计算机底层都以二进制形式表示），还能减少转换次数。

接下来我们就讨论一下如何将二进制形式的浮点数放入内存中。

原则上讲，上面的科学计数法公式中，符号 sign、尾数 mantissa、基数 base 和指数 exponent 都是不确定因素，都需要在内存中体现出来。但是现在基数 base 已经确定是二进制了，就不用在内存中体现出来了，这样只需要在内存中存储符号 sign、尾数 mantissa、指数 exponent 这三个不确定的元素就可以了。

仍然以 19.625 为例，将它转换成二进制形式的浮点数格式：

19.625 = 1.0011101×24

此时符号 sign 为 0，尾数 mantissa 为 1.0011101，指数 exponent 为 4。

1) 符号的存储

符号的存储很容易，就像存储 short、int 等普通整数一样，单独分配出一个位（Bit）来，用 0 表示正数，用 1 表示负数。对于 19.625，这一位的值是 0。

2) 尾数的存储

当采用二进制形式后，尾数部分的取值范围为 1 ≤ mantissa ＜ 2，这意味着：尾数的整数部分一定为 1，是一个恒定的值，这样就无需在内存中提现出来，可以将其直接截掉，只要把小数点后面的二进制数字放入内存中即可。对于 1.0011101，就是把 0011101 放入内存。

我们不妨将真实的尾数命名为 mantissa，将内存中存储的尾数命名为 mant，那么它们之间的关系为：

mantissa = 1.mant

如果 base 采用其它进制，那么尾数的整数部分就不是固定的，它有多种取值的可能，以十进制为例，尾数的整数部分可能是 1~9 之间的任何一个值，这样一来尾数的整数部分就不能省略了，必须在内存中体现出来。而将 base 设置为二进制就可以节省掉一个位（Bit）的内存，这也算是采用二进制的一点点优势。

3) 指数的存储

指数是一个整数，并且有正负之分，不但需要存储它的值，还得能区分出正负号来。

short、int、long 等类型的整数在内存中的存储采用的是补码加符号位的形式，数值在写入内存之前必须先进行转换，读取以后还要再转换一次。但是为了提高效率，避免繁琐的转换，指数的存储并没有采用补码加符号位的形式，而是设计了一套巧妙的解决方案，稍等我会为您解开谜团。

为二进制浮点数分配内存

C语言中常用的浮点数类型为 float 和 double；float 始终占用 4 个字节，double 始终占用 8 个字节。

下图演示了 float 和 double 的存储格式：

浮点数的内存被分成了三部分，分别用来存储符号 sign、尾数 mantissa 和指数 exponent ，当浮点数的类型确定后，每一部分的位数就是固定的。

符号 sign 可以不加修改直接放入内存中，尾数 mantissa 只需要将小数部分放入内存中，最让人疑惑的是指数 exponent 如何放入内存中，这也是我们在前面留下的一个谜团，下面我们以 float 为例来揭开谜底。

float 的指数部分占用 8 Bits，能表示从 0~255 的值，取其中间值 127，指数在写入内存前先加上127，读取时再减去127，正数负数就显而易见了。19.625 转换后的指数为 4，4+127 = 131，131 换算成二进制为 1000 0011，这就是 19.626 的指数部分在 float 中的最终存储形式。

先确定内存中指数部分的取值范围，得到一个中间值，写入指数时加上这个中间值，读取指数时减去这个中间值，这样符号和值就都能确定下来了。

中间值的求取有固定的公式。设中间值为 median，指数部分占用的内存为 n 位，那么中间值为：

median = 2n-1 - 1

对于 float，中间值为 28-1 - 1 = 127；对于 double，中间值为 211-1 -1 = 1023。

我们不妨将真实的指数命名为 exponent，将内存中存储的指数命名为 exp，那么它们之间的关系为：

exponent = exp - median

也可以写作：

exp = exponent + median

为了方便后续文章的编写，这里我强调一下命名：

• mantissa 表示真实的尾数，包括整数部分和小数部分；mant 表示内存中存储的尾数，只有小数部分，省略了整数部分。
• exponent 表示真实的指数，exp 表示内存中存储的指数，exponent 和 exp 并不相等，exponent 加上中间数 median 才等于 exp。

用代码验证 float 的存储

19.625 转换成二进制的指数形式为：

19.625 = 1.0011101×24

此时符号为 0；尾数为 1.0011101，截掉整数部分后为 0011101，补齐到 23 Bits 后为 001 1101 0000 0000 0000 0000；指数为 4，4+127 = 131，131 换算成二进制为 1000 0011。

综上所述，float 类型的 19.625 在内存中的值为：0 - 10000011 - 001 1101 0000 0000 0000 0000。

下面我们通过代码来验证一下：

#include <stdio.h>
#include <stdlib.h>
//浮点数结构体
typedef struct {    
    unsigned int nMant : 23;  //尾数部分    
    unsigned int nExp : 8;  //指数部分    
    unsigned int nSign : 1;  //符号位
} FP_SINGLE;

int main(){
    char strBin[33] = { 0 };    
    float f = 19.625;    
    FP_SINGLE *p = (FP_SINGLE*)&f;      
    itoa(p->nSign, strBin, 2); 
    printf("sign: %s\n", strBin);  
    itoa(p->nExp, strBin, 2);   
    printf("exp: %s\n", strBin); 
    itoa(p->nMant, strBin, 2);  
    printf("mant: %s\n", strBin);     
    return 0;
}

运行结果： sign: 0 exp: 10000011 mant: 111010000000000000000

mant 的位数不足，在前面补齐两个 0 即可。

printf() 不能直接输出二进制形式，这里我们借助 itoa() 函数将十进制数转换成二进制的字符串，再使用%s输出。itoa() 虽然不是标准函数，但是大部分编译器都支持。不过 itoa() 在 C99 标准中已经被指定为不可用函数，在一些严格遵循 C99 标准的编译器下会失效，甚至会引发错误，例如在 Xcode（使用 LLVM 编译器）下就会编译失败。如果 itoa() 无效，请使用%X输出十六进制形式，十六进制能够很方便地转换成二进制。

精度问题

对于十进制小数，整数部分转换成二进制使用“展除法”（就是不断除以 2，直到余数为 0），一个有限位数的整数一定能转换成有限位数的二进制。但是小数部分就不一定了，小数部分转换成二进制使用“乘二取整法”（就是不断乘以 2，直到小数部分为 0），一个有限位数的小数并不一定能转换成有限位数的二进制，只有末位是 5 的小数才有可能转换成有限位数的二进制，其它的小数都不行。

float 和 double 的尾数部分是有限的，固然不能容纳无限的二进制；即使小数能够转换成有限的二进制，也有可能会超出尾数部分的长度，此时也不能容纳。这样就必须“四舍五入”，将多余的二进制“处理掉”，只保留有效长度的二进制，这就涉及到了精度的问题。也就是说，浮点数不一定能保存真实的小数，很有可能保存的是一个近似值。

对于 float，尾数部分有 23 位，再加上一个隐含的整数 1，一共是 24 位。最后一位可能是精确数字，也可能是近似数字（由四舍五入、向零舍入等不同方式得到）；除此以外，剩余的23位都是精确数字。从二进制的角度看，这种浮点格式的小数，最多有 24 位有效数字，但是能保证的是 23 位；也就是说，整体的精度为 23~24 位。如果转换成十进制，224 = 16 777 216，一共8位；也就是说，最多有 8 位有效数字，但是能保证的是 7 位，从而得出整体精度为 7~8 位。

对于 double，同理可得，二进制形式的精度为 52~53 位，十进制形式的精度为 15~16 位。

IEEE 754 标准

浮点数的存储以及加减乘除运算是一个比较复杂的问题，很多小的处理器在硬件指令方面甚至不支持浮点运算，其他的则需要一个独立的协处理器来处理这种运算，只有最复杂的处理器才会在硬件指令集中支持浮点运算。省略浮点运算，可以将处理器的复杂度减半！如果硬件不支持浮点运算，那么只能通过软件来实现，代价就是需要容忍不良的性能。

PC 和智能手机上的处理器就是最复杂的处理器了，它们都能很好地支持浮点运算。

在六七十年代，计算机界对浮点数的处理比较混乱，各家厂商都有自己的一套规则，缺少统一的业界标准，这给数据交换、计算机协同工作带来了很大不便。

作为处理器行业的老大，Intel 早就意识到了这个问题，并打算一统浮点数的世界。Intel 在研发 8087 浮点数协处理器时，聘请到加州大学伯克利分校的 William Kahan 教授（最优秀的数值分析专家之一）以及他的两个伙伴，来为 8087 协处理器设计浮点数格式，他们的工作完成地如此出色，设计的浮点数格式具有足够的合理性和先进性，被 IEEE 组织采用为浮点数的业界标准，并于 1985 年正式发布，这就是 IEEE 754 标准，它等同于国际标准 ISO/IEC/IEEE 60559。

IEEE 是 Institute of Electrical and Electronics Engineers 的简写，中文意思是“电气和电子工程师协会”。

IEEE 754 简直是天才一般的设计，William Kahan 教授也因此获得了 1987 年的图灵奖。图灵奖是计算机界的“诺贝尔奖”。

目前，几乎所有的计算机都支持 IEEE 754 标准，大大改善了科学应用程序的可移植性，C语言编译器在实现浮点数时也采用了该标准。

不过，IEEE 754 标准的出现晚于C语言标准（最早的 ANSI C 标准于 1983 年发布），C语言标准并没有强制编译器采用 IEEE 754 格式，只是说要使用科学计数法的形式来表示浮点数，但是编译器在实现浮点数时，都采用了 IEEE 754 格式，这既符合C语言标准，又符合 IEEE 标准，何乐而不为。

特殊值

IEEE 754 标准规定，当指数 exp 的所有位都为 1 时，不再作为“正常”的浮点数对待，而是作为特殊值处理：

• 如果此时尾数 mant 的二进制位都为 0，则表示无穷大：
  • 如果符号 sign 为 1，则表示负无穷大；
  • 如果符号 sign 为 0，则表示正无穷大。
• 如果此时尾数 mant 的二进制位不全为 0，则表示 NaN（Not a Number），也即这是一个无效的数字，或者该数字未经初始化。

非规格化浮点数

当指数 exp 的所有二进制位都为 0 时，情况也比较特殊。

对于“正常”的浮点数，尾数 mant 隐含的整数部分为 1，并且在读取浮点数时，内存中的指数 exp 要减去中间值 median 才能还原真实的指数 exponent，也即：

mantissa = 1.mant exponent = exp - median

但是当指数 exp 的所有二进制位都为 0 时，一切都变了！尾数 mant 隐含的整数部分变成了 0，并且用 1 减去中间值 median 才能还原真实的指数 exponent，也即：

mantissa = 0.mant exponent = 1 - median

对于 float，exponent = 1 - 127 = -126，指数 exponent 的值恒为 -126；对于 double，exponent = 1 - 1023 = -1022，指数 exponent 的值恒为 -1022。

当指数 exp 的所有二进制位都是 0 时，我们将这样的浮点数称为“非规格化浮点数”；当指数 exp 的所有二进制位既不全为 0 也不全为 1 时，我们称之为“规格化浮点数”；当指数 exp 的所有二进制位都是 1 时，作为特殊值对待。 也就是说，究竟是规格化浮点数，还是非规格化浮点数，还是特殊值，完全看指数 exp。

+0 和 -0 的表示

对于非规格化浮点数，当尾数 mant 的所有二进制位都为 0 时，整个浮点数的值就为 0：

• 如果符号 sign 为 0，则表示 +0；
• 如果符号 sign 为 1，则表示 -0。

IEEE 754 为什么增加非规格化浮点数

我们以 float 类型为例来说明。

对于规格化浮点数，当尾数 mant 的所有位都为 0、指数 exp 的最低位为 1 时，浮点数的绝对值最小（符号 sign 的取值不影响绝对值），为 1.0 × 2-126，也即 2-126。

对于一般的计算，这个值已经很小了，非常接近 0 值了，但是对于科学计算，它或许还不够小，距离 0 值还不够近，非规格化浮点数就是来弥补这一缺点的：非规格化浮点数可以让最小值更小，更加接近 0 值。

对于非规格化浮点数，当尾数的最低位为 1 时，浮点数的绝对值最小，为 2-23 × 2-126 = 2-149，这个值比 2-126 小了 23 个数量级，更加即接近 0 值。

让我更加惊讶的是，规格化浮点数能够很平滑地过度到非规格化浮点数，它们之间不存在“断层”，下表能够让读者看得更加直观。

说明	float 内存	exp	exponent	mant	mantissa	浮点数的值 flt
0值 最小非规格化数 最大非规格化数	0 - 00...00 - 00...00 0 - 00...00 - 00...01 0 - 00...00 - 00...10 0 - 00...00 - 00...11 …… 0 - 00...00 - 11...10 0 - 00...00 - 11...11	0 0 0 0 …… 0 0	-126 -126 -126 -126 …… -126 -126	0 2^-23 2^-22 1.1 × 2^-22 …… 0.11...10 0.11...11	0 2^-23 2^-22 1.1 × 2^-22 …… 0.11...10 0.11...11	+0 2^-149 2^-148 1.1 × 2^-148 …… 1.11...10 × 2^-127 1.11...11 × 2^-127
最小规格化数 最大规格化数	0 - 00...01 - 00...00 0 - 00...01 - 00...01 …… 0 - 00...10 - 00...00 0 - 00...10 - 00...01 …… 0 - 11...10 - 11...10 0 - 11...10 - 11...11	1 1 …… 2 2 …… 254 254	-126 -126 …… -125 -125 127 127	0.0 0.00...01 …… 0.0 0.00...01 …… 0.11...10 0.11...11	1.0 1.00...01 …… 1.0 1.00...01 …… 1.11...10 1.11...11	1.0 × 2^-126 1.00...01 × 2^-126 …… 1.0 × 2^-125 1.00...01 × 2^-125 …… 1.11...10 × 2^127 1.11...11 × 2^127
	0 - 11...11 - 00...00	-	-	-	-	+∞
	0 - 11...11 - 00...01 …… 0 - 11...11 - 11...11	-	-	-	-	NaN

^ 表示次方，例如 2^10 表示 2 的 10 次方。

上表演示了正数时的情形，负数与此类似。请读者注意观察最大非规格化数和最小规格化数，它们是连在一起的，是平滑过渡的。

舍入模式

浮点数的尾数部分 mant 所包含的二进制位有限，不可能表示太长的数字，如果尾数部分过长，在放入内存时就必须将多余的位丢掉，取一个近似值。究竟该如何来取这个近似值，IEEE 754 列出了四种不同的舍入模式。

1) 舍入到最接近的值

就是将结果舍入为最接近且可以表示的值，这是默认的舍入模式。最近舍入模式和我们平时所见的“四舍五入”非常类似，但有一个细节不同。

对于最近舍入模式，IEEE 754 规定，当有两个最接近的可表示的值时首选“偶数”值；而对于四舍五入模式，当有两个最接近的可表示的值时要选较大的值。以十进制为例，就是对.5的舍入上采用偶数的方式，请看下面的例子。

最近舍入模式：Round(0.5) = 0、Round(1.5) = 2、Round(2.5) = 2 四舍五入模式：Round(0.5) = 1、Round(1.5) = 2、Round(2.5) = 3

2) 向 $+\infin$ 方向舍入（向上舍入）

会将结果朝正无穷大的方向舍入。标准库函数 ceil() 使用的就是这种舍入模式，例如，ceil(1.324) = 2，Ceil(-1.324) = -1。

3) 向 $+\infin$ 方向舍入（向下舍入）

会将结果朝负无穷大的方向舍入。标准库函数 floor() 使用的就是这种舍入模式，例如，floor(1.324) = 1，floor(-1.324) = -2。

4) 向 0 舍入（直接截断）

会将结果朝接近 0 的方向舍入，也就是将多余的位数直接丢掉。C语言中的类型转换使用的就是这种舍入模式，例如，(int)1.324 = 1，(int) -1.324 = -1。

总结

与定点数相比，浮点数在精度方面损失不小，但是在取值范围方面增大很多。牺牲精度，换来取值范围，这就是浮点数的整体思想。

IEEE 754 标准其实还规定了浮点数的加减乘除运算，不过本文的重点是讲解浮点数的存储，所以对于浮点数的运算不再展开讨论。

答疑解惑

上节我们还留下了一个疑问，就是用 %f 输出 128.101 时得到的是一个近似值，而不是一个精确值，这是因为，128.101 转换为浮点格式后，尾数部分过长，被丢掉了，不能“真实”地存储了。

128.101 转换成二进制为：

10000000.0001100111011011001000101101……（无限循环）

向左移动 7 位后为：

1.00000000001100111011011001000101101……

由此可见，尾数部分为：

000 0000 0001 1001 1101 1011 001000101101……

将多出的二进制丢掉后为：

000 0000 0001 1001 1101 1011

使用 printf 输出时，还需要进行还原，还原后的二进制为：

10000000.0001100111011011

转换成十进制为 128.1009979248046875，按照四舍五入的原则取 6 位小数，就是128.100998。

在 C 语言中使用英文字符

前面我们多次提到了字符串，字符串是多个字符的集合，它们由" "包围，例如"http://c.biancheng.net"、"C语言中文网"。字符串中的字符在内存中按照次序、紧挨着排列，整个字符串占用一块连续的内存。

当然，字符串也可以只包含一个字符，例如"A"、"6"；不过为了操作方便，我们一般使用专门的字符类型来处理。

初学者经常用到的字符类型是 char，它的长度是 1，只能容纳 ASCII 码表中的字符，也就是英文字符。

要想处理汉语、日语、韩语等英文之外的字符，就得使用其他的字符类型，char 是做不到的，我们将在下节《在C语言中使用中文字符》中详细讲解。

字符的表示

字符类型由单引号' '包围，字符串由双引号" "包围。

下面的例子演示了如何给 char 类型的变量赋值：

//正确的写法
char a = '1';
char b = '$';
char c = 'X';
char d = ' ';  // 空格也是一个字符
//错误的写法
char x = '中';  //char 类型不能包含 ASCII 编码之外的字符
char y = 'Ａ';  //A 是一个全角字符
char z = "t";  //字符类型应该由单引号包围

说明：在字符集中，全角字符和半角字符对应的编号（或者说编码值）不同，是两个字符；ASCII 编码只定义了半角字符，没有定义全角字符。

字符的输出

输出 char 类型的字符有两种方法，分别是：

• 使用专门的字符输出函数 putchar；
• 使用通用的格式化输出函数 printf，char 对应的格式控制符是%c。

请看下面的演示：

#include <stdio.h>
int main() {    
    char a = '1';  
    char b = '$';   
    char c = 'X';    
    char d = ' ';    
    //使用 putchar 输出   
    putchar(a); 
    putchar(d);    
    putchar(b); 
    putchar(d);    
    putchar(c); 
    putchar('\n');    
    //使用 printf 输出   
    printf("%c %c %c\n", a, b, c);  
    return 0;
}

运行结果： 1 $ X 1 $ X

putchar 函数每次只能输出一个字符，输出多个字符需要调用多次。

字符与整数

我们知道，计算机在存储字符时并不是真的要存储字符实体，而是存储该字符在字符集中的编号（也可以叫编码值）。对于 char 类型来说，它实际上存储的就是字符的 ASCII 码。

无论在哪个字符集中，字符编号都是一个整数；从这个角度考虑，字符类型和整数类型本质上没有什么区别。

我们可以给字符类型赋值一个整数，或者以整数的形式输出字符类型。反过来，也可以给整数类型赋值一个字符，或者以字符的形式输出整数类型。

请看下面的例子：

#include <stdio.h>
int main(){    
    char a = 'E';  
    char b = 70;  
    int c = 71;   
    int d = 'H';  
    printf("a: %c, %d\n", a, a);  
    printf("b: %c, %d\n", b, b); 
    printf("c: %c, %d\n", c, c);  
    printf("d: %c, %d\n", d, d);    
    return 0;
}

输出结果： a: E, 69 b: F, 70 c: G, 71 d: H, 72

在 ASCII 码表中，字符 'E'、'F'、'G'、'H' 对应的编号分别是 69、70、71、72。

a、b、c、d 实际上存储的都是整数：

• 当给 a、d 赋值一个字符时，字符会先转换成 ASCII 码再存储；
• 当给 b、c 赋值一个整数时，不需要任何转换，直接存储就可以；
• 当以 %c 输出 a、b、c、d 时，会根据 ASCII 码表将整数转换成对应的字符；
• 当以 %d 输出 a、b、c、d 时，不需要任何转换，直接输出就可以。

可以说，是 ASCII 码表将英文字符和整数关联了起来。

再谈字符串

前面我们讲到了字符串的概念，也讲到了字符串的输出，但是还没有讲如何用变量存储一个字符串。其实在C语言中没有专门的字符串类型，我们只能使用数组或者指针来间接地存储字符串。

在这里讲字符串很矛盾，虽然我们暂时还没有学到数组和指针，无法从原理上深入分析，但是字符串是常用的，又不得不说一下。所以本节我不会讲解太多，大家只需要死记硬背下面的两种表示形式即可：

char str1[] = "Hello world";
char *str2 = "Hello world";

str1 和 str2 是字符串的名字，后边的[ ]和前边的*是固定的写法。初学者暂时可以认为这两种存储方式是等价的，它们都可以通过专用的 puts 函数和通用的 printf 函数输出。

完整的字符串演示：

#include <stdio.h>
int main(){    
    char web_url[] = "Hello world";    
    char *web_name = "Hello world";    
    puts(web_url);    
    puts(web_name);    
    printf("%s\n%s\n", web_url, web_name);    
    return 0;
}

在 C 语言中使用中文字符

大部分C语言教材对中文字符的处理讳莫如深，甚至只字不提，导致很多初学者认为C语言只能处理英文，而不支持中文。其实C语言是一门全球化的编程语言，它支持世界上任何一个国家的语言文化，包括中文、日语、韩语等。

中文字符的存储

正确地存储中文字符需要解决两个问题。

1) 足够长的数据类型

char 只能处理 ASCII 编码中的英文字符，是因为 char 类型太短，只有一个字节，容纳不下我大中华几万个汉字，要想处理中文字符，必须得使用更长的数据类型。

一个字符在存储之前会转换成它在字符集中的编号，而这样的编号是一个整数，所以我们可以用整数类型来存储一个字符，比如 unsigned short、unsigned int、unsigned long 等。

2) 选择包含中文的字符集

C语言规定，对于汉语、日语、韩语等 ASCII 编码之外的单个字符，也就是专门的字符类型，要使用宽字符的编码方式。常见的宽字符编码有 UTF-16 和 UTF-32，它们都是基于 Unicode 字符集的，能够支持全球的语言文化。

在真正实现时，微软编译器（内嵌于 Visual Studio 或者 Visual C++ 中）采用 UTF-16 编码，使用 2 个字节存储一个字符，用 unsigned short 类型就可以容纳。GCC、LLVM/Clang（内嵌于 Xcode 中）采用 UTF-32 编码，使用 4 个字节存储字符，用 unsigned int 类型就可以容纳。

对于编号较小的字符，UTF-16 采用两个字节存储；对于编号较大的字符，UTF-16 使用四个字节存储。但是，全球常用的字符也就几万个，使用两个字节存储足以，只有极其罕见，或者非常古老的字符才会用到四个字节。

微软编译器使用两个字节来存储 UTF-16 编码的字符，虽然不能囊括所有的 Unicode 字符，但是也足以容纳全球的常见字符了，基本满足了软件开发的需求。使用两个字节存储的另外一个好处是可以节省内存，而使用四个字节会浪费 50% 以上的内存。

你看，不同的编译器可以使用不同的整数类型。如果我们的代码使用 unsigned int 来存储宽字符，那么在微软编译器下就是一种浪费；如果我们的代码使用 unsigned short 来存储宽字符，那么在 GCC、LLVM/Clang 下就不够。

为了解决这个问题，C语言推出了一种新的类型，叫做 wchar_t。w 是 wide 的首字母，t 是 type 的首字符，wchar_t 的意思就是宽字符类型。wchar_t 的长度由编译器决定：

• 在微软编译器下，它的长度是 2，等价于 unsigned short；
• 在GCC、LLVM/Clang 下，它的长度是 4，等价于 unsigned int。

wchar_t 其实是用 typedef 关键字定义的一个别名，我们会在《C语言typedef的用法详解》一节中深入讲解，大家暂时只需要记住，wchar_t 在不同的编译器下长度不一样。

wchar_t 类型位于 <wchar.h> 头文件中，它使得代码在具有良好移植性的同时，也节省了不少内存，以后我们就用它来存储宽字符。

上节我们讲到，单独的字符由单引号' '包围，例如'B'、'@'、'9'等；但是，这样的字符只能使用 ASCII 编码，要想使用宽字符的编码方式，就得加上L前缀，例如L'A'、L'9'、L'中'、L'国'、L'。'。

注意，加上L前缀后，所有的字符都将成为宽字符，占用 2 个字节或者 4 个字节的内存，包括 ASCII 中的英文字符。

下面的例子演示了如何存储宽字符（注意引入 <wchar.h> 头文件）：

wchar_t a = L'A';  //英文字符（基本拉丁字符）
wchar_t b = L'9';  //英文数字（阿拉伯数字）
wchar_t c = L'中';  //中文汉字
wchar_t d = L'国';  //中文汉字
wchar_t e = L'。';  //中文标点
wchar_t f = L'ヅ';  //日文片假名
wchar_t g = L'♥';  //特殊符号
wchar_t h = L'༄';  //藏文

在以后的编程中，我们将不加L前缀的字符称为窄字符，将加上L前缀的字符称为宽字符。窄字符使用 ASCII 编码，宽字符使用 UTF-16 或者 UTF-32 编码。

宽字符的输出

putchar、printf 只能输出不加L前缀的窄字符，对加了L前缀的宽字符无能为力，我们必须使用 <wchar.h> 头文件中的宽字符输出函数，它们分别是 putwchar 和 wprintf：

• putwchar 函数专门用来输出一个宽字符，它和 putchar 的用法类似；
• wprintf 是通用的、格式化的宽字符输出函数，它除了可以输出单个宽字符，还可以输出宽字符串（稍后讲解）。宽字符对应的格式控制符为%lc。

另外，在输出宽字符之前还要使用 setlocale 函数进行本地化设置，告诉程序如何才能正确地处理各个国家的语言文化。由于大家基础还不够，关于本地化设置的内容我们不再展开讲解，请大家先记住这种写法。

如果希望设置为中文简体环境，在 Windows 下请写作：

setlocale(LC_ALL, "zh-CN");

在 Linux 和 Mac OS 下请写作：

setlocale(LC_ALL, "zh_CN");

setlocale 函数位于 <locale.h> 头文件中，我们必须引入它。

下面的代码完整地演示了宽字符的输出：

#include <wchar.h>
#include <locale.h>
int main(){   
    wchar_t a = L'A';  //英文字符（基本拉丁字符）  
    wchar_t b = L'9';  //英文数字（阿拉伯数字）   
    wchar_t c = L'中';  //中文汉字   
    wchar_t d = L'国';  //中文汉字  
    wchar_t e = L'。';  //中文标点   
    wchar_t f = L'ヅ';  //日文片假名   
    wchar_t g = L'♥';  //特殊符号  
    wchar_t h = L'༄';  //藏文  
    //将本地环境设置为简体中文    
    setlocale(LC_ALL, "zh_CN");   
    //使用专门的 putwchar 输出宽字符  
    putwchar(a); 
    putwchar(b); 
    putwchar(c);  
    putwchar(d);  
    putwchar(e);  
    putwchar(f); 
    putwchar(g); 
    putwchar(h); 
    putwchar(L'\n');  //只能使用宽字符     
    //使用通用的 wprintf 输出宽字符  
    wprintf(    
        L"Wide chars: %lc %lc %lc %lc %lc %lc %lc %lc\n",  //必须使用宽字符串  
        a, b, c, d, e, f, g, h  
    );        
    return 0;
}

运行结果： A9中国。ヅ♥༄ Wide chars: A 9 中 国 。 ヅ ♥ ༄

宽字符串

给字符串加上L前缀就变成了宽字符串，它包含的每个字符都是宽字符，一律采用 UTF-16 或者 UTF-32 编码。输出宽字符串可以使用 <wchar.h> 头文件中的 wprintf 函数，对应的格式控制符是%ls。

下面的代码演示了如何使用宽字符串：

#include <wchar.h>
#include <locale.h>
int main(){ 
    wchar_t web_url[] = L"http://work.lynchow.com";  
    wchar_t *web_name = L"秋城技谈";   
    //将本地环境设置为简体中文
    setlocale(LC_ALL, "zh_CN");   
    //使用通用的 wprintf 输出宽字符   
    wprintf(L"web_url: %ls \nweb_name: %ls\n", web_url, web_name);   
    return 0;
}

运行结果： web_url: http://work.lynchow.com web_name: 秋城技谈

其实，不加L前缀的窄字符串也可以处理中文，它和加上了L前缀的宽字符串有什么区别呢？我们将在下节《C语言到底使用什么编码？谁说C语言使用ASCII码，真是荒谬！》中详细讲解。

C 语言到底使用什么编码？谁说C语言使用ASCII码，真是荒谬！

C语言是 70 年代的产物，那个时候只有 ASCII，各个国家的字符编码都还未成熟，所以C语言不可能从底层支持 GB2312、GBK、Big5、Shift-JIS 等国家编码，也不可能支持 Unicode 字符集。

稍微有点C语言基本功的读者可能认为C语言使用 ASCII 编码，字符在存储时会转换成对应的 ASCII 码值，这也是错误的，你被大学老师和教材误导了！在C语言中，只有 char 类型的窄字符才使用 ASCII 编码，char 类型的窄字符串、wchar_t 类型的宽字符和宽字符串都不使用 ASCII 编码！

wchar_t 类型的宽字符和宽字符串使用 UTF-16 或者 UTF-32 编码，这个在上节已经讲到了，现在只剩下 char 类型的窄字符串（下面称为窄字符串）没有讲了，这就是本节的重点。

对于窄字符串，C语言并没有规定使用哪一种特定的编码，只要选用的编码能够适应当前的环境即可，所以，窄字符串的编码与操作系统和编译器有关。

但是，可以肯定的说，在现代计算机中，窄字符串已经不再使用 ASCII 编码了，因为 ASCII 编码只能显示字母、数字等英文字符，对汉语、日语、韩语等其它地区的字符无能为力。

讨论窄字符串的编码要从以下两个方面下手。

源文件使用什么编码

源文件用来保存我们编写的代码，它最终会被存储到本地硬盘，或者远程服务器，这个时候就要尽量压缩文件体积，以节省硬盘空间或者网络流量，而代码中大部分的字符都是 ASCII 编码中的字符，用一个字节足以容纳，所以 UTF-8 编码是一个不错的选择。

UTF-8 兼容 ASCII，代码中的大部分字符可以用一个字节保存；另外 UTF-8 基于 Unicode，支持全世界的字符，我们编写的代码可以给全球的程序员使用，真正做到技术无国界。

常见的 IDE 或者编辑器，例如 Xcode、Sublime Text、Gedit、Vim 等，在创建源文件时一般也默认使用 UTF-8 编码。但是 Visual Studio 是个奇葩，它默认使用本地编码来创建源文件。

所谓本地编码，就是像 GBK、Big5、Shift-JIS 等这样的国家编码（地区编码）；针对不同国家发行的操作系统，默认的本地编码一般不同。简体中文本的 Windows 默认的本地编码是 GBK。

对于编译器来说，它往往支持多种编码格式的源文件。微软编译器、GCC、LLVM/Clang（内嵌于 Xcode 中）都支持 UTF-8 和本地编码的源文件，不过微软编译器还支持 UTF-16 编码的源文件。如果考虑到源文件的通用性，就只能使用 UTF-8 和本地编码了。

窄字符串使用什么编码

前面讲到，用 puts 或者 printf 可以输出窄字符串，代码如下：

#include <stdio.h>
int main(){    
    puts("秋城技谈"); 
    printf("http://work.lynchow.com");   
    return 0;
}

"C语言中文网"和"http://c.biancheng.net"就是需要被处理的窄字符串，程序运行后，它们会被载入到内存中。你看，这里面还包含了中文，肯定不能使用 ASCII 编码了。

1. 微软编译器使用本地编码来保存这些字符。不同地区的 Windows 版本默认的本地编码不一样，所以，同样的窄字符串在不同的 Windows 版本下使用的编码也不一样。对于简体中文版的 Windows，使用的是 GBK 编码。

2. GCC、LLVM/Clang 编译器使用和源文件相同的编码来保存这些字符：如果源文件使用的是 UTF-8 编码，那么这些字符也使用 UTF-8 编码；如果源文件使用的是 GBK 编码，那么这些字符也使用 GBK 编码。

你看，对于代码中需要被处理的窄字符串，不同的编译器差别还是挺大的。不过可以肯定的是，这些字符始终都使用窄字符（多字节字符）编码。

正是由于这些字符使用 UTF-8、GBK 等编码，而不是使用 ASCII 编码，所以它们才能包含中文。

那么，为什么很多初学者会误认为C语言使用 ASCII 编码呢？

不管是在课堂跟着老师学习，还是通过互联网自学，初学者都是从处理英文开始的，对于英文来说，使用 GBK、UTF-8、ASCII 都是一样的，GBK、UTF-8 都兼容 ASCII，初学者根本察觉不出用了哪种编码。

另外，很多大学老师和书籍作者也经常会念叨，字符在存储时会被转换成对应的 ASCII 码，在读取时又会从 ASCII 码转换成对应的字符实体，大家需要熟悉 ASCII 编码，它是C语言处理字符的基础，这从很大程度上给初学者造成一种错误印象：C语言和 ASCII 编码是绑定的，C语言使用 ASCII 编码。

总结

对于 char 类型的窄字符，始终使用 ASCII 编码。

对于 wchar_t 类型的宽字符和宽字符串，使用 UTF-16 或者 UTF-32 编码，它们都是基于 Unicode 字符集的。

对于 char 类型的窄字符串，微软编译器使用本地编码，GCC、LLVM/Clang 使用和源文件编码相同的编码。

另外，处理窄字符和处理宽字符使用的函数也不一样：

• <stdio.h> 头文件中的 putchar、puts、printf 函数只能用来处理窄字符；
• <wchar.h> 头文件中的 putwchar、wprintf 函数只能用来处理宽字符。

你看，仅仅是字符的处理，C语言就能玩出这么多花样，让人捉摸不透，不容易学习。这是因为，C语言是一种较为底层和古老的语言，既有历史遗留问题，又有贴近计算机底层的特性。不过，一旦搞明白这些繁杂的底层问题，你的编程内功将精进一个层次，这也许就是学习C语言的乐趣。

【拓展】编码字符集和运行字符集

站在专业的角度讲，源文件使用的字符集被称为编码字符集，也就是写代码的时候使用的字符集；程序中的字符或者字符串使用的字符集被称为运行字符集，也就是程序运行后使用的字符集。

源文件需要保存到硬盘，或者在网络上传输，使用的编码要尽量节省存储空间，同时要方便跨国交流，所以一般使用 UTF-8，这就是选择编码字符集的标准。

程序中的字符或者字符串，在程序运行后必须被载入到内存，才能进行后续的处理，对于这些字符来说，要尽量选用能够提高处理速度的编码，例如 UTF-16 和 UTF-32 编码就能够快速定位（查找）字符。

编码字符集是站在存储和传输的角度，运行字符集是站在处理或者操作的角度，所以它们并不一定相同。

C 语言转义字符

字符集（Character Set）为每个字符分配了唯一的编号，我们不妨将它称为编码值。在C语言中，一个字符除了可以用它的实体（也就是真正的字符）表示，还可以用编码值表示。这种使用编码值来间接地表示字符的方式称为转义字符（Escape Character）。

转义字符以\或者\x开头，以\开头表示后跟八进制形式的编码值，以\x开头表示后跟十六进制形式的编码值。对于转义字符来说，只能使用八进制或者十六进制。

字符 1、2、3、a、b、c 对应的 ASCII 码的八进制形式分别是 61、62、63、141、142、143，十六进制形式分别是 31、32、33、61、62、63。下面的例子演示了转义字符的用法：

char a = '\61';  //字符1
char b = '\141';  //字符a
char c = '\x31';  //字符1
char d = '\x61';  //字符a
char *str1 = "\x31\x32\x33\x61\x62\x63";  //字符串"123abc"
char *str2 = "\61\62\63\141\142\143";  //字符串"123abc"
char *str3 = "The string is: \61\62\63\x61\x62\x63"  //混用八进制和十六进制形式

转义字符既可以用于单个字符，也可以用于字符串，并且一个字符串中可以同时使用八进制形式和十六进制形式。

一个完整的例子：

#include <stdio.h>
int main(){   
    puts("\x68\164\164\x70://work.lynchow.\x6e\145\x74");  
    return 0;
}

运行结果： http://work.lynchow.net

转义字符的初衷是用于 ASCII 编码，所以它的取值范围有限：

• 八进制形式的转义字符最多后跟三个数字，也即\ddd，最大取值是\177；
• 十六进制形式的转义字符最多后跟两个数字，也即\xdd，最大取值是\x7f。

超出范围的转义字符的行为是未定义的，有的编译器会将编码值直接输出，有的编译器会报错。

对于 ASCII 编码，0~31（十进制）范围内的字符为控制字符，它们都是看不见的，不能在显示器上显示，甚至无法从键盘输入，只能用转义字符的形式来表示。不过，直接使用 ASCII 码记忆不方便，也不容易理解，所以，针对常用的控制字符，C语言又定义了简写方式，完整的列表如下：

转义字符	意义	ASCII码值（十进制）
\a	响铃(BEL)	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT)	009
\v	垂直制表(VT)	011
'	单引号	039
"	双引号	034
\	反斜杠	092

\n和\t是最常用的两个转义字符：

• \n用来换行，让文本从下一行的开头输出，前面的章节中已经多次使用；
• \t用来占位，一般相当于四个空格，或者 tab 键的功能。

单引号、双引号、反斜杠是特殊的字符，不能直接表示：

• 单引号是字符类型的开头和结尾，要使用\'表示，也即'\''；
• 双引号是字符串的开头和结尾，要使用\"表示，也即"abc\"123"；
• 反斜杠是转义字符的开头，要使用\\表示，也即'\\'，或者"abc\\123"。

转义字符示例：

#include <stdio.h>
int main(){ 
    puts("C\tC++\tJava\n\"C\" first appeared!"); 
    return 0;
}

运行结果： C C++ Java "C" first appeared!

C 语言标识符、关键字、注释、表达式和语句

这一节主要讲解C语言中的几个基本概念。

标识符

定义变量时，我们使用了诸如 a、abc、mn123 这样的名字，它们都是程序员自己起的，一般能够表达出变量的作用，这叫做标识符（Identifier）。

标识符就是程序员自己起的名字，除了变量名，后面还会讲到函数名、宏名、结构体名等，它们都是标识符。不过，名字也不能随便起，要遵守规范；C语言规定，标识符只能由字母（A~Z, a~z）、数字（0~9）和下划线（_）组成，并且第一个字符必须是字母或下划线，不能是数字。

以下是合法的标识符： a, x, x3, BOOK_1, sum5

以下是非法的标识符：

• 3s 不能以数字开头
• sT 出现非法字符
• -3x 不能以减号（-）开头
• bowy-1 出现非法字符减号（-）

在使用标识符时还必须注意以下几点：

• C语言虽然不限制标识符的长度，但是它受到不同编译器的限制，同时也受到操作系统的限制。例如在某个编译器中规定标识符前128位有效，当两个标识符前128位相同时，则被认为是同一个标识符。
• 在标识符中，大小写是有区别的，例如 BOOK 和 book 是两个不同的标识符。
• 标识符虽然可由程序员随意定义，但标识符是用于标识某个量的符号，因此，命名应尽量有相应的意义，以便于阅读和理解，作到“顾名思义”。

关键字

关键字（Keywords）是由C语言规定的具有特定意义的字符串，通常也称为保留字，例如 int、char、long、float、unsigned 等。我们定义的标识符不能与关键字相同，否则会出现错误。

你也可以将关键字理解为具有特殊含义的标识符，它们已经被系统使用，我们不能再使用了。

标准C语言中一共规定了32个关键字，后续我们会一一讲解。

注释

注释（Comments）可以出现在代码中的任何位置，用来向用户提示或解释代码的含义。程序编译时，会忽略注释，不做任何处理，就好像它不存在一样。

C语言支持单行注释和多行注释：

• 单行注释以//开头，直到本行末尾（不能换行）；
• 多行注释以/*开头，以*/结尾，注释内容可以有一行或多行。

一个使用注释的例子：

/*  
Powered by: work.lynchow.com  
Author: jingxun  
Date: 2017-10-25
*/
#include <stdio.h>
int main(){   
    /* puts 会在末尾自动添加换行符 */  
    puts("http://work.lynchow.com");   
    printf("秋城技谈\n");  //printf要手动添加换行符    
    return 0;
}

运行结果： http://work.lynchow.com 秋城技谈

在调试程序的过程中可以将暂时将不使用的语句注释掉，使编译器跳过不作处理，待调试结束后再去掉注释。

需要注意的是，多行注释不能嵌套使用。例如下面的注释是错误的：

/*C语言/*中文*/网*/

而下面的注释是正确的：

/*秋城技谈*/  
/*work.lynchow.com*/

表达式（Expression）和语句（Statement）

其实前面我们已经多次提到了「表达式」和「语句」这两个概念，相信读者在耳濡目染之中也已经略知一二了，本节我们不妨再重点介绍一下。

表达式（Expression）和语句（Statement）的概念在C语言中并没有明确的定义：

• 表达式可以看做一个计算的公式，往往由数据、变量、运算符等组成，例如3*4+5、a=c=d等，表达式的结果必定是一个值；
• 语句的范围更加广泛，不一定是计算，不一定有值，可以是某个操作、某个函数、选择结构、循环等。

赶紧划重点：

• 表达式必须有一个执行结果，这个结果必须是一个值，例如3*4+5的结果 17，a=c=d=10的结果是 10，printf("hello")的结果是 5（printf 的返回值是成功打印的字符的个数）。
• 以分号;结束的往往称为语句，而不是表达式，例如3*4+5;、a=c=d;等。

语言加减乘除运算

加减乘除是常见的数学运算，C语言当然支持，不过，C语言中的运算符号与数学中的略有不同，请见下表。

	加法	减法	乘法	除法	求余数（取余）
数学	+	-	×	÷	无
C语言	+	-	*	/	%

C语言中的加号、减号与数学中的一样，乘号、除号不同；另外C语言还多了一个求余数的运算符，就是 %。

下面的代码演示了如何在C语言中进行加减乘除运算：

#include <stdio.h>
int main(){   
    int a = 12;
    int b = 100;   
    float c = 8.5;   
    int m = a + b;   
    float n = b * c;  
    double p = a / c; 
    int q = b % a;  
    printf("m=%d, n=%f, p=%lf, q=%d\n", m, n, p, q);   
    return 0;
}

输出结果：m=112, n=850.000000, p=1.411765, q=4

你也可以让数字直接参与运算：

#include <stdio.h>
int main(){    
    int a = 12;  
    int b = 100;  
    float c = 8.9;   
    int m = a - b;  // 变量参与运算   
    int n = a + 239;  // 有变量也有数字 
    double p = 12.7 * 34.3;  // 数字直接参与运算
    printf("m=%d, n=%d, p=%lf\n", m, n, p);   
    printf("m*2=%d, 6/3=%d, m*n=%ld\n", m*2, 6/3, m*n);  
    return 0;
}

输出结果： m=-88, n=251, p=435.610000 m2=-176, 6/3=2, mn=-22088

对除法的说明

C语言中的除法运算有点奇怪，不同类型的除数和被除数会导致不同类型的运算结果：

• 当除数和被除数都是整数时，运算结果也是整数；如果不能整除，那么就直接丢掉小数部分，只保留整数部分，这跟将小数赋值给整数类型是一个道理。
• 一旦除数和被除数中有一个是小数，那么运算结果也是小数，并且是 double 类型的小数。

请看下面的代码：

#include <stdio.h>
int main(){  
    int a = 100;  
    int b = 12; 
    float c = 12.0;   
    double p = a / b; 
    double q = a / c;  
    printf("p=%lf, q=%lf\n", p, q);  
    return 0;
}

运行结果：p=8.000000, q=8.333333

a 和 b 都是整数，a / b 的结果也是整数，所以赋值给 p 变量的也是一个整数，这个整数就是 8。

另外需要注意的一点是除数不能为 0，因为任何一个数字除以 0 都没有意义。

然而，编译器对这个错误一般无能为力，很多情况下，编译器在编译阶段根本无法计算出除数的值，不能进行有效预测，“除数为 0”这个错误只能等到程序运行后才能发现，而程序一旦在运行阶段出现任何错误，只能有一个结果，那就是崩溃，并被操作系统终止运行。

请看下面的代码：

#include <stdio.h>
int main(){   
    int a, b;   
    scanf("%d %d", &a, &b);  //从控制台读取数据并分别赋值给a和b   
    printf("result=%d\n", a / b);    
    return 0;
}

这段代码用到了一个新的函数，就是 scanf。scanf 和 printf 的功能相反，printf 用来输出数据，scanf 用来读取数据。此处，scanf 会从控制台读取两个整数，并分别赋值给 a 和 b。关于 scanf 的具体用法，我们将在《C语言scanf：读取从键盘输入的数据（含输入格式汇总表）》一节中详细讲解，这里大家只要知道它的作用就可以了，不必求甚解。

程序开头定义了两个 int 类型的变量 a 和 b，程序运行后，从控制台读取用户输入的整数，并分别赋值给 a 和 b，这个时候才能知道 a 和 b 的具体值，才能知道除数 b 是不是 0。像这种情况，b 的值在程序运行期间会改变，跟用户输入的数据有关，编译器根本无法预测，所以就没法及时发现“除数为 0”这个错误。

对取余运算的说明

取余，也就是求余数，使用的运算符是 %。C语言中的取余运算只能针对整数，也就是说，% 的两边都必须是整数，不能出现小数，否则编译器会报错。

另外，余数可以是正数也可以是负数，由 % 左边的整数决定：

• 如果 % 左边是正数，那么余数也是正数；
• 如果 % 左边是负数，那么余数也是负数。

请看下面的例子：

#include <stdio.h>
int main(){  
    printf(    
        "100%%12=%d \n100%%-12=%d \n-100%%12=%d \n-100%%-12=%d \n",    
        100%12, 100%-12, -100%12, -100%-12  
    );    
    return 0;
}

运行结果： 100%12=4 100%-12=4 -100%12=-4 -100%-12=-4

在 printf 中，% 是格式控制符的开头，是一个特殊的字符，不能直接输出；要想输出 %，必须在它的前面再加一个 %，这个时候 % 就变成了普通的字符，而不是用来表示格式控制符了。

加减乘除运算的简写

有时候我们希望对一个变量进行某种运算，然后再把运算结果赋值给变量本身，请看下面的例子：

#include <stdio.h>
int main(){ 
    int a = 12; 
    int b = 10;  
    printf("a=%d\n", a);  
    a = a + 8;  
    printf("a=%d\n", a);  
    a = a * b;  
    printf("a=%d\n", a);  
    return 0;
}

输出结果： a=12 a=20 a=200

a = a + 8相当于用原来 a 的值（也即12）加上 8，再把运算结果（也即20）赋值给 a，此时 a 的值就变成了 20。

a = a * b相当于用原来 a 的值（也即20）乘以 b 的值（也即10），再把运算结果（也即200）赋值给 a，此时 a 的值就变成了 200。

以上的操作，可以理解为对变量本身进行某种运算。

在C语言中，对变量本身进行运算可以有简写形式。假设用 # 来表示某种运算符，那么

a = a # b

可以简写为：

a #= b

# 表示 +、-、*、/、% 中的任何一种运算符。

上例中a = a + 8可以简写为a += 8，a = a * b可以简写为a *= b。

下面的简写形式也是正确的：

int a = 10, b = 20;
a += 10;  //相当于 a = a + 10;
a *= (b-10);  //相当于 a = a * (b-10);
a -= (a+20);  //相当于 a = a - (a+20);

注意：a #= b 仅是一种简写形式，不会影响程序的执行效率。

C 语言自增(++)和自减(--)

一个整数类型的变量自身加 1 可以这样写：

a = a + 1;

或者

a += 1;

不过，C语言还支持另外一种更加简洁的写法，就是：

a++;

或者

++a;

这种写法叫做自加或自增，意思很明确，就是每次自身加 1。

相应的，也有a--和--a，它们叫做自减，表示自身减 1。

++和--分别称为自增运算符和自减运算符，它们在循环结构（后续章节会讲解）中使用很频繁。

自增和自减的示例：

#include <stdio.h>
int main(){   
    int a = 10, b = 20;  
    printf("a=%d, b=%d\n", a, b);  
    ++a;  
    --b;   
    printf("a=%d, b=%d\n", a, b);  
    a++;  
    b--;  
    printf("a=%d, b=%d\n", a, b);   
    return 0;
}

运行结果： a=10, b=20 a=11, b=19 a=12, b=18

自增自减完成后，会用新值替换旧值，将新值保存在当前变量中。

自增自减的结果必须得有变量来接收，所以自增自减只能针对变量，不能针对数字，例如10++就是错误的。

需要重点说明的是，++ 在变量前面和后面是有区别的：

• ++ 在前面叫做前自增（例如 ++a）。前自增先进行自增运算，再进行其他操作。
• ++ 在后面叫做后自增（例如 a++）。后自增先进行其他操作，再进行自增运算。

自减（--）也一样，有前自减和后自减之分。

下面的例子能更好地说明前自增（前自减）和后自增（后自减）的区别：

#include <stdio.h>
int main(){   
    int a = 10, b = 20, c = 30, d = 40;  
    int a1 = ++a, b1 = b++, c1 = --c, d1 = d--;    
    printf("a=%d, a1=%d\n", a, a1);  
    printf("b=%d, b1=%d\n", b, b1); 
    printf("c=%d, c1=%d\n", c, c1);  
    printf("d=%d, d1=%d\n", d, d1);   
    return 0;
}

输出结果： a=11, a1=11 b=21, b1=20 c=29, c1=29 d=39, d1=40

a、b、c、d 的输出结果相信大家没有疑问，下面重点分析a1、b1、c1、d1：

1. 对于a1=++a，先执行 ++a，结果为 11，再将 11 赋值给 a1，所以 a1 的最终值为11。而 a 经过自增，最终的值也为 11。

2. 对于b1=b++，b 的值并不会立马加 1，而是先把 b 原来的值交给 b1，然后再加 1。b 原来的值为 20，所以 b1 的值也就为 20。而 b 经过自增，最终值为 21。

3. 对于c1=--c，先执行 --c，结果为 29，再将 29 赋值给c1，所以 c1 的最终值为 29。而 c 经过自减，最终的值也为 29。

4. 对于d1=d--，d 的值并不会立马减 1，而是先把 d 原来的值交给 d1，然后再减 1。d 原来的值为 40，所以 d1 的值也就为 40。而 d 经过自减，最终值为 39。

可以看出：a1=++a;会先进行自增操作，再进行赋值操作；而b1=b++;会先进行赋值操作，再进行自增操作。c1=--c;和d1=d--;也是如此。

为了强化记忆，我们再来看一个自增自减的综合示例：

#include <stdio.h>
int main(){  
    int a = 12, b = 1;  
    int c = a - (b--);  // ①    
    int d = (++a) - (--b);  // ②   
    printf("c=%d, d=%d\n", c, d); 
    return 0;}

输出结果： c=11, d=14

我们来分析一下：

1. 执行语句①时，因为是后自减，会先进行a-b运算，结果是 11，然后 b 再自减，就变成了 0；最后再将a-b的结果（也就是11）交给 c，所以 c 的值是 11。

2. 执行语句②之前，b 的值已经变成 0。对于d=(++a)-(--b)，a 会先自增，变成 13，然后 b 再自减，变成 -1，最后再计算13-(-1)，结果是 14，交给 d，所以 d 最终是 14。

C语言变量的定义位置以及初始值

在前面的章节中，我们一直将变量定义在 main 函数里面，其实，变量也可以定义在 main 函数外面，例如：

#include <stdio.h>
//在main函数外部定义变量
int n = 100;
char c = '@';

int main(){ 
    //在main函数内部定义变量   
    float f = 89.5;   
    char *str = "http://work.lynchow.com";  
    //输出变量    
    printf("n: %d\nc: %c\nf: %f\nstr: %s\n", n, c, f, str);  
    return 0;
}

运行结果： n: 100 c: @ f: 89.500000 str: http://work.lynchow.com

我们在 main 函数外部定义了变量 n 和 c，在 main 函数内部定义了变量 f 和 str，它们都可以通过 printf 输出。也就是说，在函数外部定义的变量在函数内部也可以使用。

在函数外部定义的变量叫做全局变量（Global Variable），在函数内部定义的变量叫做局部变量（Local Variable），它们的区别将会在《C语言函数》一章中详细说明，这里大家只要记住，变量也可以在 main 函数外面定义即可，本节我们重点讲解的是局部变量。

局部变量的定义位置

为了让编译器方便给变量分配内存，C89 标准规定，所有的局部变量（函数内部的变量）都必须定义在函数的开头位置，在定义完所有变量之前不能有其它的表达式。

这种规定太过死板，虽然变量定义在函数开头，但是使用变量可能在函数的尾部，如果函数比较长，那么定义变量和使用变量的距离就有点远了，编写代码或者阅读代码时就要频繁得向前翻看代码，非常不方便，所以后来的 C99 标准就取消了这个限制。

GCC、LLVM/Clang 更新比较快，已经支持到 C99 标准了，局部变量可以在函数的任意位置定义。但是微软编译器更新就比较慢了，VC6.0、VS2010 对 C99 的支持都非常不好，变量仍然要定义在函数的开头位置，不过 VS2015 已经部分支持 C99 标准了，已经取消了这个限制，局部变量的定义位置就随意了。

VS2012、VS2013 没有测试，大家在编写代码时请自己注意这个问题。

如果你还是不明白什么叫“变量的定义位置”，那么请看下面的代码：

#include <stdio.h>
int main(){   
    int a = 100, b = 200, c;   
    c = a + b;  
    printf("c=%d\n", c);   
    float d = 23.5, e = 22.899, f;  
    f = d + e;  
    printf("f=%f\n", f);   
    return 0;
}

变量 a、b、c 就是在函数开头定义的，它们之前没有“非变量定义”的语句；变量 d、e、f 就不是在函数开头定义的，它们之前有一个加法运算，还有一个 printf 函数的调用。

这段代码可以在 GCC、LLVM/Clang、VS2015 下运行，但是不能在 VC6.0、VS2010 下运行。

更改上面的代码，把所有变量都挪到 main 函数开头定义：

#include <stdio.h>
int main(){  
    int a = 100, b = 200, c;   
    float d = 23.5, e = 22.899, f;   
    c = a + b;  
    printf("c=%d\n", c);  
    f = d + e;    
    printf("f=%f\n", f);    
    return 0;
}

这样的代码在任何编译器下都能运行。

变量的默认初始值

一个变量，即使不给它赋值，它也会有一个默认的值，这个值就是默认初始值。

对于全局变量，它的默认初始值始终是 0，因为全局变量存储在内存分区中的全局数据区（我们将在《C语言内存精讲》中讲解），这个区域中的数据在程序载入内存后会被初始化为 0。

而对于局部变量，C语言并没有规定它的默认初始值是什么，所以不同的编译器进行了不同的扩展，有的编译器会初始化为 0，有的编译器放任不管，爱是什么就是什么。请看下面的代码：

#include <stdio.h>
int main(){  
    int a; 
    float f;  
    char c;   
    printf("a=%d, f=%f, c=%d\n", a, f, c);  
    return 0;
}

在 VS2010 下的运行结果：a=1323060, f=0.000000, c=115

在 VS2015 下的运行结果：a=0, f=0.000000, c=109

在 Linux GCC 下的运行结果：a=32767, f=0.000000, c=0

在 Xcode 下的运行结果：a=24630, f=0.000000, c=95

你看，不同的编译器对局部变量的处理差异很大，有的将 int 类型初始化为 0，有的将 char 类型初始化为 0，有的全部初始化为 0，有的全部放任不管。这就告诉我们，使用局部变量之前一定要手动初始化（赋值），千万不敢假设它的值就是 0，不初始化就使用局部变量会导致匪夷所思的结果。

使用未初始化的局部变量有很大风险，很多编译器会给出警告，提醒程序员注意。

那么，为什么不初始化为 0 的局部变量会有一个奇怪的值？放任不管又意味着什么呢？

变量定义时会给变量分配一块内存空间，如果不对变量进行初始化，那就意味着不对这块内存进行写入操作，这块内存的数据会保持不变，依然是分配之前的数据。这样的数据可能是当前程序在之前的运行过程中产生的，也可能是之前运行过的其它程序产生的，我们根本无法预测这样的数据到底是什么，所以你会看到它是一个毫无意义的值，这样的值是随机的，是垃圾值，没有使用价值。

更改上面的代码，将所有的局部变量手动初始化为 0：

#include <stdio.h>
int main(){  
    int a = 0;  
    float f = 0.0; 
    char c = 0;  
    printf("a=%d, f=%f, c=%d\n", a, f, c);  
    return 0;
}

大家在以后的编程过程中，请尽量养成这个良好的习惯。

C 语言运算符的优先级和结合性

本节我们从一个例子入手讲解，请看下面的代码：

#include <stdio.h>
int main(){   
    int a = 16, b = 4, c = 2;  
    int d = a + b * c;   
    int e = a / b * c;   
    printf( "d=%d, e=%d\n", d, e);  
    return 0;
}

运行结果：d=24, e=8

1. 对于表达式a + b * c，如果按照数学规则推导，应该先计算乘法，再计算加法；b * c的结果为 8，a + 8的结果为 24，所以 d 最终的值也是 24。从运行结果可以看出，我们的推论得到了证实，C语言也是先计算乘法再计算加法，和数学中的规则一样。

先计算乘法后计算加法，说明乘法运算符的优先级比加法运算符的优先级高。所谓优先级，就是当多个运算符出现在同一个表达式中时，先执行哪个运算符。

C语言有几十种运算符，被分成十几个级别，有的运算符优先级不同，有的运算符优先级相同，我们在《C语言运算符的优先级和结合性一览表》中给出了详细的说明，大家可以点击链接自行查阅。

一下子记住所有运算符的优先级并不容易，还好C语言中大部分运算符的优先级和数学中是一样的，大家在以后的编程过程中也会逐渐熟悉起来。如果实在搞不清，可以加括号，就像下面这样：

int d = a + (b * c);

括号的优先级是最高的，括号中的表达式会优先执行，这样各个运算符的执行顺序就一目了然了。

2. 对于表达式a / b * c，查看了《C语言运算符的优先级和结合性一览表》的读者会发现，除法和乘法的优先级是相同的，这个时候到底该先执行哪一个呢？

按照数学规则应该从左到右，先计算除法，在计算乘法；a / b的结果是 4，4 * c的结果是 8，所以 e 最终的值也是 8。这个推论也从运行结果中得到了证实，C语言的规则和数学的规则是一样的。

当乘法和除法的优先级相同时，编译器很明显知道先执行除法，再执行乘法，这是根据运算符的结合性来判定的。所谓结合性，就是当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性。

/和*的优先级相同，又都具有左结合性，所以先执行左边的除法，再执行右边的乘法。

3. 像 +、-、*、/ 这样的运算符，它的两边都有要计算的数据，每份这样的数据都称作一个操作数，一个运算符需要 n 个操作数就称为 n 目运算符。例如：

• +、-、*、/、= 是双目运算符；
• ++、-- 是单目运算符；
• ? : 是三目运算符（这是C语言里唯一的一个三目元算符，后续我们将会讲解）。

总结

当一个表达式中出现多个运算符时，C语言会先比较各个运算符的优先级，按照优先级从高到低的顺序依次执行；当遇到优先级相同的运算符时，再根据结合性决定先执行哪个运算符：如果是左结合性就先执行左边的运算符，如果是右结合性就先执行右边的运算符。

C语言的运算符众多，每个运算符都具有优先级和结合性，还拥有若干个操作数，为了方便记忆和对比，我们在《C语言运算符的优先级和结合性一览表》中将它们全部列了出来。对于没有学到的运算符，大家不必深究，一带而过即可，等学到时再来回顾。

C 语言数据类型转换（自动类型转换+强制类型转换）

数据类型转换就是将数据（变量、数值、表达式的结果等）从一种类型转换为另一种类型。

自动类型转换

自动类型转换就是编译器默默地、隐式地、偷偷地进行的数据类型转换，这种转换不需要程序员干预，会自动发生。

1. 将一种类型的数据赋值给另外一种类型的变量时就会发生自动类型转换，例如：

float f = 100;

100 是 int 类型的数据，需要先转换为 float 类型才能赋值给变量 f。再如：

int n = f;

f 是 float 类型的数据，需要先转换为 int 类型才能赋值给变量 n。

在赋值运算中，赋值号两边的数据类型不同时，需要把右边表达式的类型转换为左边变量的类型，这可能会导致数据失真，或者精度降低；所以说，自动类型转换并不一定是安全的。对于不安全的类型转换，编译器一般会给出警告。

2. 在不同类型的混合运算中，编译器也会自动地转换数据类型，将参与运算的所有数据先转换为同一种类型，然后再进行计算。转换的规则如下：

• 转换按数据长度增加的方向进行，以保证数值不失真，或者精度不降低。例如，int 和 long 参与运算时，先把 int 类型的数据转成 long 类型后再进行运算。
• 所有的浮点运算都是以双精度进行的，即使运算中只有 float 类型，也要先转换为 double 类型，才能进行运算。
• char 和 short 参与运算时，必须先转换成 int 类型。

下图对这种转换规则进行了更加形象地描述：

unsigned 也即 unsigned int，此时可以省略 int，只写 unsigned。

自动类型转换示例：

#include<stdio.h>
int main(){   
    float PI = 3.14159;   
    int s1, r = 5; 
    double s2;   
    s1 = r * r * PI;  
    s2 = r * r * PI;  
    printf("s1=%d, s2=%f\n", s1, s2);   
    return 0;
}

运行结果：s1=78, s2=78.539749

在计算表达式r * r * PI时，r 和 PI 都被转换成 double 类型，表达式的结果也是 double 类型。但由于 s1 为整型，所以赋值运算的结果仍为整型，舍去了小数部分，导致数据失真。

强制类型转换

自动类型转换是编译器根据代码的上下文环境自行判断的结果，有时候并不是那么“智能”，不能满足所有的需求。如果需要，程序员也可以自己在代码中明确地提出要进行类型转换，这称为强制类型转换。

自动类型转换是编译器默默地、隐式地进行的一种类型转换，不需要在代码中体现出来；强制类型转换是程序员明确提出的、需要通过特定格式的代码来指明的一种类型转换。换句话说，自动类型转换不需要程序员干预，强制类型转换必须有程序员干预。

强制类型转换的格式为：

(type_name) expression

type_name为新类型名称，expression为表达式。例如：

(float) a;  //将变量 a 转换为 float 类型
(int)(x+y);  //把表达式 x+y 的结果转换为 int 整型
(float) 100;  //将数值 100（默认为int类型）转换为 float 类型

下面是一个需要强制类型转换的经典例子：

#include <stdio.h>
int main(){   
    int sum = 103;  //总数   
    int count = 7;  //数目 
    double average;  //平均数   
    average = (double) sum / count;   
    printf("Average is %lf!\n", average);  
    return 0;
}

运行结果：Average is 14.714286!

sum 和 count 都是 int 类型，如果不进行干预，那么sum / count的运算结果也是 int 类型，小数部分将被丢弃；虽然是 average 是 double 类型，可以接收小数部分，但是心有余力不足，小数部分提前就被“阉割”了，它只能接收到整数部分，这就导致除法运算的结果严重失真。

既然 average 是 double 类型，为何不充分利用，尽量提高运算结果的精度呢？为了达到这个目标，我们只要将 sum 或者 count 其中之一转换为 double 类型即可。上面的代码中，我们将 sum 强制转换为 double 类型，这样sum / count的结果也将变成 double 类型，就可以保留小数部分了，average 接收到的值也会更加精确。

在这段代码中，有两点需要注意：

• 对于除法运算，如果除数和被除数都是整数，那么运算结果也是整数，小数部分将被直接丢弃；如果除数和被除数其中有一个是小数，那么运算结果也是小数。这一点已在《C语言加减乘除运算》中进行了详细说明。
• ( )的优先级高于/，对于表达式(double) sum / count，会先执行(double) sum，将 sum 转换为 double 类型，然后再进行除法运算，这样运算结果也是 double 类型，能够保留小数部分。注意不要写作(double) (sum / count)，这样写运算结果将是 3.000000，仍然不能保留小数部分。

类型转换只是临时性的

无论是自动类型转换还是强制类型转换，都只是为了本次运算而进行的临时性转换，转换的结果也会保存到临时的内存空间，不会改变数据本来的类型或者值。请看下面的例子：

#include <stdio.h>
int main(){   
    double total = 400.8;  //总价   
    int count = 5;  //数目    
    double unit;  //单价   
    int total_int = (int)total;    
    unit = total / count;  
    printf("total=%lf, total_int=%d, unit=%lf\n", total, total_int, unit);  
    return 0;
}

运行结果：total=400.800000, total_int=400, unit=80.160000

注意看第 6 行代码，total 变量被转换成了 int 类型才赋值给 total_int 变量，而这种转换并未影响 total 变量本身的类型和值。如果 total 的值变了，那么 total 的输出结果将变为 400.000000；如果 total 的类型变了，那么 unit 的输出结果将变为 80.000000。

自动类型转换 VS 强制类型转换

在C语言中，有些类型既可以自动转换，也可以强制转换，例如 int 到 double，float 到 int 等；而有些类型只能强制转换，不能自动转换，例如以后将要学到的 void * 到 int *，int 到 char * 等。

可以自动转换的类型一定能够强制转换，但是，需要强制转换的类型不一定能够自动转换。现在我们学到的数据类型，既可以自动转换，又可以强制转换，以后我们还会学到一些只能强制转换而不能自动转换的类型。

可以自动进行的类型转换一般风险较低，不会对程序带来严重的后果，例如，int 到 double 没有什么缺点，float 到 int 顶多是数值失真。只能强制进行的类型转换一般风险较高，或者行为匪夷所思，例如，char * 到 int * 就是很奇怪的一种转换，这会导致取得的值也很奇怪，再如，int 到 char * 就是风险极高的一种转换，一般会导致程序崩溃。

使用强制类型转换时，程序员自己要意识到潜在的风险。

第四卷 C 语言输入输出

C 语言数据输出大汇总以及轻量进阶

在C语言中，有三个函数可以用来在显示器上输出数据，它们分别是：

• puts()：只能输出字符串，并且输出结束后会自动换行，在《第一个C语言程序》中已经进行了介绍。
• putchar()：只能输出单个字符，在《在C语言中使用英文字符》中已经进行了介绍。
• printf()：可以输出各种类型的数据，在前面的很多章节中都进行了介绍。

printf() 是最灵活、最复杂、最常用的输出函数，完全可以替代 puts() 和 putchar()，大家一定要掌握。前面的章节中我们已经介绍了 printf() 的基本用法，本节将重点介绍 printf() 的高级用法。

对于初学者，这一节的内容可能有些繁杂，如果你希望加快学习进度，尽早写出有趣的代码，也可以跳过这节，后面遇到不懂的 printf() 用法再来回顾。

首先汇总一下前面学到的格式控制符：

格式控制符	说明
%c	输出一个单一的字符
%hd、%d、%ld	以十进制、有符号的形式输出 short、int、long 类型的整数
%hu、%u、%lu	以十进制、无符号的形式输出 short、int、long 类型的整数
%ho、%o、%lo	以八进制、不带前缀、无符号的形式输出 short、int、long 类型的整数
%#ho、%#o、%#lo	以八进制、带前缀、无符号的形式输出 short、int、long 类型的整数
%hx、%x、%lx %hX、%X、%lX	以十六进制、不带前缀、无符号的形式输出 short、int、long 类型的整数。如果 x 小写，那么输出的十六进制数字也小写；如果 X 大写，那么输出的十六进制数字也大写。
%#hx、%#x、%#lx %#hX、%#X、%#lX	以十六进制、带前缀、无符号的形式输出 short、int、long 类型的整数。如果 x 小写，那么输出的十六进制数字和前缀都小写；如果 X 大写，那么输出的十六进制数字和前缀都大写。
%f、%lf	以十进制的形式输出 float、double 类型的小数
%e、%le %E、%lE	以指数的形式输出 float、double 类型的小数。如果 e 小写，那么输出结果中的 e 也小写；如果 E 大写，那么输出结果中的 E 也大写。
%g、%lg %G、%lG	以十进制和指数中较短的形式输出 float、double 类型的小数，并且小数部分的最后不会添加多余的 0。如果 g 小写，那么当以指数形式输出时 e 也小写；如果 G 大写，那么当以指数形式输出时 E 也大写。
%s	输出一个字符串

printf() 的高级用法

通过前面的学习，相信你已经熟悉了 printf() 的基本用法，但是这还不足以把它发挥到极致，printf() 可以有更加炫酷、更加个性、更加整齐的输出形式。

假如现在老师要我们输出一个 4×4 的整数矩阵，为了增强阅读性，数字要对齐，怎么办呢？我们显然可以这样做：

#include <stdio.h>
int main(){  
    int a1=20, a2=345, a3=700, a4=22;    
    int b1=56720, b2=9999, b3=20098, b4=2;   
    int c1=233, c2=205, c3=1, c4=6666;   
    int d1=34, d2=0, d3=23, d4=23006783;  
    printf("%d        %d       %d       %d\n", a1, a2, a3, a4); 
    printf("%d     %d      %d     %d\n", b1, b2, b3, b4);    
    printf("%d       %d       %d         %d\n", c1, c2, c3, c4);   
    printf("%d        %d         %d        %d\n", d1, d2, d3, d4);   
    return 0;
}

运行结果：

20        345       700       22
56720     9999      20098     2
233       205       1         6666
34        0         23        23006783

矩阵一般在大学的《高等数学》中会讲到，m×n 的数字矩阵可以理解为把 m×n 个数字摆放成 m 行 n 列的样子。

看，这是多么地自虐，要敲那么多空格，还要严格控制空格数，否则输出就会错位。更加恶心的是，如果数字的位数变了，空格的数目也要跟着变。例如，当 a1 的值是 20 时，它后面要敲八个空格；当 a1 的值是 1000 时，它后面就要敲六个空格。每次修改整数的值，都要考虑修改空格的数目，逼死强迫症。

类似的需求随处可见，整齐的格式会更加美观，让人觉得生动有趣。其实，我们大可不必像上面一样，printf() 可以更好的控制输出格式。更改上面的代码：

#include <stdio.h>
int main(){  
    int a1=20, a2=345, a3=700, a4=22;
    int b1=56720, b2=9999, b3=20098, b4=2;   
    int c1=233, c2=205, c3=1, c4=6666;  
    int d1=34, d2=0, d3=23, d4=23006783;   
    printf("%-9d %-9d %-9d %-9d\n", a1, a2, a3, a4); 
    printf("%-9d %-9d %-9d %-9d\n", b1, b2, b3, b4);   
    printf("%-9d %-9d %-9d %-9d\n", c1, c2, c3, c4);  
    printf("%-9d %-9d %-9d %-9d\n", d1, d2, d3, d4);  
    return 0;
}

输出结果：

20        345       700       22
56720     9999      20098     2
233       205       1         6666
34        0         23        23006783

这样写起来更加方便，即使改变某个数字，也无需修改 printf() 语句，增加或者减少空格数目。

%-9d中，d表示以十进制输出，9表示最少占9个字符的宽度，宽度不足以空格补齐，-表示左对齐。综合起来，%-9d表示以十进制输出，左对齐，宽度最小为9个字符。大家可以亲自试试%9d的输出效果。

printf() 格式控制符的完整形式如下：

%[flag][width][.precision]type

[ ] 表示此处的内容可有可无，是可以省略的。

1. type 表示输出类型，比如 %d、%f、%c、%lf，type 就分别对应 d、f、c、lf；再如，%-9d中 type 对应 d。

type 这一项必须有，这意味着输出时必须要知道是什么类型。

2. width 表示最小输出宽度，也就是至少占用几个字符的位置；例如，%-9d中 width 对应 9，表示输出结果最少占用 9 个字符的宽度。

当输出结果的宽度不足 width 时，以空格补齐（如果没有指定对齐方式，默认会在左边补齐空格）；当输出结果的宽度超过 width 时，width 不再起作用，按照数据本身的宽度来输出。

下面的代码演示了 width 的用法：

#include <stdio.h>
int main(){  
    int n = 234;  
    float f = 9.8; 
    char c = '@';  
    char *str = "http://work.lynchow.com";    
    printf("%10d%12f%4c%8s", n, f, c, str);  
    return 0;
}

运行结果：

       234    9.800000   @http://work.lynchow.com

对输出结果的说明：

• n 的指定输出宽度为 10，234 的宽度为 3，所以前边要补上 7 个空格。
• f 的指定输出宽度为 12，9.800000 的宽度为 8，所以前边要补上 4 个空格。
• str 的指定输出宽度为 8，"http://work.lynchow.com" 的宽度为 22，超过了 8，所以指定输出宽度不再起作用，而是按照 str 的实际宽度输出。

3. .precision 表示输出精度，也就是小数的位数。

• 当小数部分的位数大于 precision 时，会按照四舍五入的原则丢掉多余的数字；
• 当小数部分的位数小于 precision 时，会在后面补 0。

另外，.precision 也可以用于整数和字符串，但是功能却是相反的：

• 用于整数时，.precision 表示最小输出宽度。与 width 不同的是，整数的宽度不足时会在左边补 0，而不是补空格。
• 用于字符串时，.precision 表示最大输出宽度，或者说截取字符串。当字符串的长度大于 precision 时，会截掉多余的字符；当字符串的长度小于 precision 时，.precision 就不再起作用。

请看下面的例子：

#include <stdio.h>
int main(){    
    int n = 123456;    
    double f = 882.923672;    
    char *str = "abcdefghi";    
    printf("n: %.9d  %.4d\n", n, n);    
    printf("f: %.2lf  %.4lf  %.10lf\n", f, f, f);    
    printf("str: %.5s  %.15s\n", str, str);    
    return 0;
}

运行结果：

n: 000123456  123456
f: 882.92  882.9237  882.9236720000
str: abcde  abcdefghi

对输出结果的说明：

• 对于 n，.precision 表示最小输出宽度。n 本身的宽度为 6，当 precision 为 9 时，大于 6，要在 n 的前面补 3 个 0；当 precision 为 4 时，小于 6，不再起作用。
• 对于 f，.precision 表示输出精度。f 的小数部分有 6 位数字，当 precision 为 2 或者 4 时，都小于 6，要按照四舍五入的原则截断小数；当 precision 为 10 时，大于 6，要在小数的后面补四个 0。
• 对于 str，.precision 表示最大输出宽度。str 本身的宽度为 9，当 precision 为 5 时，小于 9，要截取 str 的前 5 个字符；当 precision 为 15 时，大于 9，不再起作用。

4. flag 是标志字符。例如，%#x中 flag 对应 #，%-9d中 flags 对应-。下表列出了 printf() 可以用的 flag：

标志字符	含 义
-	-表示左对齐。如果没有，就按照默认的对齐方式，默认一般为右对齐。
+	用于整数或者小数，表示输出符号（正负号）。如果没有，那么只有负数才会输出符号。
空格	用于整数或者小数，输出值为正时冠以空格，为负时冠以负号。
#	对于八进制（%o）和十六进制（%x / %X）整数，# 表示在输出时添加前缀；八进制的前缀是 0，十六进制的前缀是 0x / 0X。对于小数（%f / %e / %g），# 表示强迫输出小数点。如果没有小数部分，默认是不输出小数点的，加上 # 以后，即使没有小数部分也会带上小数点。

请看下面的例子：

#include <stdio.h>
int main(){  
    int m = 192, n = -943;   
    float f = 84.342;  
    printf("m=%10d, m=%-10d\n", m, m);  //演示 - 的用法   
    printf("m=%+d, n=%+d\n", m, n);  //演示 + 的用法  
    printf("m=% d, n=% d\n", m, n);  //演示空格的用法   
    printf("f=%.0f, f=%#.0f\n", f, f);  //演示#的用法    
    return 0;
}

运行结果：

m=       192, m=192      
m=+192, n=-943
m= 192, n=-943
f=84, f=84.

对输出结果的说明：

• 当以%10d输出 m 时，是右对齐，所以在 192 前面补七个空格；当以%-10d输出 m 时，是左对齐，所以在 192 后面补七个空格。
• m 是正数，以%+d输出时要带上正号；n 是负数，以%+d输出时要带上负号。
• m 是正数，以% d输出时要在前面加空格；n 是负数，以% d输出时要在前面加负号。
• %.0f表示保留 0 位小数，也就是只输出整数部分，不输出小数部分。默认情况下，这种输出形式是不带小数点的，但是如果有了#标志，那么就要在整数的后面“硬加上”一个小数点，以和纯整数区分开。

printf() 不能立即输出的问题

printf() 有一个尴尬的问题，就是有时候不能立即输出，请看下面的代码：

#include<stdio.h>
#include<unistd.h>
int main(){  
    printf("C语言中文网");  
    sleep(5);  //程序暂停5秒钟   
    printf("http://c.biancheng.net\n");    
    return 0;
}

这段代码使用了两个 printf() 语句，它们之间有一个 sleep() 函数，该函数的作用是让程序暂停 5 秒，然后再继续执行。sleep() 是 Linux 和 Mac OS 下特有的函数，不能用于 Windows。当然，Windows 下也有功能相同的暂停函数，叫做 Sleep()，稍后我们会讲解。

在 Linux 或者 Mac OS 下运行该程序，会发现第一个 printf() 并没有立即输出，而是等待 5 秒以后，和第二个 printf() 一起输出了，请看下面的动图演示：

我们不妨修改一下代码，在第一个 printf() 的最后添加一个换行符，如下所示：

printf("C语言中文网\n");

再次编译并运行程序，发现第一个 printf() 首先输出（程序运行后立即输出），等待 5 秒以后，第二个 printf() 才输出，请看下面的动图演示：

为什么一个换行符\n就能让程序的表现有天壤之别呢？按照通常的逻辑，程序运行后第一个 printf() 应该立即输出，而不是等待 5 秒以后再和第二个 printf() 一起输出，也就是说，第二种情形才符合我们的惯性思维。然而，第一种情形该如何理解呢？

其实，这一切都是输出缓冲区（缓存）在作怪！

从本质上讲，printf() 执行结束以后数据并没有直接输出到显示器上，而是放入了缓冲区，直到遇见换行符\n才将缓冲区中的数据输出到显示器上。更加深入的内容，我们将在本章的《进入缓冲区（缓存）的世界，破解一切与输入输出有关的疑难杂症》中详细讲解。

以上测试的是 Linux 和 Mac OS，我们不妨再测试一下 Windows，请看下面的代码：

#include<stdio.h>
#include<Windows.h>
int main(){  
    printf("C语言中文网");   
    Sleep(5000);  //程序暂停5秒钟    
    printf("http://c.biancheng.net\n");  
    return 0;
}

在 Windows 下，想让程序暂停可以使用 Windows.h 头文件中的 Sleep() 函数（S要大写），它和 Linux 下的 sleep() 功能相同。不过，sleep() 要求的时间单位是秒，而 Sleep() 要求的时间单位是毫秒，1 秒等于 1000 毫秒。这段代码中，我们要求程序暂停 5000 毫秒，也即 5 秒。

编译并运行程序，会发现第一个 printf() 首先输出（程序运行后立即输出），等待 5 秒以后，第二个 printf() 才输出，请看下面的动画演示：

在第一个 printf() 的最后添加一个换行符，情况也是一样的，第一个 printf() 从来不会和第二个 printf() 一起输出。

你看，Windows 和 Linux、Mac OS 的情况又不一样。这是因为，Windows 和 Linux、Mac OS 的缓存机制不同。更加深入的内容，我们将在本章的《进入缓冲区（缓存）的世界，破解一切与输入输出有关的疑难杂症》中详细讲解。

要想破解 printf() 输出的问题，必须要了解缓存，它能使你对输入输出的认识上升到一个更高的层次，以后不管遇到什么疑难杂症，都能迎刃而解。可以说，输入输出的“命门”就在于缓存。

总结

对于初学者来说，上面讲到的 printf() 用法已经比较复杂了，基本满足了实际开发的需求，相信大家也需要一段时间才能熟悉。但是，受到所学知识的限制，本文也未能讲解 printf() 的所有功能，后续我们还会逐步深入。

printf() 的这些格式规范不是“小把戏”，优美的输出格式随处可见，例如，dos 下的 dir 命令，会整齐地列出当前目录下的文件，这明显使用了右对齐，还指定了宽度。

C 语言在屏幕的任意位置输出字符，开发小游戏的第一步

初学编程的读者，肯定很想编写出一个游戏来秀一下，贪吃蛇就是C语言小游戏中经典的一个，本教程的目标也是带着大家做出这款游戏。

编写游戏的第一步就是搞定光标定位问题，这样你的程序就可以随心所欲、按任意顺序、在任意位置输出了。但是，C语言本身并不支持该功能，我们必须使用 Windows 提供的接口，所以要引入 windows.h 头文件。

因为用到了 Windows 操作系统的功能，所以本节的代码不能在 Linux 和 Mac OS 下运行。

所谓 Windows 接口，就是 Windows 这个操作系统本身提供的函数，它们都是以C语言的形式呈现的，只要我们引入了 windows.h 头文件，就可以调用这些函数，使用 Windows 提供的强大功能了。

因为涉及到了 Windows 编程，所以本节的内容不要求大家深入理解，能按照葫芦画瓢就可以，以后如果决定专攻 Windows 编程了，再来深入研究也不迟。

光标定位需要使用 windows.h 头文件中的SetConsoleCursorPosition函数，它的使用方式为：

SetConsoleCursorPosition(HANDLE hConsoleOutput, COORD  dwCursorPosition);

hConsoleOutput表示控制台缓冲区句柄，可通过GetStdHandle(STD_OUTPUT_HANDLE)来获得；dwCursorPosition是光标位置，也就是第几行第几列，它是 COORD 类型的结构体。

看不懂是吧？嗯，没关系，我知道大部分读者都看不懂，所以，照着葫芦画瓢吧。

例如，将光标定位到控制台的第3行第3列：

//定义光标位置
COORD coord;coord.X = 3;  //第3行
coord.Y = 3;  //第3列
//获取控制台缓冲区句柄，固定写法
HANDLE ConsoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);
//设置光标位置，固定写法
SetConsoleCursorPosition(ConsoleHandle, coord);

这样，程序就可以从第3行第3列开始输出了。

将代码补充完整：

#include <stdio.h>
#include <windows.h>
int main(){   
    //定义光标位置   
    COORD coord;    
    coord.X = 3;  //第3行   
    coord.Y = 3;  //第3列  
    //获取控制台缓冲区句柄   
    HANDLE ConsoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);    
    //设置光标位置  
    SetConsoleCursorPosition(ConsoleHandle, coord);     
    printf("http://c.biancheng.net\n");  
    return 0;
}

运行结果：

注意：窗口的左上角是第 0 行第 0 列，而不是我们通常所认为的第 1 行第 1 列。编程语言中的很多计数都是从 0 开始的，而不是从 1 开始。

搞定了光标重定位，你就可以将输出顺序打乱了，想在哪里输出就在哪里输出。例如：

#include <stdio.h>
#include <windows.h>
//设置光标位置
void setCursorPosition(int x, int y);
//设置文字颜色void setColor(int color);
int main(){   
    setColor(3);  
    setCursorPosition(3, 3); 
    puts("★");
    setColor(0XC);    
    setCursorPosition(1, 1);   
    puts("◆");    setColor(6);  
    setCursorPosition(6, 6);
    puts("■");  
    return 0;
}
//自定义的光标定位函数
void setCursorPosition(int x, int y){  
    COORD coord;  
    coord.X = x;   
    coord.Y = y;  
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
}
//自定义的文字颜色函数
void setColor(int color){ 
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color);
}

运行结果：

可以发现，先输出的字符位置不一定靠前，后输出的字符位置不一定靠后，它们都可以在任意位置。

看到这里，很多初学者会不懂，甚至一头雾水，不过没关系，这里仅仅是演示，引起你对C语言的兴趣，待学完C语言的基本语法后会恍然大悟。

C 语言scanf：读取从键盘输入的数据（含输入格式汇总表）

程序是人机交互的媒介，有输出必然也有输入，第三章我们讲解了如何将数据输出到显示器上，本章我们开始讲解如何从键盘输入数据。在C语言中，有多个函数可以从键盘获得用户输入：

• scanf()：和 printf() 类似，scanf() 可以输入多种类型的数据。
• getchar()、getche()、getch()：这三个函数都用于输入单个字符。
• gets()：获取一行数据，并作为字符串处理。

scanf() 是最灵活、最复杂、最常用的输入函数，但它不能完全取代其他函数，大家都要有所了解。

本节我们只讲解 scanf()，其它的输入函数将在下节讲解。

scanf() 函数

scanf 是 scan format 的缩写，意思是格式化扫描，也就是从键盘获得用户输入，和 printf 的功能正好相反。

我们先来看一个例子：

#include <stdio.h>
int main(){   
    int a = 0, b = 0, c = 0, d = 0;  
    scanf("%d", &a);  //输入整数并赋值给变量a   
    scanf("%d", &b);  //输入整数并赋值给变量b   
    printf("a+b=%d\n", a+b);  //计算a+b的值并输出 
    scanf("%d %d", &c, &d);  //输入两个整数并分别赋值给c、d   
    printf("c*d=%d\n", c*d);  //计算c*d的值并输出  
    return 0;
}

运行结果： 12↙ 60↙ a+b=72 10 23↙ c*d=230

↙表示按下回车键。

从键盘输入12，按下回车键，scanf() 就会读取输入数据并赋值给变量 a；本次输入结束，接着执行下一个 scanf() 函数，再从键盘输入 60，按下回车键，就会将 60 赋值给变量 b，都是同样的道理。

第 8 行代码中，scanf() 有两个以空格分隔的%d，后面还跟着两个变量，这要求我们一次性输入两个整数，并分别赋值给 c 和 d。注意"%d %d"之间是有空格的，所以输入数据时也要有空格。对于 scanf()，输入数据的格式要和控制字符串的格式保持一致。

其实 scanf 和 printf 非常相似，只是功能相反罢了：

scanf("%d %d", &a, &b);  // 获取用户输入的两个整数，分别赋值给变量 a 和 b
printf("%d %d", a, b);  // 将变量 a 和 b 的值在显示器上输出

它们都有格式控制字符串，都有变量列表。不同的是，scanf 的变量前要带一个&符号。&称为取地址符，也就是获取变量在内存中的地址。

在《数据在内存中的存储》一节中讲到，数据是以二进制的形式保存在内存中的，字节（Byte）是最小的可操作单位。为了便于管理，我们给每个字节分配了一个编号，使用该字节时，只要知道编号就可以，就像每个学生都有学号，老师会随机抽取学号来让学生回答问题。字节的编号是有顺序的，从 0 开始，接下来是 1、2、3……

下图是 4G 内存中每个字节的编号（以十六进制表示）：

这个编号，就叫做地址（Address）。int a;会在内存中分配四个字节的空间，我们将第一个字节的地址称为变量 a 的地址，也就是&a的值。对于前面讲到的整数、浮点数、字符，都要使用 & 获取它们的地址，scanf 会根据地址把读取到的数据写入内存。

我们不妨将变量的地址输出看一下：

#include <stdio.h>
int main(){ 
    int a='F';  
    int b=12;   
    int c=452;   
    printf("&a=%p, &b=%p, &c=%p\n", &a, &b, &c);   
    return 0;
}

输出结果：&a=0x18ff48, &b=0x18ff44, &c=0x18ff40

%p是一个新的格式控制符，它表示以十六进制的形式（带小写的前缀）输出数据的地址。如果写作%P，那么十六进制的前缀也将变成大写形式。

​ 图：a、b、c 的内存地址

注意：这里看到的地址都是假的，是虚拟地址，并不等于数据在物理内存中的地址。虚拟地址是现代计算机因内存管理的需要才提出的概念，我们将在《C语言内存精讲》专题中详细讲解。

再来看一个 scanf 的例子：

#include <stdio.h>
int main(){   
    int a, b, c; 
    scanf("%d %d", &a, &b);  
    printf("a+b=%d\n", a+b);  
    scanf("%d   %d", &a, &b);  
    printf("a+b=%d\n", a+b);   
    scanf("%d, %d, %d", &a, &b, &c);  
    printf("a+b+c=%d\n", a+b+c);    
    scanf("%d is bigger than %d", &a, &b); 
    printf("a-b=%d\n", a-b);   
    return 0;
}

运行结果：

10    20↙
a+b=30
100 200↙
a+b=300
56,45,78↙
a+b+c=179
25 is bigger than 11↙
a-b=14

第一个 scanf() 的格式控制字符串为"%d %d"，中间有一个空格，而我们却输入了10 20，中间有多个空格。第二个 scanf() 的格式控制字符串为"%d %d"，中间有多个空格，而我们却输入了100 200，中间只有一个空格。这说明 scanf() 对输入数据之间的空格的处理比较宽松，并不要求空格数严格对应，多几个少几个无所谓，只要有空格就行。

第三个 scanf() 的控制字符串为"%d, %d, %d"，中间以逗号分隔，所以输入的整数也要以逗号分隔。

第四个 scanf() 要求整数之间以is bigger than分隔。

用户每次按下回车键，程序就会认为完成了一次输入操作，scanf() 开始读取用户输入的内容，并根据格式控制字符串从中提取有效数据，只要用户输入的内容和格式控制字符串匹配，就能够正确提取。

本质上讲，用户输入的内容都是字符串，scanf() 完成的是从字符串中提取有效数据的过程。

连续输入

在本节第一段示例代码中，我们一个一个地输入变量 a、b、c、d 的值，每输入一个值就按一次回车键。现在我们改变输入方式，将四个变量的值一次性输入，如下所示：

12 60 10 23↙ a+b=72 c*d=230

可以发现，两个 scanf() 都能正确读取。合情合理的猜测是，第一个 scanf() 读取完毕后没有抛弃多余的值，而是将它们保存在了某个地方，下次接着使用。

如果我们多输入一个整数，会怎样呢？

12 60 10 23 99↙ a+b=72 c*d=230

这次我们多输入了一个 99，发现 scanf() 仍然能够正确读取，只是 99 没用罢了。

如果我们少输入一个整数，又会怎样呢？

12 60 10↙ a+b=72 23↙ c*d=230

输入三个整数后，前两个 scanf() 把前两个整数给读取了，剩下一个整数 10，而第三个 scanf() 要求输入两个整数，一个单独的 10 并不能满足要求，所以我们还得继续输入，凑够两个整数以后，第三个 scanf() 才能读取完毕。

从本质上讲，我们从键盘输入的数据并没有直接交给 scanf()，而是放入了缓冲区中，直到我们按下回车键，scanf() 才到缓冲区中读取数据。如果缓冲区中的数据符合 scanf() 的要求，那么就读取结束；如果不符合要求，那么就继续等待用户输入，或者干脆读取失败。我们将在本章的《进入缓冲区（缓存）的世界，破解一切与输入输出有关的疑难杂症》《结合C语言缓冲区谈scanf函数》两节中详细讲解缓冲区。

注意，如果缓冲区中的数据不符合 scanf() 的要求，要么继续等待用户输入，要么就干脆读取失败，上面我们演示了“继续等待用户输入”的情形，下面我们对代码稍作修改，演示“读取失败”的情形。

#include <stdio.h>
int main(){  
    int a = 1, b = 2, c = 3, d = 4;  //修改处：给变量赋予不同的初始值  
    scanf("%d", &a);   
    scanf("%d", &b);   
    printf("a=%d, b=%d\n", a, b);  
    scanf("%d %d", &c, &d);  
    printf("c=%d, d=%d\n", c, d);   
    return 0;
}

运行结果：

12 60 a10↙ a=12, b=60 c=3, d=4

前两个整数被正确读取后，剩下了 a10，而第三个 scanf() 要求输入两个十进制的整数，a10 无论如何也不符合要求，所以只能读取失败。输出结果也证明了这一点，c 和 d 的值并没有被改变。

这说明 scanf() 不会跳过不符合要求的数据，遇到不符合要求的数据会读取失败，而不是再继续等待用户输入。

总而言之，正是由于缓冲区的存在，才使得我们能够多输入一些数据，或者一次性输入所有数据，这可以认为是缓冲区的一点优势。然而，缓冲区也带来了一定的负面影响，甚至会导致很奇怪的行为，请看下面的代码：

#include <stdio.h>
int main(){  
    int a = 1, b = 2;    
    scanf("a=%d", &a);   
    scanf("b=%d", &b);   
    printf("a=%d, b=%d\n", a, b); 
    return 0;
}

输入示例：

a=99↙ a=99, b=2

输入a=99，按下回车键，程序竟然运行结束了，只有第一个 scanf() 成功读取了数据，第二个 scanf() 仿佛没有执行一样，根本没有给用户任何机会去输入数据。

如果我们换一种输入方式呢？

a=99b=200↙ a=99, b=200

这样 a 和 b 都能够正确读取了。注意，a=99b=200中间是没有任何空格的。

肯定有好奇的小伙伴又问了，如果a=99b=200两个数据之间有空格又会怎么样呢？我们不妨亲试一下：

a=99 b=200↙ a=99, b=2

你看，第二个 scanf() 又读取失败了！在前面的例子中，输入的两份数据之前都是有空格的呀，为什么这里不能带空格呢，真是匪夷所思。好吧，这个其实还是跟缓冲区有关系，我将在《结合C语言缓冲区谈scanf()函数》中深入讲解。

要想破解 scanf() 输入的问题，一定要学习缓冲区，它能使你对输入输出的认识上升到一个更高的层次，以后不管遇到什么疑难杂症，都能迎刃而解。可以说，输入输出的“命门”就在于缓冲区。

输入其它数据

除了输入整数，scanf() 还可以输入单个字符、字符串、小数等，请看下面的演示：

#include <stdio.h>
int main(){  
    char letter; 
    int age; 
    char url[30];  
    float price;    
    scanf("%c", &letter);  
    scanf("%d", &age); 
    scanf("%s", url); //可以加&也可以不加&   
    scanf("%f", &price);     
    printf("26个英文字母的最后一个是 %c。\n", letter);   
    printf("秋城技谈已经成立%d年了，网址是 %s，开通VIP会员的价格是%g。\n", age, url, price);  
    return 0;
}

运行示例：

z↙ 6↙ http://work.lynchow.com↙ 159.9↙ 26个英文字母的最后一个是 z。 秋城技谈已经成立6年了，网址是 http://work.lynchow.com，开通VIP会员的价格是159.9。

scanf() 和 printf() 虽然功能相反，但是格式控制符是一样的，单个字符、整数、小数、字符串对应的格式控制符分别是 %c、%d、%f、%s。

对读取字符串的说明

在《在C语言中使用英文字符》一节中，我们谈到了字符串的两种定义形式，它们分别是：

char str1[] = "http://work.lynchow.com";
char *str2 = "秋城技谈";

这两种形式其实是有区别的，第一种形式的字符串所在的内存既有读取权限又有写入权限，第二种形式的字符串所在的内存只有读取权限，没有写入权限。printf()、puts() 等字符串输出函数只要求字符串有读取权限，而 scanf()、gets() 等字符串输入函数要求字符串有写入权限，所以，第一种形式的字符串既可以用于输出函数又可以用于输入函数，而第二种形式的字符串只能用于输出函数。

另外，对于第一种形式的字符串，在[ ]里面要指明字符串的最大长度，如果不指明，也可以根据=后面的字符串来自动推算，此处，就是根据"http://c.biancheng.net"的长度来推算的。但是在前一个例子中，开始我们只是定义了一个字符串，并没有立即给它赋值，所以没法自动推算，只能手动指明最大长度，这也就是为什么一定要写作char url[30]，而不能写作char url[]的原因。

读者还要注意第 11 行代码，这行代码用来输入字符串。上面我们说过，scanf() 读取数据时需要的是数据的地址，整数、小数、单个字符都要加&取地址符，这很容易理解；但是对于此处的 url 字符串，我们并没有加 &，这是因为，字符串的名字会自动转换为字符串的地址，所以不用再多此一举加 & 了。当然，你也可以加上，这样虽然不会导致错误，但是编译器会产生警告，至于为什么，我们将会在《数组和指针绝不等价，数组是另外一种类型》《数组到底在什么时候会转换为指针》中讲解。

关于字符串，后续章节我们还会专门讲解，这里只要求大家会模仿，不要彻底理解，也没法彻底理解。

最后需要注意的一点是，scanf() 读取字符串时以空格为分隔，遇到空格就认为当前字符串结束了，所以无法读取含有空格的字符串，请看下面的例子：

#include <stdio.h>
int main(){   
    char author[30], lang[30], url[30];   
    scanf("%s %s", author, lang);  
    printf("author:%s \nlang: %s\n", author, lang);   
    scanf("%s", url);  
    printf("url: %s\n", url);    
    return 0;
}

运行示例：

jingxun C-Language↙ author:jingxun lang: C-Language http://work.lynchow.com↙ url: http://work.lynchow.com

对于第一个 scanf()，它将空格前边的字符串赋值给 author，将空格后边的字符串赋值给 lang；很显然，第一个字符串遇到空格就结束了，第二个字符串到了本行的末尾结束了。

或许第二个 scanf() 更能说明问题，我们输入了两个网址，但是 scanf() 只读取了一个，就是因为这两个网址以空格为分隔，scanf() 遇到空格就认为字符串结束了，不再继续读取了。

scanf() 格式控制符汇总

格式控制符	说明
%c	读取一个单一的字符
%hd、%d、%ld	读取一个十进制整数，并分别赋值给 short、int、long 类型
%ho、%o、%lo	读取一个八进制整数（可带前缀也可不带），并分别赋值给 short、int、long 类型
%hx、%x、%lx	读取一个十六进制整数（可带前缀也可不带），并分别赋值给 short、int、long 类型
%hu、%u、%lu	读取一个无符号整数，并分别赋值给 unsigned short、unsigned int、unsigned long 类型
%f、%lf	读取一个十进制形式的小数，并分别赋值给 float、double 类型
%e、%le	读取一个指数形式的小数，并分别赋值给 float、double 类型
%g、%lg	既可以读取一个十进制形式的小数，也可以读取一个指数形式的小数，并分别赋值给 float、double 类型
%s	读取一个字符串（以空白符为结束）