C 语言类型转换：隐式转换与强制类型转换

C 无时无刻不在类型之间转换值。其中一些转换是你自己用强制转换写出来的；大部分则是编译器按照不由你选择的规则悄悄完成的。分清这两者，就是“为什么我的平均值总是 3？”和代码言行一致之间的区别。

隐式转换

只要某个类型的值出现在需要另一种类型的地方，C 就会转换它：

#include <stdio.h>

int main(void) {
    int    i = 5;
    double d = i;        /* int -> double: 5.0, exact */
    char   c = 'A';
    int    code = c;     /* char -> int: 65 */
    double pi = 3.9;
    int    truncated = pi;   /* double -> int: 3, the .9 is gone */

    printf("d         = %f\n", d);
    printf("code      = %d\n", code);
    printf("truncated = %d\n", truncated);
    return 0;
}

不会丢失信息的转换（int 转 double、char 转 int、short 转 long）是拓宽转换，始终安全。反方向的转换是收窄转换，可能丢失数据：上面的 3.9 变成了 3，除非你用 -Wconversion 要求警告，否则不会有任何提示。

常规算术转换

当二元运算符的操作数类型不同时，C 会先把它们转换为同一种类型再进行运算。这个阶梯自下而上是：

1. 所有比 int 小的类型（char、short、_Bool）都会提升为 int。这叫整数提升，它总是最先发生。
2. 如果任意一边是 long double，另一边就变成 long double。
3. 否则，如果任意一边是 double，另一边就变成 double。
4. 否则，如果任意一边是 float，另一边就变成 float。
5. 否则，在整数类型之间，等级高的一方胜出；如果等级相同，无符号的一方胜出。

最后这条规则才是真正引发 bug 的那条，其余的都很直观。

#include <stdio.h>

int main(void) {
    char a = 100, b = 100;

    /* a and b are promoted to int first, so 10000 fits fine. */
    printf("a * b as int = %d\n", a * b);

    /* But storing it back in a char narrows it again. */
    char product = a * b;
    printf("stored in char = %d\n", product);
    return 0;
}

整数提升解释了为什么 char 运算不会像你预想的那样溢出，也解释了为什么把结果存回 char 时会溢出。

显式强制转换

强制转换就是放在括号里的目标类型：

(double)x
(int)3.9
(char)65
(unsigned int)n

它作用于紧跟在它后面的表达式，而且结合得非常紧，比 *、/ 或 + 都紧。

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("no cast:        %f\n", (double)(total / count));  /* 3.0 */
    printf("cast first:     %f\n", (double)total / count);    /* 3.5 */
    printf("cast both:      %f\n", (double)total / (double)count);
    return 0;
}

第一行先按整数相除（得到 3），再把 3 转换成 3.0，已经太晚了。第二行在除法之前就把 total 转换成了 double，所以 / 运算符看到的是一个 double 和一个 int，它会提升那个 int，然后进行浮点除法。

转换一个操作数就够了，常规算术转换会处理另一个。

解决整数除法问题

这是在 C 中写强制转换最常见的原因：

#include <stdio.h>

int main(void) {
    int scores[] = {88, 92, 75, 61, 90};
    int n = 5;
    int sum = 0;

    for (int i = 0; i < n; i++) {
        sum += scores[i];
    }

    printf("sum = %d\n", sum);
    printf("wrong average: %f\n", (double)(sum / n));    /* 81.000000 - divided as ints, THEN converted */
    printf("right average: %f\n", (double)sum / n);      /* 81.200000 */

    /* Percentages have the same trap. */
    int passed = 3;
    printf("wrong pct: %d%%\n", passed / n * 100);            /* 0 percent */
    printf("right pct: %.1f%%\n", 100.0 * passed / n);        /* 60.0 percent */
    return 0;
}

百分比那一行很有启发性：passed / n 是 3 / 5，按整数计算是 0，而 0 * 100 还是 0。先乘后除（100 * passed / n）即使不用强制转换也能修好，因为 300 / 5 能整除，但这只在数字恰好配合时才有效。强制转换才是可靠的修复方法。

是截断，不是四舍五入

把浮点值强制转换成整数会丢弃小数部分。它向零截断，而不是四舍五入：

#include <stdio.h>
#include <math.h>

int main(void) {
    printf("(int) 3.2  = %d\n", (int) 3.2);
    printf("(int) 3.9  = %d\n", (int) 3.9);    /* 3, not 4 */
    printf("(int)-3.9  = %d\n", (int)-3.9);    /* -3, not -4 */

    /* Real rounding from math.h: */
    printf("round(3.9)  = %d\n", (int)round(3.9));    /* 4  */
    printf("round(-3.9) = %d\n", (int)round(-3.9));   /* -4 */
    printf("floor(3.9)  = %d\n", (int)floor(3.9));    /* 3  */
    printf("ceil(3.2)   = %d\n", (int)ceil(3.2));     /* 4  */
    return 0;
}

如果在你自己的机器上编译，记住在 Linux 上 math.h 需要在链接时加 -lm。

还有一个隐患：转换一个超出整数类型范围的浮点值是未定义行为，而不是回绕。(int)1e20 可能产生任何结果。当值不受你控制时，转换前先检查范围。

