C语言操作符

/知识点汇总/

(1)概念：操作符就是说明特定操作的符号，它是构造C语言表达式的工具
(2)常见的三大类：算术运算符、关系运算符与逻辑运算符之外，还有一些用于完成特殊任务的运算符，比如位运算符等。
(3)具体操作符分类：

a、算术操作符
b、移位操作符
c、位操作符
d、赋值操作符
e、单目操作符
f、关系操作符
g、逻辑操作符
i、条件操作符
j、逗号表达式
k、下标引用、函数调用和结构体成员操作符

1、算数操作符

算术操作符：+，-，*，/，%
注意：
a、% 操作符不能用于浮点数，只能作用于整数，如果作用于浮点数将会报错。
b、当/ 两边的操作都是整数，执行的就是整数除法
c、 当/ 两边的操作数有一个数为浮点数的话，执行的是浮点数除法

1.1、算术操作符例程

/*例程1.1*/
#include <stdio.h>
int main()
{
	int a = 6 / 5;//0.6
	printf("%d\n",a);//1

	int e = 6.0 / 5.0;
	printf("%d\n",e);//1

	float b = 6 / 5;
	printf("%f\n",b);//1.000000

	float c = 6.0 / 5.0;
	printf("%f\n",c);//1.200000

	float d = 6.0 / 5;
	printf("%f\n", d);//1.200000

	int f = 6 % 5;
	printf("%d\n",f);//1
	//%操作符的两个操作数必须为整数
	return 0;
}

2、移位操作符

移位操作符：
<< 左移操作符
>> 右移操作符
左移操作符规则：左边抛弃，右边补0
右移操作符分类：
(1).算术右移
(2).逻辑右移
右移操作符规则：
a、右移正整数
(1).算术右移：右边丢弃，左边补原符号位
(2).逻辑右移：右移丢弃，左边补0
b、右移负整数
负数，存放在内存中，存放的是二进制的补码
原码：直接根据数值写出的二进制序列就是原码
反码：原码的符号位不变，其他位按位取反就是反码
补码：反码右边加1，就是补码
注意：
(1)、被移动的数不可为负数,且被移动的数必须为整数。与%操作符一样只能操作整型数据。
(2)、对于整型数据，我们平时存储在内存中的是补码二进制序列
(3)、绝大数编译器都采用的算术右移方式计算

原码、反码、补码示例：

10
原码：0000 0000 0000 0000 0000 0000 0000 1010
反码：0000 0000 0000 0000 0000 0000 0000 1010
补码：0000 0000 0000 0000 0000 0000 0000 1010

-10
原码：1000 0000 0000 0000 0000 0000 0000 1010 
反码：1111 1111 1111 1111 1111 1111 1111 0101 
补码：1111 1111 1111 1111 1111 1111 1111 0110 

2.1、移位操作符例程1

/*例程2.1*/
#include <stdio.h>
int main()
{
	int a = 2;
	//把a的二进制向左移动一位
	int b = a << 1;
	//左移N位，就增大2的N次方倍
	printf("b = %d\n",b);//4

	int c = 10;
	//把c的二进制位向右移动1位
	int d = c >> 1;
	//右移N位，就增大2的N次方倍
	printf("d = %d\n",d);//5
	return 0;
}

2.2、移位操作符例程2

/*例程2.2*/
#include <stdio.h>
int main()
{
	int a = -1;
	//-1原码：1000 0000 0000 0001
	//-1反码：1111 1111 1111 1110
	//-1补码：1111 1111 1111 1111
	//负数，存放在内存中，开头的1表示负数
	//正数，以二进制存放
	//原码、反码、补码
	//把a的二进制向右移动一位
	int b = a >> 1;
	//根据输出为-1，可知当前右移操作符默认为，算数右移
	//逻辑右移为1777
	printf("b = %d\n", b);//-1
	return 0;
}

2.3、移位操作符例程3

值得注意的是：以%d打印与以%u打印等格式对结果的影响。
当以%d打印时，输出有符号的十进制的整数格式；
当以%u打印时，输出无符号的整型数据格式。

