【C语言】学习笔记第7章基本类型 7.4 类型转换

小咪咪 2024-03-22 09:15 9阅读 0赞

### 【C语言】学习笔记 ###

#### 文章目录 ####

*   *  【C语言】学习笔记
     *   *  第7章 基本类型
         *   *  7.4 类型转换
             *   *  7.4.1 常规算术转换
                 *  7.4.2 赋值过程中的转换
                 *  7.4.3 C99中的隐式转换
                 *  7.4.4 强制类型转换

#### 第7章 基本类型 ####

![在这里插入图片描述][474abd6b4eee4e639e163e39a9cc3baf.png_pic_center]

计算机处理的是数而不是符号。我们用对行为的算术化程度 来衡量我们的理解力（和控制力）。

##### 7.4 类型转换 #####

C 语言允许在表达式中**混合使用**基本类型。在单个表达式中可以组合整数、浮点数，甚 至是字符。

例如，如果对 16 位 short 型数和 32 位 int 型数进行加 法操作，那么编译器将安排把 16 位 short 型值转换成 32 位值。如果是 int 型数据和 float 型 数据进行加法操作，那么编译器将安排把 int 型值转换成为 float 格式。这个转换过程稍微复 杂一些，因为 int 型值和 float 型值的存储方式不同。

因为编译器可以自动处理这些转换而无须程序员介入，所以这类转换称为**隐式转换** （implicit conversion）。C 语言还允许程序员使用强制运算符执行**显式转换**（explicit conversion）。

当发生下列情况时会进行隐式转换：

*  当算术表达式或逻辑表达式中操作数的类型不相同时。（C语言执行所谓的常规算术转换。
 *  当赋值运算符右侧表达式的类型和左侧变量的类型不匹配时。
 *  当函数调用中的实参类型与其对应的形参类型不匹配时。
 *  当 return 语句中表达式的类型和函数返回值的类型不匹配时。

###### 7.4.1 常规算术转换 ######

常规算术转换可用于大多数二元运算符（包括算术运算符、关系运算符和判等运算符）的 操作数。

常规算术转换的策略是**把操作数转换成可以安全地适用于两个数值的“最狭小的”数据类 型。**（粗略地说，如果某种类型要求的存储字节比另一种类型少，那么这种类型就比另一种类型 更狭小。）

为了统一操作数的类型，通常可以将相对较狭小类型的操作数转换成另一个操作数的 类型来实现（这就是所谓的**提升**）。

最常用的提升是整值提升（integral promotion），它把 **字符或短整数转换成 int 类型**（或者某些情况下是 unsigned int 类型）。

执行常规算术转换的规则可以划分成两种情况：

1.  任一操作数的类型是浮点类型的情况。
    
    ![在这里插入图片描述][389fa0f054b1400da6cf3600e92e0d9b.png_pic_center]
    
    也就是说，如果一个操作数的类型为 long double，那么把另一个操作数的类型转换成 long double 类型。否则，如果一个操作数的类型为 double 类型，那么把另一个操作 数转换成 double 类型。否则，如果一个操作数的类型是 float 类型，那么把另一个操 作数转换成 float 类型。\*\*注意，这些规则涵盖了混合整数和浮点类型的情况。\*\*例如，如 果一个操作数的类型是 long int 类型，并且另一个操作数的类型是 double 类型，那 么把 long int 类型的操作数转换成 double 类型。
2.  两个操作数的类型都不是浮点类型的情况。
    
    ![在这里插入图片描述][7f98a4f45e3049bf98008a159d84712c.png_pic_center]
    
    首先对两个操作数进行整值提升（保证没有 一个操作数是字符类型或短整型）。然后按照上图对类型较狭小的操作数进行提升：
    
    有一种特殊情况，只有在 long int 类型和 unsigned int 类型长度相同（比如 32 位） 时才会发生。在这类情况下，如果一个操作数的类型是 long int，而另一个操作数的 类型是 unsigned int，那么两个操作数都会转换成 unsigned long int 类型。

【注意】当有符号操作数和无符号操作数组合起来时，有符号操作数会被“转换”为无符号 的值。转换过程中需要加上或者减去 n+1 的倍数，其中 n 是无符号类型能表示的最大 值。`但是这条规则可能会导致一些隐蔽的编程错误`

假设 int 类型的变量 `i` 值为`-10`，而 `unsigned int` 类型的变量 `u` 值为 `10`。如果用< 运算符比较变量 i 和变量 u，那么期望的结果应该是 `1（真）`。但是，在比较前，变 量 `i` 转换为 `unsigned int` 类型。因为负数不能被表示成无符号整数，所以转换后 的值将不再为-10，而是加上 4 294 967 296 的结果（假定 4 294 967 295 是最大的无符 号整数），即 `4 294 967 286`。因而 i < u 比较的结果将为 0。有些编译器会在程序试 图比较有符号数与无符号数时给出一条类似“comparison between signed and unsigned” 的警告消息。【避免这种陷阱发生，最好尽量避免使用无符号整数，特别是不要把它和有符 号整数混合使用。】

下面是一些常规算术转换的实际执行情况：