char 与 int

C 中的 char 本身就是一个存放字符编码的小整数。两者之间的转换是日常操作：

#include <stdio.h>

int main(void) {
    char letter = 'A';
    int code = letter;

    printf("'%c' has code %d\n", letter, code);
    printf("code + 1 is '%c'\n", (char)(code + 1));   /* 'B' */

    /* Digit character to its numeric value: */
    char digit = '7';
    int value = digit - '0';
    printf("the character '%c' as a number is %d\n", digit, value);

    /* Upper to lower, using the fixed 32-position gap in ASCII: */
    for (char ch = 'A'; ch <= 'E'; ch++) {
        printf("%c -> %c\n", ch, (char)(ch + 32));
    }
    return 0;
}

digit - '0' 是把数字字符转换成数值的标准写法，之所以可行，是因为十个数字字符保证是连续的。对于字母，优先使用 ctype.h 中的 toupper() 和 tolower()，而不是 + 32 运算：这个偏移量是 ASCII 的事实，而不是 C 的保证。

相关的陷阱：ctype.h 中的函数，比如 isdigit 和 toupper，接收的 int 必须是 EOF 或者能用 unsigned char 表示的值。传入一个为负数的普通 char（这是可能的，因为普通 char 可能是有符号的）属于未定义行为。要先转换：isdigit((unsigned char)c)。

有符号与无符号的陷阱

转换阶梯的第 5 步，即等级相同时无符号胜出，造就了 C 中最出人意料的比较：

#include <stdio.h>

int main(void) {
    int          signed_val = -1;
    unsigned int unsigned_val = 1;

    if (signed_val < unsigned_val) {
        printf("-1 is less than 1  (what you expect)\n");
    } else {
        printf("-1 is NOT less than 1  (what C actually says)\n");
    }

    printf("(unsigned)-1 = %u\n", (unsigned int)signed_val);
    return 0;
}

-1 被转换为 unsigned int，它的位模式被重新解释为 4,294,967,295。这比 1 大，所以比较结果为假。

同样的转换会让循环永远不结束：

/* BUG: i is unsigned, so i >= 0 is always true. When i is 0, i-- wraps. */
for (size_t i = n - 1; i >= 0; i--) { ... }

也会让长度检查失效：

/* BUG: strlen returns size_t (unsigned). If the string is shorter
   than 5, len - 5 wraps to a huge number and the test passes. */
if (strlen(s) - 5 > 0) { ... }

改写成 if (strlen(s) > 5)，减法就不会发生了。

防御方法：让计数和下标始终保持同一种符号性，用 -Wsign-compare 编译（包含在 -Wextra 中），必须混用时，先确认值不可能为负，再显式转换。

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *s = "hi";
    size_t len = strlen(s);

    /* Safe: compare without subtracting. */
    if (len > 5) {
        printf("long\n");
    } else {
        printf("short: %zu characters\n", len);
    }

    /* Safe: cast to a signed type once the value is known to be small. */
    int signed_len = (int)len;
    printf("len - 5 = %d\n", signed_len - 5);
    return 0;
}

指针的强制转换

强制转换也可以在指针类型之间转换，这时它带有真正的风险，因为它改变的是内存的解读方式，而不是字节本身。

#include <stdio.h>

int main(void) {
    int value = 1;
    /* View the bytes of an int through a char pointer. */
    unsigned char *bytes = (unsigned char *)&value;

    printf("int 1 is stored as bytes:");
    for (size_t i = 0; i < sizeof(int); i++) {
        printf(" %02x", bytes[i]);
    }
    printf("\n");
    return 0;
}

在小端机器上，这会打印 01 00 00 00。通过 unsigned char * 查看对象的表示形式，是标准明确认可的少数几种指针转换之一。

其他大多数指针转换都没有得到认可。通过 float * 读取 int 违反了严格别名规则，即使能编译也是未定义行为；要重新解释字节，请改用 memcpy。

有两个值得了解的惯例。在 C 中，void * 可以不加强制转换地与任何对象指针类型互相转换，所以你不应该对 malloc 的结果做强制转换：

int *arr = malloc(n * sizeof *arr);        /* correct C */
int *arr = (int *)malloc(n * sizeof *arr); /* needless; hides a missing header */

C++ 中必须加这个强制转换，所以很多代码里都有它。在 C 中，它可能会掩盖忘记包含 <stdlib.h> 的错误。

另外，printf("%p", ...) 需要 void *，所以在这里指针参数确实需要强制转换：printf("%p", (void *)p)。

强制转换不是正确答案的时候

强制转换会让编译器闭嘴。但有时候编译器是对的。

long big = 5000000000L;
int  small = (int)big;    /* the cast hides real data loss */

如果值确实放得下，强制转换表明你检查过了。如果可能放不下，强制转换就把一条警告变成了一个悄无声息的错误结果。写强制转换之前，先问问自己，正确的修复是不是改变变量的类型：用 double 代替 int，用 size_t 代替 int，用 long long 代替 long。强制转换主要适用于两种都正确的类型必须在一次运算中相遇的情况，比如 (double)sum / count。