#include <stdio.h>
int main()
{
	int m = 7;
	//0000 0000 0000 0000 0000 0000 0000 0111
	int n = m << 1;//左移操作符运算规则：左边丢弃，右边补0
	//0000 0000 0000 0000 0000 0000 0000 0111 --- 7
	//0000 0000 0000 0000 0000 0000 0000 1110 --- 14
	printf("%d\n",m);//7
	printf("%d\n",n);//14

	int a = -7;
	//1000 0000 0000 0000 0000 0000 0000 0111 ---  -7
	//1111 1111 1111 1111 1111 1111 1111 1000 --- 反码
	//1111 1111 1111 1111 1111 1111 1111 1001 --- 补码，整数均已补码进行存储
	int b = a << 1;
	//1111 1111 1111 1111 1111 1111 1111 1001 --- 补码
	//1111 1111 1111 1111 1111 1111 1111 0010 --- 补码<< 1  
	//又因为打印格式为%d,是以原码的二进制形式打印，所以补码减1取反，得到打印出来的原码
	//1111 1111 1111 1111 1111 1111 1111 0010 --- 补码<< 1 
	//1111 1111 1111 1111 1111 1111 1111 0001 --- 补码<< 1 减一
	//1000 0000 0000 0000 0000 0000 0000 1110 --- 补码<< 1 取反  ---  -14
	printf("%d\n", a);//-7
	printf("%d\n", b);//-14

	return 0;
}

3、位操作符

位操作符：
按位与 &
按位或 |
异或 ^
注意：
操作数必须为整数，且操作的是二进制序列
补充;
异或操作扩展：
a^b异或b = a
a^a = 0

3.1、位操作符例程1

/*例程3.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	//&---按(二级制)位与
	//规则：有0为0，全1为1
	int c = a & b;
	//3：0000 0000 0000 0000 0000 0000 0000 0011
	//5：0000 0000 0000 0000 0000 0000 0000 0101
	//C: 0000 0000 0000 0000 0000 0000 0000 0001----1
	printf("%d\n",c);//1

	//|---按(二级制)位或
	//规则：有1为1，全0为0
	int d = a | b;
	//3：0000 0000 0000 0000 0000 0000 0000 0011
	//5：0000 0000 0000 0000 0000 0000 0000 0101
	//C: 0000 0000 0000 0000 0000 0000 0000 0111----7
	printf("%d\n", d);//7

	//^---按(二级制)位异或
	//规则：相同为0，相异为1
	int e = a ^ b;
	//3：0000 0000 0000 0000 0000 0000 0000 0011
	//5：0000 0000 0000 0000 0000 0000 0000 0101
	//C: 0000 0000 0000 0000 0000 0000 0000 0110----6
	printf("%d\n", e);//6
	return 0;
}

3.2、位操作符例程2

#include <stdio.h>
int main()
{
	int a = 3;
	int b = -5;
	int c = a | b;//按(二进制)位或
	//0000 0000 0000 0000 0000 0000 0000 0011 --- 3的原码、反码、补码相同
	//1000 0000 0000 0000 0000 0000 0000 0101 --- -5的原码
	//1111 1111 1111 1111 1111 1111 1111 1010 --- -5的反码
	//1111 1111 1111 1111 1111 1111 1111 1011 --- -5的补码
	//| 按位或运算规则：有1为1，全0为0
	//0000 0000 0000 0000 0000 0000 0000 0011 --- 3的补码
	//1111 1111 1111 1111 1111 1111 1111 1011 --- -5的补码
	//1111 1111 1111 1111 1111 1111 1111 1011 --- 得到或之后的二进制序列，将它转换回原码打印出来，减1取反即可
	//1111 1111 1111 1111 1111 1111 1111 1010 --- 减1之后得到的二进制序列，继续取反
	//1000 0000 0000 0000 0000 0000 0000 1010 --- -5
	//符号位1，正数则原码。反码。补码相同
	printf("%d\n", c);//-5
	return 0;
}

小结：
补码有两种方式得到原码：
(1).补码减一取反
(2).补码取反加1

3.3、位操作符例程3 --按位与&1扩展

说明：与上一个1（&1），可得到当前二进制序列的最低是否为1/0.

#include <stdio.h>
int main()
{
	int a = 3;
	//a&1 --- 理解为提取最低为是否为1
	//0000 0000 0000 0000 0000 0000 0000 0011 --- 3
	//0000 0000 0000 0000 0000 0000 0000 0001 --- 1
	//a&1
	//0000 0000 0000 0000 0000 0000 0000 0001 --- 1得到最低位为1 
	return 0;
}

3.4、位操作符例程4 --按位异或^扩展

说明：
异或本身等于0 —> a^a = 0
异或0等于本身 —> 0^a = a
说明：不能创建临时变量(第三个变量)，实现两个数的交换
写法一：局限于数据太大就超出了类型的最大范围，但效率高

#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	printf("交换前：a = %d,b = %d\n", a, b);
	a = a + b;
	b = a - b;
	a = a - b;
	printf("交换后：a = %d,b = %d\n", a, b);
	return 0;
}

写法二：

/*例程3.4*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	//3：0000 0000 0000 0000 0000 0000 0000 0011
	//5：0000 0000 0000 0000 0000 0000 0000 0101
	printf("a = %d b = %d\n", a, b);
	//交换
	//3：0000 0000 0000 0000 0000 0000 0000 0011
	//5：0000 0000 0000 0000 0000 0000 0000 0101
	a = a ^ b;//3^5
	//a: 0000 0000 0000 0000 0000 0000 0000 0110--6
	b = a ^ b;//6^5
	//b: 0000 0000 0000 0000 0000 0000 0000 0011--3
	a = a ^ b;//6^3
	//a: 0000 0000 0000 0000 0000 0000 0000 0101--5
	printf("a = %d b = %d\n", a, b);
	return 0;
}

4、赋值操作符

赋值操作符：=
注意：区分 赋值= 与 判断 ==
一个赋值，一个判断

4.1、赋值操作符例程1

/*例程4.1*/
#include <stdio.h>
int main()
{
	//初始化赋值
	int weight = 120;
	int high = 175;
	float price = 666.66;
	//连续赋值
	int a = 10;
	int b = 0;
	int c = 20;

	a = b = c + 1;
	//等价写法
	b = c + 1;
	a = b;

	int x, y;
	int m = x + y;
	return 0;
}

