10.溢出
每一种数据类型都有数值范围，如果存放的数值超出了这个范围（小于最小值或大于最大值），需要更多的二进制位存储，就会发生溢出。大于最大值，叫做向上溢出（overflow）；小于最小值，叫做向下溢出（underflow）。一般来说，编译器不会对溢出报错，会正常执行代码，但是会忽略多出来的二进制位，只保留剩下的位，这样往往会得到意想不到的结果。所以，应该避免溢出。
unsigned char x = 255; x = x + 1; printf("%d\n", x); // 0
上面示例中，变量 x 加 1 ，得到的结果不是 256 ，而是 0 。因为 x 是 unsign char 类型，最大值是255 （二进制 11111111 ），加 1 后就发生了溢出， 256 （二进制 100000000 ）的最高位 1 被丢弃，剩下的值就是 0 。
再看下面的例子。
unsigned int ui = UINT_MAX; // 4,294,967,295 ui++; printf("ui = %u\n", ui); // 0 ui--; printf("ui = %u\n", ui); // 4,294,967,295
上面示例中，常量 UINT_MAX 是 unsigned int 类型的最大值。如果加 1 ，对于该类型就会溢出，从而得到 0 ；而 0 是该类型的最小值，再减 1 ，又会得到 UINT_MAX 。溢出很容易被忽视，编译器又不会报错，所以必须非常小心。
for (unsigned int i = n; i >= 0; --i) // 错误
上面代码表面看似乎没有问题，但是循环变量 i 的类型是 unsigned int，这个类型的最小值是 0 ，不可能得到小于0的结果。当 i 等于0，再减去 1 的时候，并不会返回 -1 ，而是返回 unsigned int 的类型最大值，这个值总是大于等于 0 ，导致无限循环。为了避免溢出，最好方法就是将运算结果与类型的极限值进行比较。
unsigned int ui; unsigned int sum; // 错误 if (sum + ui > UINT_MAX) too_big(); else sum = sum + ui; // 正确 if (ui > UINT_MAX - sum) too_big(); else sum = sum + ui;
上面示例中，变量 sum 和 ui 都是 unsigned int 类型，它们相加的和还是 unsigned int 类型，这就有可能发生溢出。但是，不能通过相加的和是否超出了最大值 UINT_MAX ，来判断是否发生了溢出，因为sum + ui 总是返回溢出后的结果，不可能大于 UINT_MAX 。正确的比较方法是，判断 UINT_MAX - sum与 ui 之间的大小关系。
下面是另一种错误的写法。 unsigned int i = 5; unsigned int j = 7; if (i - j < 0) // 错误 printf("negative\n"); else printf("positive\n");
上面示例的运算结果，会输出 positive 。原因是变量 i 和 j 都是 unsigned int 类型， i - j 的结果也是这个类型，最小值为 0 ，不可能得到小于 0 的结果。正确的写法是写成下面这样。
if (j > i) // ....
11.sizeof 运算符
sizeof 是 C 语言提供的一个运算符，返回某种数据类型或某个值占用的字节数量。它的参数可以是数据类型的关键字，也可以是变量名或某个具体的值。
// 参数为数据类型 int x = sizeof(int); // 参数为变量 int i; sizeof(i); // 参数为数值 sizeof(3.14);
上面的第一个示例，返回得到 int 类型占用的字节数量（通常是 4 或 8 ）。第二个示例返回整数变量占用字节数量，结果与前一个示例完全一样。第三个示例返回浮点数 3.14 占用的字节数量，由于浮点数的字面量一律存储为 double 类型，所以会返回 8 ，因为 double 类型占用的8个字节。sizeof 运算符的返回值，C 语言只规定是无符号整数，并没有规定具体的类型，而是留给系统自己去决定， sizeof 到底返回什么类型。不同的系统中，返回值的类型有可能是 unsigned int ，也有可能是unsigned long ，甚至是 unsigned long long ，对应的 printf() 占位符分别是 %u 、 %lu和 %llu 。这样不利于程序的可移植性。C 语言提供了一个解决方法，创造了一个类型别名 size_t ，用来统一表示 sizeof 的返回值类型。该别名定义在 stddef.h 头文件（引入 stdio.h 时会自动引入）里面，对应当前系统的 sizeof 的返回值类型，可能是 unsigned int ，也可能是 unsigned long 。C 语言还提供了一个常量 SIZE_MAX ，表示 size_t 可以表示的最大整数。所以， size_t 能够表示的整数范围为 [0, SIZE_MAX] 。
printf() 有专门的占位符 %zd 或 %zu ，用来处理 size_t 类型的值。
printf("%zd\n", sizeof(int));
上面代码中，不管 sizeof 返回值的类型是什么， %zd 占位符（或 %zu ）都可以正确输出。
如果当前系统不支持 %zd 或 %zu ，可使用 %u （unsigned int）或 %lu （unsigned long int）代替。
12.类型的自动转换
某些情况下，C 语言会自动转换某个值的类型。
赋值运算
赋值运算符会自动将右边的值，转成左边变量的类型。
（1）浮点数赋值给整数变量
浮点数赋予整数变量时，C 语言直接丢弃小数部分，而不是四舍五入。
int x = 3.14;
上面示例中，变量 x 是整数类型，赋给它的值是一个浮点数。编译器会自动把 3.14 先转为 int 类型，丢弃小数部分，再赋值给 x ，因此 x 的值是 3 。这种自动转换会导致部分数据的丢失（ 3.14 丢失了小数部分），所以最好不要跨类型赋值，尽量保证变量与所要赋予的值是同一个类型。注意，舍弃小数部分时，不是四舍五入，而是整个舍弃。
int x = 12.99;
上面示例中， x 等于 12 ，而不是四舍五入的 13 。
（2）整数赋值给浮点数变量
整数赋值给浮点数变量时，会自动转为浮点数。
float y = 12 * 2;
上面示例中，变量 y 的值不是 24 ，而是 24.0 ，因为等号右边的整数自动转为了浮点数。
（3）窄类型赋值给宽类型
字节宽度较小的整数类型，赋值给字节宽度较大的整数变量时，会发生类型提升，即窄类型自动转为宽类型。
比如， char 或 short 类型赋值给 int 类型，会自动提升为 int 。
char x = 10; int i = x + y;
上面示例中，变量 x 的类型是 char ，由于赋值给 int 类型，所以会自动提升为 int 。
（4）宽类型赋值给窄类型
字节宽度较大的类型，赋值给字节宽度较小的变量时，会发生类型降级，自动转为后者的类型。这时可能会发生截值（truncation），系统会自动截去多余的二进制位，导致难以预料的结果。
int i = 321; char ch = i; // ch 的值是 65 （321 - 256）
上面例子中，变量 ch 是 char 类型，宽度是8个二进制位。变量 i 是 int 类型，将 i 赋值给 ch ，后者只能容纳 i （二进制形式为 101000001 ，共9位）的后八位，前面多出来的二进制位被丢弃，保留后八位就变成了 01000001 （十进制的65，相当于字符 A ）。浮点数赋值给整数类型的值，也会发生截值，浮点数的小数部分会被截去。
double pi = 3.14159; int i = pi; // i 的值为 3
上面示例中， i 等于 3 ， pi 的小数部分被截去了。
13.混合类型的运算
不同类型的值进行混合计算时，必须先转成同一个类型，才能进行计算。转换规则如下：
（1）整数与浮点数混合运算时，整数转为浮点数类型，与另一个运算数类型相同。
3 + 1.2 // 4.2
上面示例是 int 类型与 float 类型的混合计算， int 类型的 3 会先转成 float 的 3.0 ，再进行计算，得到 4.2 。
（2）不同的浮点数类型混合运算时，宽度较小的类型转为宽度较大的类型，比如 float 转为
double ， double 转为 long double 。
（3）不同的整数类型混合运算时，宽度较小的类型会提升为宽度较大的类型。比如 short 转为 int ，
int 转为 long 等，有时还会将带符号的类型 signed 转为无符号 unsigned 。
下面例子的执行结果，可能会出人意料。
int a = -5; if (a < sizeof(int)） do_something();
上面示例中，变量 a 是带符号整数， sizeof(int) 是 size_t 类型，这是一个无符号整数。按照规则，signed int 自动转为 unsigned int，所以 a 会自动转成无符号整数 4294967291 （转换规则是 -5 加上无符号整数的最大值，再加1），导致比较失败， do_something() 不会执行。
所以，最好避免无符号整数与有符号整数的混合运算。因为这时 C 语言会自动将 signed int 转为unsigned int ，可能不会得到预期的结果。
14.整数类型的运算
两个相同类型的整数运算时，或者单个整数的运算，一般来说，运算结果也属于同一类型。但是有一个例外，宽度小于 int 的类型，运算结果会自动提升为 int 。
unsigned char a = 66; if ((-a) < 0) printf("negative\n"); else printf("positive\n");
上面示例中，变量 a 是 unsigned char 类型，这个类型不可能小于0，但是 -a 不是 unsigned char 类型，会自动转为 int 类型，导致上面的代码输出 negative。
再看下面的例子。
unsigned char a = 1; unsigned char b = 255; unsigned char c = 255; if ((a - 5) < 0) do_something(); if ((b + c) > 300) do_something();
上面示例中，表达式 a - 5 和 b + c 都会自动转为 int 类型，所以函数 do_something() 会执行两次。
15.函数
函数的参数和返回值，会自动转成函数定义里指定的类型。
int dostuff(int, unsigned char); char m = 42; unsigned short n = 43; long long int c = dostuff(m, n);
上面示例中，参数变量 m 和 n 不管原来的类型是什么，都会转成函数 dostuff() 定义的参数类型。下面是返回值自动转换类型的例子。
char func(void) { int a = 42; return a; }
上面示例中，函数内部的变量 a 是 int 类型，但是返回的值是 char 类型，因为函数定义中返回的是这个类型。
16.类型的显式转换
原则上，应该避免类型的自动转换，防止出现意料之外的结果。C 语言提供了类型的显式转换，允许手动转换类型。
只要在一个值或变量的前面，使用圆括号指定类型 (type) ，就可以将这个值或变量转为指定的类型，这叫做“类型指定”（casting）。
(unsigned char) ch
上面示例将变量 ch 转成无符号的字符类型。
long int y = (long int) 10 + 12;
上面示例中， (long int) 将 10 显式转为 long int 类型。这里的显示转换其实是不必要的，因为赋值运算符会自动将右边的值，转为左边变量的类型。
17.可移植类型
C 语言的整数类型（short、int、long）在不同计算机上，占用的字节宽度可能是不一样的，无法提前知道它们到底占用多少个字节。
程序员有时控制准确的字节宽度，这样的话，代码可以有更好的可移植性，头文件 stdint.h 创造了一些新的类型别名。
（1）精确宽度类型(exact-width integer type)，保证某个整数类型的宽度是确定的。
int8_t ：8位有符号整数。
int16_t ：16位有符号整数。
int32_t ：32位有符号整数。
int64_t ：64位有符号整数。
uint8_t ：8位无符号整数。
uint16_t ：16位无符号整数。
uint32_t ：32位无符号整数。
uint64_t ：64位无符号整数。
上面这些都是类型别名，编译器会指定它们指向的底层类型。比如，某个系统中，如果 int 类型为32位， int32_t 就会指向 int ；如果 long 类型为32位， int32_t 则会指向 long 。下面是一个使用示例。
#include <stdio.h> #include <stdint.h> int main(void) { int32_t x32 = 45933945; printf("x32 = %d\n", x32); return 0; }
上面示例中，变量 x32 声明为 int32_t 类型，可以保证是32位的宽度。
（2）最小宽度类型（minimum width type），保证某个整数类型的最小长度。
int_least8_t
int_least16_t
int_least32_t
int_least64_t
uint_least8_t
uint_least16_t
uint_least32_t
uint_least64_t
上面这些类型，可以保证占据的字节不少于指定宽度。比如， int_least8_t 表示可以容纳8位有符号整数的最小宽度的类型。
（3）最快的最小宽度类型（fast minimum width type），可以使整数计算达到最快的类型。
int_fast8_t
int_fast16_t
int_fast32_t
int_fast64_t
uint_fast8_t
uint_fast16_t
uint_fast32_t
uint_fast64_t
上面这些类型是保证字节宽度的同时，追求最快的运算速度，比如 int_fast8_t 表示对于8位有符号整数，运算速度最快的类型。这是因为某些机器对于特定宽度的数据，运算速度最快，举例来说，32位计算机对于32位数据的运算速度，会快于16位数据。
（4）可以保存指针的整数类型。
intptr_t ：可以存储指针（内存地址）的有符号整数类型。
uintptr_t ：可以存储指针的无符号整数类型。
（5）最大宽度整数类型，用于存放最大的整数。
intmax_t ：可以存储任何有效的有符号整数的类型。
uintmax_t ：可以存放任何有效的无符号整数的类型。
上面的这两个类型的宽度比 long long 和 unsigned long 更大。
