数值类型转换

在编程实践中，不同数值类型之间的转换操作十分常见。根据转换后数值范围的变化，可将数值类型转换归纳为两大类：宽转换（Widening Conversion）与窄转换（Narrowing Conversion）。宽转换是指从表示范围较小的类型向范围更大的类型转换，例如从 int 到 long、从 long 到 float；窄转换则相反，是从大范围类型向小范围类型转换。深入理解这两种转换的底层机制，有助于你规避许多潜在的编程错误。

整型间转换

整型涵盖有符号整数与无符号整数，其转换规则与二进制位的处理方式密切相关。

（1）宽转换

整型之间的宽转换不会导致溢出。具体规则如下：

• 若转换前后的类型均为无符号整数，则在高位补零。
• 若转换前后的类型均为有符号整数，则在高位补符号位（正数补0，负数补1）。

// C++
int main() {
    int8_t i1 = 100;
    cout << "int8_t  i1: " << bitset<8>(i1) << endl;
    cout << "int16_t i1: " << bitset<16>((int16_t) i1) << endl;
    int8_t i2 = -100;
    cout << "int8_t  i2: " << bitset<8>(i2) << endl;
    cout << "int16_t i2: " << bitset<16>((int16_t) i2) << endl;
    uint8_t i3 = 200;
    cout << "uint8_t  i3: " << bitset<8>(i3) << endl;
    cout << "uint16_t i3: " << bitset<16>((uint16_t) i3) << endl;
    return 0;
}
// 输出结果
int8_t  i1: 01100100
int16_t i1: 0000000001100100
int8_t  i2: 10011100
int16_t i2: 1111111110011100
uint8_t  i3: 11001000
uint16_t i3: 0000000011001000

小提示：宽转换始终是安全的，不会丢失数据或发生溢出。因此，许多编程语言（如 Ja va）在需要时会自动执行宽转换（隐式类型转换）。

（2）窄转换

整型之间的窄转换直接进行高位截断，仅保留低 n 位。例如，将16位的 int16 转换为8位的 int8 时，会直接保留 int16 的低8位作为结果。

// C++
int main() {
    int16_t i1 = 200;
    cout << "int16_t i1: " << bitset<16>(i1) << endl;
    cout << "int8_t  i1: " << bitset<8>((int8_t) i1) << endl;
    int16_t i2 = -200;
    cout << "int16_t i2: " << bitset<16>(i2) << endl;
    cout << "int8_t  i2: " << bitset<8>((int8_t) i2) << endl;
    uint16_t i3 = 300;
    cout << "uint16_t i3: " << bitset<16>(i3) << endl;
    cout << "uint8_t  i3: " << bitset<8>((uint8_t) i3) << endl;
    return 0;
}
// 输出结果
int16_t i1: 0000000011001000
int8_t  i1: 11001000
int16_t i2: 1111111100111000
int8_t  i2: 00111000
uint16_t i3: 0000000100101100
uint8_t  i3: 00101100

风险提示：窄转换会导致数据截断，高位信息可能丢失，结果可能不符合预期。例如上例中 int16_t i2 = -200 转换后变成了正数 56（因为高位符号位被截掉）。务必谨慎使用显式强制转换。

（3）无符号整数与有符号整数间的转换

转换规则分为两种情形：

• 如果两者二进制位数相同（例如 int8 到 uint8），则二进制数值不变，仅改变编码方式。即相同的二进制位，按有符号解释或无符号解释会得到不同的十进制数值。
• 如果位数不同（例如 int16 到 uint8），则先按照宽转换或窄转换的规则处理二进制位（补位或截断），再改变编码方式。

// C++
int main() {
    uint8_t i1 = 200;
    cout << "uint8_t i1, decimal: " << +i1 << ", binary: " << bitset<8>(i1) << endl;
    cout << "int8_t  i1, decimal: " << +(int8_t) i1 << ", binary: " << bitset<8>((int8_t) i1) << endl;
    int16_t i2 = -300;
    cout << "int16_t i2, decimal: " << +i2 << ", binary: " << bitset<16>(i2) << endl;
    cout << "uint8_t i2, decimal: " << +(uint8_t) i2 << ",  binary: " << bitset<8>((uint8_t) i2) << endl;
    return 0;
}
// 输出结果
uint8_t i1, decimal: 200, binary: 11001000
int8_t  i1, decimal: -56, binary: 11001000
int16_t i2, decimal: -300, binary: 1111111011010100
uint8_t i2, decimal: 212,  binary: 11010100

常见问题：为什么 uint8_t(200) 强转为 int8_t 后变成了 -56？

解答：因为 uint8_t 和 int8_t 位数相同（都是8位），转换时二进制值 11001000 不变。但 int8_t 是有符号数，最高位为1表示负数，按补码规则计算得到 -2^7 + 2^6 + 2^3 = -128 + 64 + 8 = -56。

整数与浮点数间转型

（1）宽转换

从整型转换到浮点数类型属于宽转换，因为浮点数的表示范围通常比整数更大。但需要注意精度问题：

• 如果浮点数的精度能够精确表示该整数，则结果准确。
• 如果浮点数精度不足，则需要进行近似处理，导致精度丢失。

// Ja va
public static void main(String[] args) {
    int i1 = 1234567;
    System.out.printf("int i1: %d, float i1: ", i1);
    System.out.println((float) i1);
    int i2 = 123456789;
    System.out.printf("int i2: %d, float i2: ", i2);
    System.out.println((float) i2);
}
// 输出结果
int i1: 1234567, float i1: 1234567.0
int i2: 123456789, float i2: 1.23456792E8

上例中，i2=123456789 超出了 float 类型（23位尾数）能精确表示的范围，因此近似为 1.23456792E8。具体的近似原理如下：