5、复合赋值操作符

赋值操作符：“+= -= *= /= %= >>= <<= &= |= ^=”

5.1、复合赋值操作符例程1

/*例程5.1*/
#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	a = a + b;
	//等价于
	a += b;

	a = a << b;
	//等价
	a <<= b;
	//均同理
	return 0;
}

6、单目操作符

//! 逻辑取反
//- 负号
//+ 正号
//& 取地址符
//sizeof 求操作数的类型长度(单位字节)
//~ 按位取反
//-- 前置/后置减减
//++ 前置/后置加加
//* 间接访问操作符(解引用操作符)
//(数据类型) 强制类型转换

注意：单目运算符对应只有一个操作数

6.1、! 单目操作符例程1

/*例程6.1*/
#include <stdio.h>
int main()
{
	int flag = 0;
	printf("%d\n",!flag);
	//flag为假打印hehe
	if (flag)
	{
		printf("hehe\n");
	}
	//flag为假打印哈哈
	if (!flag)//！取反
	{
		printf("haha\n");
	}
	return 0;
}

6.2、 - (逻辑负号) + (逻辑正号)单目操作符例程2

/*例程6.2*/
#include <stdio.h>
int main()
{
	int a = 10;
	a = -a;//-逻辑负号
	printf("%d\n", a);//-10
	a = -a;
	printf("%d\n",a);//10
	a = a - (-a);
	printf("%d\n", a);//20
	return 0;
}

6.3、sizeof单目操作符例程3

sizeof是操作符，不是函数，C语言唯一的单词形式的单目操作符
注意：
(1)、sizeof的结果是size_t类型的，是无符号整型；所以sizeof的数据打印时，应该用%zd或%u
(2)、sizeof后面的括号写的不是类型时，括号可以省略，这样同样证明sizeof不是函数，因为函数的括号不可省

/*例程6.3*/
#include <stdio.h>
int main()
{
	int a = 10;
	printf("%d\n", sizeof(a));//4
	printf("%d\n", sizeof(int));//4

	printf("%zd\n", sizeof(a));//4
	printf("%zd\n", sizeof(int));//4

	printf("%u\n", sizeof(a));//4
	printf("%u\n", sizeof(int));//4

	//而且因为sizeof是操作符，所以计算变量的数据类型大小时，可不用加括号
	printf("%d\n", sizeof a );//4

	int arr[10] = { 0 };
	printf("%zd\n",sizeof(arr));//40 --- 10个整型的大小 4*10 = 40
	//说明sizeof可计算类型创建的变量或变量的大小，单位是字节
	printf("%zd",sizeof(arr)/sizeof(arr[0]));//数组的元素个数
	//数组的元素个数等于，总的数组大小除以一个元素的大小
	return 0;
}

