C语言学习笔记---操作符详解
C语言程序设计笔记---012
- C语言操作符
-
- 1、算数操作符
-
- 1.1、算术操作符例程
- 2、移位操作符
-
- 2.1、移位操作符例程1
- 2.2、移位操作符例程2
- 2.3、移位操作符例程3
- 3、位操作符
-
- 3.1、位操作符例程1
- 3.2、位操作符例程2
- 3.3、位操作符例程3 --按位与&1扩展
- 3.4、位操作符例程4 --按位异或^扩展
- 4、赋值操作符
-
- 4.1、赋值操作符例程1
- 5、复合赋值操作符
-
- 5.1、复合赋值操作符例程1
- 6、单目操作符
-
- 6.1、! 单目操作符例程1
- 6.2、 - (逻辑负号) + (逻辑正号)单目操作符例程2
- 6.3、sizeof单目操作符例程3
- 6.4、单目操作符例程4 --- sizeof易错点
- 6.5、~ 单目操作符例程5
- 6.6、++ --单目操作符例程6
- 6.7、& 和 * 单目操作符例程7
- 6.8、( ) 单目操作符例程8
- 6.9、~（取反）单目操作符例程9 --- 扩展
- 7、关系操作符
-
- 7.1、关系操作符例程1
- 8、逻辑操作符
-
- 8.1、逻辑操作符例程1
- 8.2、逻辑操作符例程2
- 9、条件（三目）操作符
-
- 9.1、条件操作符例程1
- 10、逗号表达式
-
- 10.1、逗号表达式例程1
- 11、下标引用操作符
-
- 11.1、下标引用操作符例程1
- 12、函数调用操作符
-
- 12.1、函数调用操作符例程1
- 13、结构成员访问操作符
-
- 13.1、结构成员访问操作符例程1
- 14、表达式求值
-
- 14.1、操作符优先级例程1
- 15、隐式类型转换
-
- 15.1、隐式类型转换（整型提升）例程1
- 15.2、隐式类型转换（整型提升）例程2
- 15.3、隐式类型转换（整型提升）例程3
- 16、算术转换
-
- 16.1、算术转换例程1
- 17、操作符的属性
-
- 17.1、操作符的属性例程1
- 18、问题表达式
-
- 18.1、问题表达式例程1
- 18.2、问题表达式例程2
- 18.3、问题表达式例程3
- 19、结语
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 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 小结：
补码有两种方式得到原码：
(1).补码减一取反
(2).补码取反加1
3.3、位操作符例程3 --按位与&1扩展
说明：与上一个1（&1），可得到当前二进制序列的最低是否为1/0.
#include 3.4、位操作符例程4 --按位异或^扩展
说明：
异或本身等于0 —> a^a = 0
异或0等于本身 —> 0^a = a
说明：不能创建临时变量(第三个变量)，实现两个数的交换
写法一：局限于数据太大就超出了类型的最大范围，但效率高
#include 写法二：
/*例程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 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、结语
半亩方糖一鉴开，天光云影共徘徊。
问渠哪得清如许?为有源头活水来。–朱熹（观书有感）