C语言：表达式运算的类型转换

相关阅读

C语言https://blog.csdn.net/weixin_45791458/category_12423166.html?spm=1001.2014.3001.5482

1、前言

C语言作为一种强类型语言，要求在进行操作时变量类型必须匹配。然而，为了提高灵活性和便利性，C语言提供了一套规则，用于在必要时自动转换不同类型的变量。这些规则称为类型转换（type conversion）。本文将详细介绍C语言中的类型转换及其重要性。

首先来看一个简单的表达式的例子，例1中的主函数内有一个赋值表达式，其中标识符a是左操作数（左值），一个乘法表达式作为子表达式是右操作数（右值）；对于这个乘法表达式，其左操作数(b+c)加法表达式是一个子表达式，标识符d是其右操作数；加法表达式中，标识符b、c分别是左、右操作数。

// 例1

int a;
char b;
float c;
double d;

int main()
{
    a = (b + c) * d;
    return 0;
}

从例1中可以看出，这些操作数的类型是不同的，因此它们在进行运算前会进行类型转换，需要特别注意的是：类型转换（除整型提升）是从表达式底层向上，且在表达式操作数这个范围进行的。也就是说，对于例1，操作数b和c的运算并不会受到操作数a和d影响（但是加法表达式的结果会受到操作数d的影响）；操作数d不会受到操作数a、b、c的影响，而是受到加法表达式结果的影响。对于赋值表达式，类型转换可能导致降级(demotion)，子表达式(b + c) * d的结果可能会因为操作数a发生类型转换，但操作数a不会受到赋值号右边表达式的影响。

2、整型提升 (Integer Promotion)

所有char类型和short类型（包括 signed 和 unsigned）在表达式中（如上面所说，赋值表达式的左操作数除外）都会被提升为int类型。如果short类型和int类型的大小相同（例如都是16位），则unsigned short类型会被转换为unsigned int类型。这是因为在这种情况下，unsigned short类型比int类型所能表示的最大值更大。整型提升是在全局的范围二不是表达式范围内进行的，因此在进行任何表达式计算和其他的类型转换前，整型提升就已经进行了。

下面是一个整型提升的例子。

// 例2

#include <stdio.h>

unsigned char b=255;
unsigned char c=255;
unsigned char d=255;

int main()
{
    long int a = (b + c) * d; 
    printf("%d \n", a);
	printf("%d \n", (b + c) * d);
    return 0;
}

输出：
130050 
130050

在例2中，操作数b、c、d在进行运算前都被提升为int类型：所以b+c并不会产生溢出，因为此时进行的是两个int类型相加得到int类型的运算，而不是两个unsigned char类型相加得到unsigned char类型的运算。在进行最后的赋值运算时，由于表达式(b + c) * d是int类型而标识符a是long int类型，会进行类型转换（此处是提升）。

3、类型检测宏

为了更加直观的分析表达式的类型，下面定义了一个可以检测表达式类型的类函数宏。

#define TYPEOF(x) _Generic((typeof(x)){0}, \
    char: "char", \
    unsigned char: "unsigned char", \
    short: "short", \
    unsigned short: "unsigned short", \
    int: "int", \
    unsigned int: "unsigned int", \
    long: "long", \
    unsigned long: "unsigned long", \
    long long: "long long", \
    unsigned long long: "unsigned long long", \
    float: "float", \
    double: "double", \
    long double: "long double", \
    default: "unknown")

下面的例3检测了例2中标识符a和表达式(b + c) * d)的类型，可以看到上面的分析无误。

// 例3
#include <stdio.h>
#define TYPEOF(x) _Generic((typeof(x)){0}, \
    char: "char", \
    unsigned char: "unsigned char", \
    short: "short", \
    unsigned short: "unsigned short", \
    int: "int", \
    unsigned int: "unsigned int", \
    long: "long", \
    unsigned long: "unsigned long", \
    long long: "long long", \
    unsigned long long: "unsigned long long", \
    float: "float", \
    double: "double", \
    long double: "long double", \
    default: "unknown")


unsigned char b=255;
unsigned char c=255;
unsigned char d=255;

int main()
{
    long int a = (b + c) * d; 
    printf("%d , type is %s \n", a, TYPEOF(a));
	printf("%d , type is %s \n", (b + c) * d, TYPEOF((b + c) * d));
    return 0;
}

输出：
130050 , type is long 
130050 , type is int