6.4、单目操作符例程4 — sizeof易错点

sizeof()易错例程

/*例程6.4*/
#include <stdio.h>
int main()
{
	short s = 5;
	int a = 10;
	printf("%d\n",sizeof(s = a + 2));
	//2,大的放不进小的，数据截断，仍为short类型，且a+2不会运算
	//且sizeof(参数)，参数的计算不对参数外起作用
	printf("%d\n",s);//5
	return 0; 
}

6.5、~ 单目操作符例程5

~取反例程

/*例程6.5*/
#include <stdio.h>
int main()
{
	int a = -1;
	//1000 0000 0000 0000 0000 0000 0000 0001---原码--开头的1表示负号，0正号
	//1111 1111 1111 1111 1111 1111 1111 1110---反码
	//1111 1111 1111 1111 1111 1111 1111 1111---补码
	//~取反
	//1111 1111 1111 1111 1111 1111 1111 1111---负数的原码等于补码-1
	//1000 0000 0000 0000 0000 0000 0000 0000---取反--0
	int b = ~a;
	printf("%d\n",b);//0
	return 0;
}

小结：-1的补码就是全1

6.6、++ --单目操作符例程6

// ++ ：自增1操作
// – ： 自减1操作
//前置加加 ++a：先用后加
//后置加加 a++：先加后用
//前置减减 --a：先用后减
//后置减减 a–：先减后用

/*例程6.6*/
#include <stdio.h>
int main()
{
	int a = 10;
	int b = a++;//++后置，先用a后加++
	printf("%d\n",a);//11
	printf("%d\n", b);//10
	a = 10;
	int c = ++a;//++前置，先加++后用a
	printf("%d\n", a);//11
	printf("%d\n", c);//11
	a = 10;
	int d = a--;//++后置，先用a后加++
	printf("%d\n", a);//9
	printf("%d\n", d);//10
	a = 10;
	int e = --a;//++前置，先加++后用a
	printf("%d\n", a);//9
	printf("%d\n", e);//9
	a = 10;
	printf("%d\n",a++);//10
	printf("%d\n",a);//11
	a = 10;
	printf("%d\n", a--);//10
	printf("%d\n", a);//9
	return 0;
}

6.7、& 和 * 单目操作符例程7

&取地址，*解引用例程

/*例程6.7*/
#include <stdio.h>
int main()
{
	int a = 10;
	printf("%p\n",&a);//&--取地址
	//%p打印地址的格式符
	int* pa = &a;//pa是用来存放地址的，是指针变量
	*pa = 20;//*解引用操作符 -- 间接访问操作符
	printf("%d\n", a);
	return 0;
}

6.8、( ) 单目操作符例程8

( )强制类型转换
注意：（）括起来的是数据类型

/*例程6.8*/
#include <stdio.h>
int main()
{
	float a = 10.5;
	printf("%f\n", a);//10.500000
	int b = (int)a;//强制类型转换
	printf("%d\n",b);//10
	return 0;
}

/*例程6.8.1*/
#include <stdio.h>
void test1(int arr[])//int* arr数组首元素的地址
{
	printf("%d\n",sizeof(arr));//4
}
void test2(char ch[])//char* ch数组首元素的地址
{
	printf("%d\n", sizeof(ch));//4
}
int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%d\n",sizeof(arr));//40
	printf("%d\n", sizeof(ch));//10
	test1(arr);
	test2(ch);
	return 0;
}

6.9、~（取反）单目操作符例程9 — 扩展