char c; 
    short int s; 
    int i; 
    unsigned int u; 
    long int l; 
    unsigned long int ul; 
    float f; 
    double d; 
    long double ld; 
    
    i = i + c; /* c is converted to int */ 
    i = i + s; /* s is converted to int */ 
    u = u + i; /* i is converted to unsigned int */ 
    l = l + u; /* u is converted to long int */ 
    ul = ul + l; /* l is converted to unsigned long int */ 
    f = f + ul; /* ul is converted to float */ 
    d = d + f; /* f is converted to double */ 
    ld = ld + d; /* d is converted to long double */

###### 7.4.2 赋值过程中的转换 ######

常规算术转换不适用于赋值运算。C 语言会遵循另一条简单的转换规则，那就是**把赋值运 算右边的表达式转换成左边变量的类型**。如果变量的类型至少和表达式类型一样“宽”，那么这 种转换将没有任何障碍。例如：

char c; 
    int i; 
    float f; 
    double d; 
    
    i = c; /* c is converted to int */ 
    f = i; /* i is converted to float */ 
    d = f; /* f is converted to double */

此外，把某种类型的值赋给类型更狭小的变量时， 如果该值在变量类型范围之外，那 么将得到无意义的结果（甚至更糟）。

c = 10000; /*** WRONG ***/ 
    i = 1.0e20; /*** WRONG ***/ 
    f = 1.0e100; /*** WRONG ***/

如果浮点常量被赋值给 float 型变量，那么建议在浮点常量尾部加上后缀 f，`f = 3.14159f;`如果没有后缀，常量 3.14159 将是 double 类型，可能会触发警告。

###### 7.4.3 C99中的隐式转换 ######

C99 中的隐式转换和 C89 中的隐式转换略有不同，这主要是因为 C99 增加了一些类型 （`_Bool`、`long long` 类型、扩展的整数类型和复数类型）

为了定义转换规则，C99 允许每个整数类型具有“**整数转换等级**”。下面按从最高级到最低 级的顺序排列

(1) long long int、unsigned long long int
    (2) long int、unsigned long int
    (3) int、unsigned int 
    (4) short int、unsigned short int 
    (5) char、signed char、unsigned char
    (6) _Bool

C99 用整数提升（integer promotion）取代了 C89 中的整值提升（integral promotion），可以 将任何等级低于 int 和 unsigned int 的类型转换为 int（只要该类型的所有值都可以用 int 类型表示）或 unsigned int。

与 C89 一样，C99 中执行常规算术转换的规则可以分为两种情况：

*  任一操作数的类型是浮点类型的情况。
    
    只要两个操作数都不是复数型，规则与前面一样
    
    ![在这里插入图片描述][86ba6263d17c4a048554e2a970624504.png_pic_center]
 *  两个操作数的类型都不是浮点类型的情况。
    
    首先对两个操作数进行整数提升。如果这时 两个操作数的类型相同，过程结束。否则，依次尝试下面的规则，一旦遇到可应用的规 则就不再考虑别的规则。
    
     *  如果两个操作数都是有符号型或者都是无符号型，将整数转换等级较低的操作数转换 为等级较高的操作数的类型。
     *  如果无符号操作数的等级高于或等于有符号操作数的等级，将有符号操作数转换为无 符号操作数的类型。
     *  如果有符号操作数类型可以表示无符号操作数类型的所有值，将无符号操作数转换为 有符号操作数的类型。
     *  否则，将两个操作数都转换为与有符号操作数的类型相对应的无符号类型。

> 另外，所有算术类型都可以转换为\_Bool 类型。如果原始值为 0 则转换结果为 0，否则结 果为 1。

###### 7.4.4 强制类型转换 ######

C 语言提供了强制类型转换。强制类型转换表达式如下所示：

(类型名) 表达式

类型名表示的是表达式应该转换成的类型。

使用强制类型转换表达式计算 float 类型值小数部分的方法：

float f, frac_part; 
    frac_part = f – (int) f;

`f` 和`(int)f` 的不同之处就在于 f 的 小数部分，这部分在强制类型转换时被丢掉了。

C 语言把(类型名)视为一元运算符。一元运算符的优先级高于二元运算符， 因此编译器会把表达式

(float) dividend / divisor

解释为 `((float) dividend) / divisor`

有些时候，我们需要使用强制类型转换来避免溢出：

long i; 
    int j = 1000; 
    i = j * j; /* overflow may occur */

这样的`j * j`算出来是1000000，int 型是装不下的，赋值直接就已经溢出了，可以使用强制类型转换避免这种问题发生：

i = (long) j * j;

因为强制运算符的优先级高于\*，所以第一个变量 j 会被转换成 long int 类型，同时也迫使第 二个 j 进行转换。

[474abd6b4eee4e639e163e39a9cc3baf.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/c6a5c6be474141329073043ecee777ba.png
[389fa0f054b1400da6cf3600e92e0d9b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/89eaa9d787504641924c53ff6d5cfb72.png
[7f98a4f45e3049bf98008a159d84712c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/d16ac9f9f3d14c419632694b739d78fa.png
[86ba6263d17c4a048554e2a970624504.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/65fe491f58e0409d91614e0f7fbdb437.png