4、常见类型转换 (Usual Arithmetic Conversions)

一个表达式运算前，会先将其操作数先统一转换为其中的最高等级的类型（有些运算不会将某些操作数考虑在内，比如三目运算符的第一个操作数，这会在最后进行说明，我们只考虑一般情况）。

类型的等级是根据其能表示的最大正数而确定的，如下表所示。

等级(1代表最高)	类型
1	long double
2	double
3	float
4	unsigned long long
5	long long
6	unsigned long
7	long
8	unsigned int
9	int

表中不包含char类型和short类型（包括 signed 和 unsigned），因为他们会因为整型提升而在一开始就进行一次类型转换。

例4给出了一个常见类型转换的例子。

// 例4
#include <stdio.h>
#include <limits.h>
#define TYPEOF(x) _Generic((typeof(x)){0}, \
    char: "char", \
    unsigned char: "unsigned char", \
    short: "short", \
    unsigned short: "unsigned short", \
    int: "int", \
    unsigned int: "unsigned int", \
    long: "long", \
    unsigned long: "unsigned long", \
    long long: "long long", \
    unsigned long long: "unsigned long long", \
    float: "float", \
    double: "double", \
    long double: "long double", \
    default: "unknown")


int b=INT_MAX;
int c=1;
long d=1;

int main()
{
	printf("%d , type is %s \n", (b + c) , TYPEOF(b + c));
	printf("%lld , type is %s \n", (b + c) * d, TYPEOF((b + c) * d));
    return 0;
}

输出：
-2147483648 , type is int 
-2147483648 , type is long

由于此时b的值是int类型能表达的最大值，所以表达式b+c的结果还是一个int类型，且会溢出，产生一个大负数，如第一个printf显示的那样。即使表达式b+c的结果再与一个long类型的操作数进行运算，也无济于事，如我们早就说过的，类型转换是在表达式的范围进行的，此时表达式b+c的结果会类型提升为long类型。

5、一些类型转换的例外

上面的例子似乎说明了，类型转换就是：首先进行整型提升，最后自底向上进行常见类型转换，统一每次运算的所有操作数的类型。

但这是错误的，并不是所有操作数之间的常见类型转换都会发生，例如对于三目运算符的第一个操作数，三目运算符的第二个和第三个操作数会因为常见类型类型转换而统一类型，但这与第一个操作数无关（如果第一个操作数本身是一个子表达式，该子表达式的计算过程会进行类型转换，但子表达式的结果不会影响第二个和第三个操作数的类型），例5给出了这种情况的例子。

// 例5
#include <stdio.h>
#include <limits.h>
#define TYPEOF(x) _Generic((typeof(x)){0}, \
    char: "char", \
    unsigned char: "unsigned char", \
    short: "short", \
    unsigned short: "unsigned short", \
    int: "int", \
    unsigned int: "unsigned int", \
    long: "long", \
    unsigned long: "unsigned long", \
    long long: "long long", \
    unsigned long long: "unsigned long long", \
    float: "float", \
    double: "double", \
    long double: "long double", \
    default: "unknown")


unsigned char b=1;
unsigned char c=0;
long d=1;
int e=INT_MAX;
long f=1;

int main()
{
	printf("%d , type is %s \n", d?b:c , TYPEOF(d?b:c));
	printf("%d , type is %s \n", (e+f>0)?b:c , TYPEOF((e+f>0)?b:c)); // 因为e和f之间发生类型转换，所以并未溢出
    return 0;
}

输出：
1 , type is int 
1 , type is int

与此类似的还有逗号表达式，其值是最后一个操作数的值，各个操作数之间不会发生常见类型转换，如例6所示。

// 例6
#include <stdio.h>
#include <limits.h>
#define TYPEOF(x) _Generic((typeof(x)){0}, \
    char: "char", \
    unsigned char: "unsigned char", \
    short: "short", \
    unsigned short: "unsigned short", \
    int: "int", \
    unsigned int: "unsigned int", \
    long: "long", \
    unsigned long: "unsigned long", \
    long long: "long long", \
    unsigned long long: "unsigned long long", \
    float: "float", \
    double: "double", \
    long double: "long double", \
    default: "unknown")


long d=0;
int e=INT_MAX;
int a;
int main()
{
	a=(d, e, e+1); // 子表达式e+1并不会因为d发生类型提升
	printf("%d , type is %s \n", a , TYPEOF(a));
    return 0;
}

输出：
-2147483648 , type is int