#include <stdio.h>
int main()
{
	int a = 10;
	//0000 0000 0000 0000 0000 0000 000 0 1010 ---- 10 
	//实现将第低5位的0改为1，其余位不变。
	//观察思考：只需要或上一个需要改变的那位数为1，其余位为0。即或上：1 << 4
	//0000 0000 0000 0000 0000 0000 0000 0001 ---- 1
	//即：0000 0000 0000 0000 0000 0000 0001 0000 --- 即：1 << 4
	//将 10或(1<<4) 运算得：
	//0000 0000 0000 0000 0000 0000 0000 1010 ---- 10 
	//0000 0000 0000 0000 0000 0000 0001 0000 --- 即：1 << 4
	//0000 0000 0000 0000 0000 0000 0001 1010 ---- 26 
	a |= (1 << 4);
	//a = a | (1 << 4);
	printf("%d\n", a);//26

	//同样：我们将26返回10
	//0000 0000 0000 0000 0000 0000 0001 1010 ---- 26 
	//观察思考：只需要将第低5位的数，1变为0 即可
	//与上一个需要改变的那位数为0，其余位1为。即取反右移4位：~(1<<4)
	//0000 0000 0000 0000 0000 0000 0000 0001 ---- 1
	//1111 1111 1111 1111 1111 1111 1110 1111 ---- ~(1<<4)
	//最后进行与与运算
	//0000 0000 0000 0000 0000 0000 0001 1010 ---- 26 
	//1111 1111 1111 1111 1111 1111 1110 1111 ---- ~(1<<4)
	//0000 0000 0000 0000 0000 0000 0000 1010 ---- 10
	a &= ~(1 << 4);
	printf("%d\n", a);//10
	return 0;
}

7、关系操作符

关系操作符：> < >= <= != ==
注意：区分 赋值 = 与 判断 ==
一个赋值，一个判断
比较两个字符串时，不能用== 来判断
用strcmp函数，它的形式是:strcmp(str1, str2) == 0(成立则两个字符串相等)

7.1、关系操作符例程1

/*例程7.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	if (a == b)
	{
		printf("hehe\n");
	}
	if (a != b)
	{
		printf("hehe\n");
	}
	if (a < b)
	{
		printf("hehe\n");
	}
	return 0;
}

8、逻辑操作符

逻辑操作符：&& ||
注意：逻辑只看真假

8.1、逻辑操作符例程1

/*例程8.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 0;
	if (a && b)//逻辑与，条件均满足成立
	{
		printf("hehe");
	}
	if (a || b)//逻辑或，条件满足一个则成立
	{
		printf("haha");
	}
	return 0;
}

8.2、逻辑操作符例程2

/*例程8.2*/
#include <stdio.h>
int main()
{
	//int i = 0, a = 0, b = 2, c = 3, d = 4;
	//i = a++ && ++b && d++;
	//printf("i = %d\n",i);//0
	//printf("a = %d\nb = %d\nc = %d\nd = %d\n",a,b,c,d);//1,2,3,4
	
	//int i = 0, a = 1, b = 2, c = 3, d = 4;
	//i = a++ && ++b && d++;
	//printf("i = %d\n", i);//1
	//printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);//2,3,3,5

	//int i = 0, a = 0, b = 2, c = 3, d = 4;
	//i = a++ || ++b || d++;//从前往后，满足条件后，后面未使用的条件就默认不执行了
	//printf("i = %d\n", i);//1
	//printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);//1,3,3,4

	int i = 0, a = 1, b = 2, c = 3, d = 4;
	i = a++ || ++b || d++;//从前往后，满足条件后，后面未使用的条件就默认不执行了
	printf("i = %d\n", i);//1
	printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);//2,2,3,4
	return 0;
}

小结：
(1)、&& — 左边操作数如果为假，则右边就无需计算了
(2)、|| — 左边操作数如果为真，则右边无需计算了

9、条件（三目）操作符

三目操作符：exp1 ? exp2 : exp3
规则：前真后假

9.1、条件操作符例程1

/*例程9.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 0;
	//写法一：
	//if (a > 5)
	//{
	//	b = 1;
	//}
	//else
	//{
	//	b = -1;
	//}
	//写法二：
	b = a > 5 ? 1 : -1;
	//a>5表达式1
	//1表达式2
	//-1表达式3
	return 0;
}

10、逗号表达式

注意：，从左向右依次计算，但注意，输出结果时最后一个表达式结果

10.1、逗号表达式例程1

/*例程10.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	int c = 0;
	
	//逗号表达式加括号
	//int d = (c = 5,a =c + 3,b = a - 4,c+= b);
	//printf("%d\n",d);//10
	//逗号表达式不加括号,就只会执行第一个表达式结束
	int e = 0;
	e = c = 5, a = c + 3, b = a - 4, c += b;
	printf("%d\n", e);//5
	return 0;
}

11、下标引用操作符

下标引用操作符：[ ]
操作数：一个数组名 + 一个索引值（下标）
注意：下标从0开始

11.1、下标引用操作符例程1

/*例程11.1*/
#include <stdio.h>
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	printf("%d\n",arr[0]);//0
	printf("%d\n", arr[1]);//1
	printf("%d\n", arr[6]);//6
	return 0;
}

