十、在C语言中使用英文字符
前面我们多次提到了字符串，字符串是多个字符的集合，它们由" "包围，例如"http://c.biancheng.net"、"C语言中文网"。字符串中的字符在内存中按照次序、紧挨着排列，整个字符串占用一块连续的内存。
当然，字符串也可以只包含一个字符，例如"A"、"6"；不过为了操作方便，我们一般使用专门的字符类型来处理。
初学者经常用到的字符类型是 char，它的长度是 1，只能容纳 ASCII 码表中的字符，也就是英文字符。
要想处理汉语、日语、韩语等英文之外的字符，就得使用其他的字符类型，char 是做不到的，我们将在下节《在C语言中使用中文字符》中详细讲解。
1、字符的表示
字符类型由单引号' '包围，字符串由双引号" "包围。
下面的例子演示了如何给 char 类型的变量赋值：
//正确的写法
char a = '1';
char b = '$';
char c = 'X';
char d = ' '; // 空格也是一个字符
//错误的写法
char x = '中'; //char 类型不能包含 ASCII 编码之外的字符
char y = 'Ａ'; //A 是一个全角字符
char z = "t"; //字符类型应该由单引号包围
说明：在字符集中，全角字符和半角字符对应的编号（或者说编码值）不同，是两个字符；ASCII 编码只定义了半角字符，没有定义全角字符。
2、字符的输出
输出 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 函数每次只能输出一个字符，输出多个字符需要调用多次。
3、字符与整数
我们知道，计算机在存储字符时并不是真的要存储字符实体，而是存储该字符在字符集中的编号（也可以叫编码值）。对于 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 码表将英文字符和整数关联了起来。
4、再谈字符串
前面我们讲到了字符串的概念，也讲到了字符串的输出，但是还没有讲如何用变量存储一个字符串。其实在C语言中没有专门的字符串类型，我们只能使用数组或者指针来间接地存储字符串。
在这里讲字符串很矛盾，虽然我们暂时还没有学到数组和指针，无法从原理上深入分析，但是字符串是常用的，又不得不说一下。所以本节我不会讲解太多，大家只需要死记硬背下面的两种表示形式即可：
char str1[] = "http://c.biancheng.net";
char *str2 = "C语言中文网";
str1 和 str2 是字符串的名字，后边的[ ]和前边的*是固定的写法。初学者暂时可以认为这两种存储方式是等价的，它们都可以通过专用的 puts 函数和通用的 printf 函数输出。
完整的字符串演示：
#include <stdio.h>
int main()
{
char web_url[] = "http://c.biancheng.net";
char *web_name = "C语言中文网";
puts(web_url);
puts(web_name);
printf("%s\n%s\n", web_url, web_name);
return 0;
}
十一、在C语言中使用中文字符
大部分C语言教材对中文字符的处理讳莫如深，甚至只字不提，导致很多初学者认为C语言只能处理英文，而不支持中文。其实C语言是一门全球化的编程语言，它支持世界上任何一个国家的语言文化，包括中文、日语、韩语等。
1、中文字符的存储
正确地存储中文字符需要解决两个问题。
（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 编码。
2、宽字符的输出
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 中 国 。 ヅ ♥ ༄
3、宽字符串
给字符串加上L前缀就变成了宽字符串，它包含的每个字符都是宽字符，一律采用 UTF-16 或者 UTF-32 编码。输出宽字符串可以使用 <wchar.h> 头文件中的 wprintf 函数，对应的格式控制符是%ls。
下面的代码演示了如何使用宽字符串：
#include <wchar.h>
#include <locale.h>
int main(){
wchar_t web_url[] = L"http://c.biancheng.net";
wchar_t *web_name = L"C语言中文网";
//将本地环境设置为简体中文
setlocale(LC_ALL, "zh_CN");
//使用通用的 wprintf 输出宽字符
wprintf(L"web_url: %ls \nweb_name: %ls\n", web_url, web_name);
return 0;
}
运行结果：
web_url: http://c.biancheng.net
web_name: C语言中文网
其实，不加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 编码只能显示字母、数字等英文字符，对汉语、日语、韩语等其它地区的字符无能为力。
讨论窄字符串的编码要从以下两个方面下手。
1、源文件使用什么编码
源文件用来保存我们编写的代码，它最终会被存储到本地硬盘，或者远程服务器，这个时候就要尽量压缩文件体积，以节省硬盘空间或者网络流量，而代码中大部分的字符都是 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 和本地编码了。
2、窄字符串使用什么编码
前面讲到，用 puts 或者 printf 可以输出窄字符串，代码如下：
#include <stdio.h>
int main()
{
puts("C语言中文网");
printf("http://c.biancheng.net");
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 编码。
3、总结
对于 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语言的乐趣。
4、【拓展】编码字符集和运行字符集
站在专业的角度讲，源文件使用的字符集被称为编码字符集，也就是写代码的时候使用的字符集；程序中的字符或者字符串使用的字符集被称为运行字符集，也就是程序运行后使用的字符集。
源文件需要保存到硬盘，或者在网络上传输，使用的编码要尽量节省存储空间，同时要方便跨国交流，所以一般使用 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://c.biancheng.\x6e\145\x74");
return 0;
}
运行结果：
http://c.biancheng.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语言中的几个基本概念。
1、标识符
定义变量时，我们使用了诸如 a、abc、mn123 这样的名字，它们都是程序员自己起的，一般能够表达出变量的作用，这叫做标识符（Identifier）。
标识符就是程序员自己起的名字，除了变量名，后面还会讲到函数名、宏名、结构体名等，它们都是标识符。不过，名字也不能随便起，要遵守规范；C语言规定，标识符只能由字母（A~Z, a~z）、数字（0~9）和下划线（_）组成，并且第一个字符必须是字母或下划线，不能是数字。
以下是合法的标识符：
a, x, x3, BOOK_1, sum5
以下是非法的标识符：
- 3s 不能以数字开头
- s*T 出现非法字符*
- -3x 不能以减号（-）开头
- bowy-1 出现非法字符减号（-）
在使用标识符时还必须注意以下几点：
- C语言虽然不限制标识符的长度，但是它受到不同编译器的限制，同时也受到操作系统的限制。例如在某个编译器中规定标识符前128位有效，当两个标识符前128位相同时，则被认为是同一个标识符。
- 在标识符中，大小写是有区别的，例如 BOOK 和 book 是两个不同的标识符。
- 标识符虽然可由程序员随意定义，但标识符是用于标识某个量的符号，因此，命名应尽量有相应的意义，以便于阅读和理解，作到“顾名思义”。
2、关键字
关键字（Keywords）是由C语言规定的具有特定意义的字符串，通常也称为保留字，例如 int、char、long、float、unsigned 等。我们定义的标识符不能与关键字相同，否则会出现错误。
你也可以将关键字理解为具有特殊含义的标识符，它们已经被系统使用，我们不能再使用了。
标准C语言中一共规定了32个关键字，后续我们会一一讲解。
3、注释
注释（Comments）可以出现在代码中的任何位置，用来向用户提示或解释代码的含义。程序编译时，会忽略注释，不做任何处理，就好像它不存在一样。
C语言支持单行注释和多行注释：
- 单行注释以
//开头，直到本行末尾（不能换行）； - 多行注释以
/*开头，以*/结尾，注释内容可以有一行或多行。
一个使用注释的例子：
/*
Powered by: c.biancheng.net
Author: 严长生
Date: 2017-10-25
*/
#include <stdio.h>
int main()
{
/* puts 会在末尾自动添加换行符 */
puts("http://c.biancheng.net");
printf("C语言中文网\n"); //printf要手动添加换行符
return 0;
}
运行结果：
http://c.biancheng.net
C语言中文网
在调试程序的过程中可以将暂时将不使用的语句注释掉，使编译器跳过不作处理，待调试结束后再去掉注释。
需要注意的是，多行注释不能嵌套使用。例如下面的注释是错误的：
/*C语言/*中文*/网*/
而下面的注释是正确的：
/*C语言中文网*/ /*c.biancheng.net*/
4、表达式（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语言还多了一个求余数的运算符，就是 %。
下面的代码演示了如何在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
m*2=-176, 6/3=2, m*n=-22088
1、对除法的说明
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”这个错误。
2、对取余运算的说明
取余，也就是求余数，使用的运算符是 %。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 中，% 是格式控制符的开头，是一个特殊的字符，不能直接输出；要想输出 %，必须在它的前面再加一个 %，这个时候 % 就变成了普通的字符，而不是用来表示格式控制符了。
3、加减乘除运算的简写
有时候我们希望对一个变量进行某种运算，然后再把运算结果赋值给变量本身，请看下面的例子：
#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=200a = 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://c.biancheng.net";
//输出变量
printf("n: %d\nc: %c\nf: %f\nstr: %s\n", n, c, f, str);
return 0;
}
运行结果：
n: 100
c: @
f: 89.500000
str: http://c.biancheng.net
我们在 main 函数外部定义了变量 n 和 c，在 main 函数内部定义了变量 f 和 str，它们都可以通过 printf 输出。也就是说，在函数外部定义的变量在函数内部也可以使用。
在函数外部定义的变量叫做全局变量（Global Variable），在函数内部定义的变量叫做局部变量（Local Variable），它们的区别将会在《C语言函数详解（包括声明、定义、使用等）》一章中详细说明，这里大家只要记住，变量也可以在 main 函数外面定义即可，本节我们重点讲解的是局部变量。
1、局部变量的定义位置
为了让编译器方便给变量分配内存，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;
}
这样的代码在任何编译器下都能运行。
2、变量的默认初始值
一个变量，即使不给它赋值，它也会有一个默认的值，这个值就是默认初始值。
对于全局变量，它的默认初始值始终是 0，因为全局变量存储在内存分区中的全局数据区（我们将在《C语言内存精讲，让你彻底明白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
在ios手机编译器（如何在手机上编写C语言代码？）的运行结果：
a=0, f=0.000000, c=0
你看，不同的编译器对局部变量的处理差异很大，有的将 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语言里唯一的一个三目元算符，后续我们将会讲解）。
1、总结
当一个表达式中出现多个运算符时，C语言会先比较各个运算符的优先级，按照优先级从高到低的顺序依次执行；当遇到优先级相同的运算符时，再根据结合性决定先执行哪个运算符：如果是左结合性就先执行左边的运算符，如果是右结合性就先执行右边的运算符。
C语言的运算符众多，每个运算符都具有优先级和结合性，还拥有若干个操作数，为了方便记忆和对比，我们在《《C语言运算符优先级和结合性一览表》》中将它们全部列了出来。对于没有学到的运算符，大家不必深究，一带而过即可，等学到时再来回顾。
十九、C语言数据类型转换（自动类型转换+强制类型转换）
数据类型转换就是将数据（变量、数值、表达式的结果等）从一种类型转换为另一种类型。
1、自动类型转换
自动类型转换就是编译器默默地、隐式地、偷偷地进行的数据类型转换，这种转换不需要程序员干预，会自动发生。
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 为整型，所以赋值运算的结果仍为整型，舍去了小数部分，导致数据失真。
2、强制类型转换
自动类型转换是编译器根据代码的上下文环境自行判断的结果，有时候并不是那么“智能”，不能满足所有的需求。如果需要，程序员也可以自己在代码中明确地提出要进行类型转换，这称为强制类型转换。
自动类型转换是编译器默默地、隐式地进行的一种类型转换，不需要在代码中体现出来；强制类型转换是程序员明确提出的、需要通过特定格式的代码来指明的一种类型转换。换句话说，自动类型转换不需要程序员干预，强制类型转换必须有程序员干预。
强制类型转换的格式为：
(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，仍然不能保留小数部分。
3、类型转换只是临时性的
无论是自动类型转换还是强制类型转换，都只是为了本次运算而进行的临时性转换，转换的结果也会保存到临时的内存空间，不会改变数据本来的类型或者值。请看下面的例子：
#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。
4、自动类型转换 VS 强制类型转换
在C语言中，有些类型既可以自动转换，也可以强制转换，例如 int 到 double，float 到 int 等；而有些类型只能强制转换，不能自动转换，例如以后将要学到的 void * 到 int *，int 到 char * 等。
可以自动转换的类型一定能够强制转换，但是，需要强制转换的类型不一定能够自动转换。现在我们学到的数据类型，既可以自动转换，又可以强制转换，以后我们还会学到一些只能强制转换而不能自动转换的类型。
可以自动进行的类型转换一般风险较低，不会对程序带来严重的后果，例如，int 到 double 没有什么缺点，float 到 int 顶多是数值失真。只能强制进行的类型转换一般风险较高，或者行为匪夷所思，例如，char * 到 int * 就是很奇怪的一种转换，这会导致取得的值也很奇怪，再如，int 到 char * 就是风险极高的一种转换，一般会导致程序崩溃。
使用强制类型转换时，程序员自己要意识到潜在的风险。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