1. 将 int i2 写成二进制形式：00000111010110111100110100010101。
2. IEEE浮点数表示：(-1)^s * M * 2^E。其中 s=0，E=26，M=1.11010110111100110100010101。
3. 对于 float，阶码部分 k=8，偏置 bias=127，所以 e = E + bias = 26 + 127 = 153（二进制 10011001）。
4. 尾数部分 m 需要保留23位小数，而 M-1 有26位小数，因此需按 round-to-even（向偶舍入）规则截断为23位：0.11010110111100110100011。
5. 组合得到 float 的二进制：01001100111010110111100110100011，即十进制 1.23456792E8。

（2）窄转换

从浮点数转换到整型属于窄转换，规则如下：

• 如果浮点数的整数部分在整型范围内，则直接舍弃小数部分，保留整数部分（向零取整）。
• 如果浮点数超出了整型范围，则结果为该整型的最大值或最小值（对于有符号整型为 Integer.MAX_VALUE 或 Integer.MIN_VALUE）。

// Ja va
public static void main(String[] args) {
    float f1 = 12345.123F;
    System.out.print("float f1: ");
    System.out.print(f1);
    System.out.printf(",  int f1: %d\n", (int) f1);
    float f2 = 1.2345E20F;
    System.out.print("float f2: ");
    System.out.print(f2);
    System.out.printf(",  int f2: %d\n", (int) f2);
    float f3 = -1.2345E20F;
    System.out.print("float f3: ");
    System.out.print(f3);
    System.out.printf(", int f3: %d\n", (int) f3);
 }
// 输出结果
float f1: 12345.123,  int f1: 12345
float f2: 1.2345E20,  int f2: 2147483647
float f3: -1.2345E20, int f3: -2147483648

小提示：在 Ja va 中，浮点数转整型时，float f2 的值远大于 int 的最大值，结果为 Integer.MAX_VALUE（2147483647）。这种“饱和截断”行为有助于程序避免不可预测的溢出，但仍需谨慎对待。

浮点数间转型

（1）宽转换

从单精度 float 转换到双精度 double 属于宽转换，不会丢失精度。转换规则如下：

• 符号位 s 保持不变。
• 阶码部分：float 的 k=8，double 的 k=11，在 E 不变的前提下，e 值（偏移量不同）会重新计算。
• 尾数部分：float 的 n=23，double 的 n=52，因此 m 需要在低位补 52 - 23 = 29 个0。

// Ja va
public static void main(String[] args) {
    float f1 = 1.2345E20F;
    System.out.print("float  f1: ");
    System.out.print(f1);
    System.out.print(", double f1: ");
    System.out.println((double) f1);
    System.out.println("float  f1: " + float2BinaryStr(f1));
    System.out.println("double f1: " + double2BinaryStr((double) f1));
}
// 输出结果
float  f1: 1.2345E20, double f1: 1.2344999897320129E20
float  f1: 01100000110101100010011011010000
double f1: 0100010000011010110001001101101000000000000000000000000000000000

注意：尽管宽转换不会丢失精度，但 float 原本的近似值在转换为 double 后，数值不会变得更精确，只是用更多位数表示同一个近似值。上例中 double f1 打印为 1.2344999897320129E20，与原始 float 值一致。

（2）窄转换

从 double 转换到 float 属于窄转换，会存在精度丢失，甚至可能溢出。

• 如果 double 值超出了 float 的表示范围（约 ±3.4E38），则转换结果为 Infinity 或 -Infinity。
• 如果仍在 float 范围内，则按以下规则转换：
  • 符号位 s 不变。
  • 阶码部分重新计算，因为 float 的偏移量不同。
  • 尾数部分：只保留高23位，低位被截断。

// Ja va
public static void main(String[] args) {
    double d1 = 1E200;
    System.out.print("double d1: ");
    System.out.println(d1);
    System.out.print("float d1: ");
    System.out.println((float) d1);
    double d2 = -1E200;
    System.out.print("double d2: ");
    System.out.println(d2);
    System.out.print("float d2: ");
    System.out.println((float) d2);
 }
// 输出结果
double d1: 1.0E200
float d1: Infinity
double d2: -1.0E200
float d2: -Infinity

// Ja va
public static void main(String[] args) {
    double d1 = 3.267393471324506;
    System.out.print("double d1: ");
    System.out.println(d1);
    System.out.print("float  d1: ");
    System.out.println((float) d1);
    System.out.println("double d1: " + double2BinaryStr(d1));
    System.out.println("float  d1: " + float2BinaryStr((float) d1));
}
// 输出结果
double d1: 3.267393471324506
float  d1: 3.2673936
double d1: 0100000000001010001000111001111100110000001101000000010101110110
float  d1: 01000000010100010001110011111010

常见问题：为什么浮点数不能直接用等号比较？

解答：因为浮点数的二进制表示只能近似绝大多数十进制小数，并且运算过程中会累积舍入误差。即使两个计算结果在数学上相等，在计算机中也可能因精度问题而不同。通常应使用一个很小的误差阈值（如 Math.abs(a - b) < 1e-9）来比较，或使用 Float.compare() / Double.compare() 方法。

最后

数值类型之间的转换是编程中最基础也最容易出错的部分之一。宽转换通常安全，但窄转换以及无符号/有符号混合转换需要特别警惕。浮点数由于编码限制，其转换和比较都隐藏着精度陷阱。深入理解这些底层规则，能够帮助你编写出更健壮、更可靠的代码。在实际开发中，建议尽量使用同一类型的变量，减少不必要的类型转换；如果必须转换，请明确使用显式强制类型转换，并留意是否会发生截断、溢出或精度损失。