12、函数调用操作符

函数调用操作符：（ ）
操作数：函数名+（ ）
注意：接收一个或多个操作数时，第一个操作数是函数名，剩余操作数是传递的函数参数

12.1、函数调用操作符例程1

/*例程12.1*/
#include <stdio.h>
int add(int x, int y)
{
	return x + y;
}
int main()
{
	int a = 10;
	int b = 20;
	int ret = add(a,b);
	printf("%d\n",ret);//30
	return 0;
}

13、结构成员访问操作符

结构体概念：结构体 – 相关成员变量，不同类型描述对象
比如描述书：书名、书的编号、价格、作者等
struct关键字，创建一个新的结构体类型

结构成员访问操作符： . （点操作符） ->（箭头操作符）
区别：
. 结构体变量.成员名
-> 结构体指针->成员名
操作对象一个是变量，一个是指针。

13.1、结构成员访问操作符例程1

/*例程13.1*/
#include <stdio.h>
struct Book
{
	//结构体成员/变量
	char name[20];
	char ID[20];
	int price;
};//注意：分号不可少
int main()
{
	//int num = 0;
	b结构体变量名
	结构体成员初始化
	//struct Book b = {"C语言","CBS123456",55};
	//printf("书名：%s\n",b.name);//.操作符
	//printf("ID：%s\n", b.ID);//结构体变量名.成员名
	//printf("价格：%d\n", b.price);

	int num = 0;
	//b结构体变量名
	//结构体成员初始化
	struct Book b = { "C语言", "CBS123456", 55 };
	struct Book* pb = &b;
	//printf("价格：%s\n", (*pb).name);
	//printf("价格：%s\n", (*pb).ID);
	//printf("价格：%d\n", (*pb).price);

	printf("价格：%s\n", pb->name);//->操作符
	printf("价格：%s\n", pb->ID);//结构体指针->成员名
	printf("价格：%d\n", pb->price);
	return 0;
}

14、表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定的；
同样，有些表达式的操作数在求值过程中可能需要转换为其他类型。
注意：表达式求值注意，运算的优先级
操作符优先级如图所示：

14.1、操作符优先级例程1

/*例程14.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	int c = a + b * 7;//*符号优先级较高
	printf("%d\n",c);//38
	return 0;
}

15、隐式类型转换

C的整型算数运算总是至少以缺省整型类型的精度来进行的。
为了获取精度，表达式中的字符和短整型在使用前被转换为普通类型
这种转换就是整型提升
整型提升的意义：
表达式的整型运算要在CPU的相应运算器内执行，CPU内整型运算器(ALU)的操作数的字节长度，一般就是int的字节长度，同时也是CPU的通用寄存器长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要转换为CPU内整型操作数的标准长度。
通用CPU是难以直接实现两个8比特字节直接相加运算(虽然机器指令中可能有这种字节相加指令)。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。
如何整型提升？
是按照变量的数据类型的符号位来提升的

隐式类型转换分类：
(1).整型提升
(2).算术转换

15.1、隐式类型转换（整型提升）例程1

/*例程15.1*/
#include <stdio.h>
int main()
{
	char a = 3;
	//0000 0000 0000 0000 0000 0000 0000 0011---3
	//char：0000 0011---a 数据截断
	char b = 127;
	//0000 0000 0000 0000 0000 0000 0111 1111---127
	//char：0111 1111---b 数据截断
	char c = a + b;
	//整型提升：
	//0000 0000 0000 0000 0000 0000 0000 0011---3---a最高位是0，那么表示正数，然后高位全补0
	//0000 0000 0000 0000 0000 0000 0111 1111---127-b最高位是0，那么表示正数，然后高位全补0
	//0000 0000 0000 0000 0000 0000 1000 0010
	//char截断：1000 0010--c
	//分析：c最高位为1，表示负数，提升后补1
	//发现a和b均是char类型，都没有达到一个int的大小
	//这里就会发生整型提升
	//char截断：1000 0010--c(-126)
	//1111 1111 1111 1111 1111 1111 1000 0010--补码
	//1111 1111 1111 1111 1111 1111 1000 0001--反码
	//1000 0000 0000 0000 0000 0000 0111 1110--原码，以%d格式打印
	printf("%d\n",c);//-126
	return 0;
}

15.2、隐式类型转换（整型提升）例程2

/*例程15.2*/
#include <stdio.h>
int main()
{
	char a = 0xb6;
	short b = 0xb600;
	int c = 0xb6000000;
	//a和b，char和short会整型提升，所以提升后会改变
	//c本身就是int型，所以不变
	if (a == 0xb6)
	{
		printf("a\n");
	}
	if (b == 0xb600)
	{
		printf("b\n");
	}
	if (c == 0xb6000000)
	{
		printf("c\n");//c
	}
	return 0;
}

15.3、隐式类型转换（整型提升）例程3

说明：证明的确存在整型提升

/*例程15.3*/
#include <stdio.h>
int main()
{
	char c = 1;
	printf("%u\n",sizeof(c));//1
	printf("%u\n",sizeof(+c));//4
	printf("%u\n",sizeof(-c));//4
	printf("%u\n",sizeof(!c));//4 gcc编译为-4 
	return 0;
}

16、算术转换

如果某个操作符的各个操作符属于不同的类型，那么除非其中一个操作数的转换为另外一个操作数的类型，否则操作就无法进行。
下面的层次体系称为寻常算术转换
数据类型列表：

//long double
//double
//float
//unsigned long int
//long int
//unsigned int
//int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算，
注意：
(1)、算术转换要合理，不然会有潜在问题报错。
(2)、同类型条件下，大于等于int类型时，就属于算术转换了，小的向大的转换
(3)、不同类型之间如float浮点数类型与int整形运算，则int向下隐式类型转换为float,再进行算术运算。
补充：
a、隐式类型转换：小类型向大类型转换
b、强制类型转换：大类型向小类型（理论上都可以强制转换，但是因为语法上：大的转成小的有可能导致精度丢失或者溢出）

16.1、算术转换例程1

说明：当进行算数运算时，类型不同则进行隐式类型转换

/*例程16.1*/
#include <stdio.h>
int main()
{
	int a = 4;
	float f = 4.5f;//f表示为float类型的常量，没有f默认为double类型
	a + f;//int向下转换为float，再相加
	return 0;
}

17、操作符的属性

复杂表达式的求值有三个影响的因素
1.操作符优先级
2.操作符的结合性
3.是否控制求值顺序

17.1、操作符的属性例程1

/*例程17.1*/
#include <stdio.h>
int main()
{
	int a = 4;
	int b = 5;
	int c = a + b * c;//优先级决定运算顺序
	int d = a + b + c;//当优先级相同那么结合性决定运算顺序
	return 0;
}

小结：
两个相邻的操作符先执行哪个？取决于他们的优先级。如果二者优先级相同，那么取决于他们的结合性，最后是顺序

18、问题表达式

编写代码的规范性问题，编译器问题以及逻辑问题的注意与约束
说明：如果我们写代码表达式不能通过操作符的属性确定唯一的计算路径，那么这个表达式就是存在问题的

18.1、问题表达式例程1

/*例程18.1*/
#include <stdio.h>
int main()
{
	int a, b, c, d, e, f;
	a*b + c*d + e*f;
	//这样写会影响运算步骤，不能确定唯一的执行顺序
	c + --c;//这种问题表达式，也不能确定顺序
	return 0;
}

18.2、问题表达式例程2

/*例程18.2*/
#include <stdio.h>
int main()
{
	int i = 10;
	i = i-- - --i * (i = -3)*i++ + ++i;
	printf("%d\n",i);//各编译器执行结果均不同
	//这样写会影响运算步骤，不能确定唯一的执行顺序
	//不提倡，无意义的代码
	return 0;
}

18.3、问题表达式例程3

/*例程18.3*/
#include <stdio.h>
int fun()
{
	static int count = 1;
	return ++count;
}
int main()
{
	int answer;
	//调用紊乱
	answer = fun() - fun() * fun();
	printf("%d\n", answer);//2-3*4
	//各编译器执行结果均不同
	//这样写会影响运算步骤，不能确定唯一的执行顺序
	//不提倡，无意义的代码
	return 0;
}

19、结语

半亩方糖一鉴开，天光云影共徘徊。
问渠哪得清如许?为有源头活水来。–朱熹（观书有感）