1. 各种操作符的介绍。2. 表达式求值
目录
1. 操作符分类：
算术操作符移位操作符位操作符赋值操作符单目操作符关系操作符逻辑操作符条件操作符逗号表达式下标引用、函数调用和结构成员
2. 算术操作符
+ - * / %
1.
除了
%
操作符之外，其他的几个操作符可以作用于整数和浮点数。
2.
对于
/
操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
3.
%
操作符的两个操作数必须为整数。返回的是整除之后的余数。
#include<stdio.h>
int main()
{
//int a = 3 / 5;//0 -- 整数除法
//float a = 6 / 5;//1.000000 6/5=1 1存入浮点型数据当中
/*printf("%d\n", a);*/
float a = 6 / 5.0;//1.200000
printf("%f\n", a);
return 0;
}3. 移位操作符
<< 左移操作符>> 右移操作符注：移位操作符的操作数只能是整数。
3.1 左移操作符
移位规则：左边抛弃、右边补 0
3.2 右移操作符
移位规则：
首先右移运算分两种：
1. 逻辑移位 （逻辑右移）左边用 0 填充，右边丢弃2. 算术移位 （算术右移）左边用原该值的符号位填充，右边丢弃
警告
⚠
：
对于移位运算符，不要移动负数位，这个是标准未定义的。
例如：
int num = 10;
num>>-1;//error
符号位 0为正 1为负
#include<stdio.h>
int main()
{
int a = 2; //4*8 =32 比特位 00....010
//把a的二进制位向左
int b = a << 1;
printf("b=%d\n",b);//4
int c = -1;
int d = c >> 1;
//当前的右移操作符使用的：算术右移 左边用原该值的符号位填充，右边丢弃
printf("d=%d\n", d);//-1
//无论该数字是左移还是右移不改变该数值的大小
printf("%d %d", a, c);//2 -1
return 0;
}4. 位操作符
位操作符有：
& // 按位与| // 按位或^ // 按位异或注：他们的操作数必须是整数。
int main()
{
int a = 3;
int b = 5;
int c = a & b;
printf("c=%d\n", c);//1
// & - 按（2进制）位与
//
//00000000 00000000 00000000 00000011
//00000000 00000000 00000000 00000101
//a&b 有0则0 全1才1 0假 1真 同真才真 有一个假则假
//00000000 00000000 00000000 00000001
int d = a | b;
printf("d=%d\n", d);//7
// | - 按（2进制）位或
//00000000 00000000 00000000 00000011
//00000000 00000000 00000000 00000101
//a|b 有1则1 全0才0 0假 1真 同假才假 有一个真则真
//00000000 00000000 00000000 00000111
// ^ - 按（2进制）位异或
//对应的二进制位进行异或
//00000000 00000000 00000000 00000011
//00000000 00000000 00000000 00000101
//规则：相同为0， 不同为1
//00000000 00000000 00000000 00000110
int e = a ^ b;
printf("e=%d\n", e);//6
}
练习一下：
#include <stdio.h>
int main()
{
int num1 = 1;
int num2 = 2;
num1 & num2;
num1 | num2;
num1 ^ num2;
return 0;
}一道变态的面试题：
不能创建临时变量（第三个变量），实现两个数的交换。
常规写法：
#include <stdio.h>
int main()
{
int a = 10;
int b = 20;
a = a^b;
b = a^b;
a = a^b;
printf("a = %d b = %d\n", a, b);
return 0;
}//不能创建临时变量（第三个变量），实现两个数的交换。
int main()
{
int a=3;
int b = 5;
printf("a=%d b=%d\n", a, b);
//交换
// 常规方法 空瓶（临时变量）不符合要求
//
//方法1：缺陷 数值太大相加会溢出
//a = a + b;//3+5
//b = a - b;//3+5-5=3
//a = a - b;//3+5-3
//printf("a=%d b=%d\n", a, b);
//方法2：异或
a = a ^ b;
b = a ^ b;
a = a ^ b;
printf("a=%d b=%d\n", a, b);
//a: 011
//b: 101
//a=a^b: 110
//
//a: 110
//b: 101
//b=a^b: 011
//
//a: 110
//b: 011
//a=a^b: 101
//
//a=101 //5
//b=011 //3
}
a^b^b=a a^a=0 任意相同的两个数异或为0，相同为0 ，0与任何数异或为任何数 0^a=a 相同为0，不同为1
练习：
编写代码实现：求一个整数存储在内存中的二进制中
1
的个数。
int main()
{
int a = 13;
//1101
//00000000 00000000 00000000 00001101 向右移动1 2 3 4....31位
//00000000 00000000 00000000 00000001 按位与&1 有0则0 结果是几 二进制最低位就是几
//00000000 00000000 00000000 00000001
//& >>
//
//指定位变成0->1 给该位 或个1，其他位或0，或0不改变其值，原来是什么还是什么； 原来0 或个1 变成1 ，原来1 或个1还是1
//00000000 00000000 00000000 00001101
//00000000 00000000 00000000 00010000 // | 1<<4
//00000000 00000000 00000000 00011101
//
//1<<4
//00000000000000000000000000000000001
return 0;
}
参考代码：
//方法1
#include <stdio.h>
int main()
{
int num = 10;
int count= 0;//计数
while(num)
{
if(num%2 == 1)
count++;
num = num/2;
}
printf("二进制中1的个数 = %d\n", count);
return 0;
}
//思考这样的实现方式有没有问题？
//方法2：
#include <stdio.h>
int main()
{
int num = -1;
int i = 0;
int count = 0;//计数
for(i=0; i<32; i++)
{
if( num & (1 << i) )
count++;
}
printf("二进制中1的个数 = %d\n",count);
return 0;
}
//思考还能不能更加优化，这里必须循环32次的。
//方法3：
#include <stdio.h>
int main()
{
int num = -1;
int i = 0;
int count = 0;//计数
while(num)
{
count++;
num = num&(num-1);
}
printf("二进制中1的个数 = %d\n",count);
return 0;
}
//这种方式是不是很好？达到了优化的效果，但是难以想到。5. 赋值操作符
赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。
int weight = 120 ; // 体重weight = 89 ; // 不满意就赋值double salary = 10000.0 ;salary = 20000.0 ; // 使用赋值操作符赋值。赋值操作符可以连续使用，比如：int a = 10 ;int x = 0 ;int y = 20 ;a = x = y + 1 ; // 连续赋值 从右往左赋值这样的代码感觉怎么样？那同样的语义，你看看：x = y + 1 ;a = x ;这样的写法是不是更加清晰爽朗而且易于调试。
复合赋值符
+=-=*=/=%=>>=<<=&=|=^=
这些运算符都可以写成复合的效果。
比如：
int x = 10 ;x = x + 10 ;x += 10 ; // 复合赋值// 其他运算符一样的道理。这样写更加简洁。
= 赋值 == 判断相等
6. 单目操作符
6.1 单目操作符介绍
单目只有一个操作数
! 逻辑反操作 真假- 负值+ 正值（常省略）& 取地址sizeof 操作数的类型长度（以字节为单位）~ 对一个数的二进制按位取反-- 前置、后置 --++ 前置、后置 ++* 间接访问操作符 ( 解引用操作符 )( 类型 ) 强制类型转换
! 逻辑反操作 真假
int main()
{
int flag = 5;
printf("%d\n", !flag);//0 编译器把0求反 结果为1 真 虽然c中非0即为真
if (flag)
{
printf("hehe\n");
}
//flag为假，打印haha
if (!flag)
{
printf("haha\n");
}
return 0;
}~ 对一个数的二进制按位取反
int main()
{
int a = -1;
//10000000 00000000 00000000 00000001 - 原码
//11111111 11111111 11111111 11111110 - 反码
//11111111 11111111 11111111 11111111 - 补码 负数在内存中按补码存储
//~按二进制位取反
//11111111 11111111 11111111 11111111
//00000000 00000000 00000000 00000000
int b=~a;
printf("%d\n", a);//a不变
printf("%d\n", b);
return 0;
}int main()
{
int a = 13;
//把a的二进制中的第五位置成1
a = a | (1 << 4);
printf("a=%d\n", a);
//把a的二进制中的第五位置成0
a = a & ~(1 << 4);
printf("a=%d\n", a);
//1101
//00000000 00000000 00000000 00001101 向右移动1 2 3 4....31位
//00000000 00000000 00000000 00000001 按位与&1 有0则0 结果是几 二进制最低位就是几
//00000000 00000000 00000000 00000001
//& >>
//
//指定位变成0->1 给该位 或个1，其他位或0，或0不改变其值，原来是什么还是什么； 原来0 或个1 变成1 ，原来1 或个1还是1
//00000000 00000000 00000000 00001101
//00000000 00000000 00000000 00010000 // | 1<<4
//00000000 00000000 00000000 00011101
//
//1<<4
//00000000000000000000000000000000001
//00000000 00000000 00000000 00011101
//00000000 00000000 00000000 00010000 // 1<<4
//11111111 11111111 11111111 11101111 //& ~
//00000000 00000000 00000000 00001101
return 0;
}
演示代码：
#include <stdio.h>
int main()
{
int a = -10;
int *p = NULL;
printf("%d\n", !2);
printf("%d\n", !0);
a = -a;
p = &a;
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
printf("%d\n", sizeof a);//这样写行不行？
printf("%d\n", sizeof int);//这样写行不行？
return 0;
}
关于
sizeof
其实我们之前已经见过了，可以求变量（类型）所占空间的大小。
6.2 sizeof 和 数组
#include <stdio.h>
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//(2)4
}
void test2(char ch[])
{
printf("%d\n", sizeof(ch));//(4)4
}
int main()
{
int arr[10] = { 0 };
char ch[10] = { 0 };
printf("%d\n", sizeof(arr));//(1)40
printf("%d\n", sizeof(ch));//(3)10
test1(arr);//4
test2(ch);//4
return 0;
}
问：
（
1
）、（
2
）两个地方分别输出多少？40 4
（3）、（4）两个地方分别输出多少？10 4
数组传参本质上传过去的是数组首元素的地址 -- 本质也就是个指针，大小应该是指针的大小4/8，指针不论类型，大小都是固定的32位就是4字节,64位就是8字节
sizeo括号中放的表达式是不参与运算的
int main()
{
short s = 5;
int a = 10;
/*char arr[10] = { 0 };*/
int arr[10] = { 0 };
printf("%d\n", sizeof(a));//计算a所占空间的大小，单位是字节 //4
printf("%d\n", sizeof(int)); //4
printf("%d\n", sizeof a); //4 证明sizeof是一个操作符，不是函数，如果是函数不能省略（）
printf("%d\n", sizeof(arr)); //10 char占用1 个字节,如果是int 话占用 4个字节 结果是40 sizeof可以计算一个数组的大小
printf("%d\n", sizeof(int [10])); //40 - int[10]是arr数组的类型
printf("%d\n", sizeof(s = a + 3));//2 sizeof计算的是s所占空间的大小，a+3后把值放入s中
printf("%d\n", s);//5 sizeo括号中放的表达式是不参与运算的 sizeof是在编译时计算的s=a+3结果要放入s中，所以sizeof编译计算时只考虑s,但是s=a+3是在运行期间做的事,最后剩了个3没有计算
return 0;
}//++和--运算符
//前置++和--
#include <stdio.h>
int main()
{
int a = 10;
int x = ++a;
//先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。
int y = --a;
//先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;
return 0;
}
//后置++和--
#include <stdio.h>
int main()
{
int a = 10;
int x = a++;
//先对a先使用，再增加，这样x的值是10；之后a变成11；
int y = a--;
//先对a先使用，再自减，这样y的值是11；之后a变成10；
return 0;
}
++和--运算符 不必深究，深究无意义
int main()
{
int a = 10;
int a1 = 10;
int b = a++;//后置++，先使用a，a再++
int c = ++a1;//前置++，先++，再使用
printf("%d\n", a);//11
printf("%d\n", b);//10
printf("%d\n", c);//11
printf("%d\n",a1);//11
return 0;
}int main()
{
int a = 10;
int b = a--;//后置--，先使用a，a再--
printf("%d\n", a);//9
printf("%d\n", b);//10
return 0;
}int main()
{
int a = 10;
int b = --a;//前置--，先使用a，a再--
printf("%d\n", a);//9
printf("%d\n", b);//9
return 0;
}int main()
{
int a = 10;
printf("%d\n", a--);//10 先使用，先打印a的值10 ，再--
printf("%d\n", a);//9
return 0;
}
int main()
{
int a = 1;
int b = (++a) + (++a)+(++a);//无意义
printf("%d\n", a);//4
printf("%d\n", b);//12 其实这个代码是有问题的 看最后代码5实例
return 0;
}& 取地址
int main()
{
int a = 10;
printf("%p\n", &a);//& - 取地址符 &单目取地址，双目按位与
int * pa = &a;//pa是用来存放地址的 - pa就是一个指针变量
*pa=20;//* - 解引用操作符 / 间接访问操作符 *pa等价变量a
printf("%d\n", a);//20
return 0;
}(类型) 强制类型转换
int main()
{
int a = (int)3.14;//强制类型转换（类型）
printf("%d", a);
return 0;
}7. 关系操作符
关系操作符
>>=<<=!= 用于测试 “ 不相等 ”== 用于测试 “ 相等 ”
这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。
警告：
在编程的过程中
==
和
=
不小心写错，导致的错误。
8. 逻辑操作符
逻辑操作符有哪些：
&& 逻辑与 并且 只看真假|| 逻辑或 或者
区分
逻辑与
和
按位与
区分
逻辑或
和
按位或
1 & 2 -----> 0 按二进制位进行与运算1 && 2 ----> 11 | 2 -----> 31 || 2 ----> 1
逻辑与和或的特点：
360笔试题
#include <stdio.h>
int main()
{
int i = 0, a = 0, b = 2, c = 3, d = 4;
//i = a++ && ++b && d++;//1 2 4 当我们发现a为0时，后面b，d已经不重要了,所以就不用算了，短路求值
//i = a++||++b||d++; //1 3 4 当前面数为真时后面就不用再计算了，短路求值
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
return 0;
}
//程序输出的结果是什么？
//a = 1
//b = 2
//c = 3
//d = 49. 条件操作符
exp1 ? exp2 : exp3 也被称为三目操作符
练习：
1.if ( a > 5 )b = 3 ;elseb = - 3 ;转换成条件表达式，是什么样？2. 使用条件表达式实现找两个数中较大值。
int main()
{
int a = 3;
int b = 0;
/*if (a > 5)
b = 3;
else
b = -3;*/
//三目操作符
b = (a > 5 ? 1 : -1);//表达式1结果为真返回表达式2，表达式1结果为假返回表达式3
printf("%d", b);//-1
return 0;
}10. 逗号表达式
exp1, exp2, exp3, …expN
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
int main()
{
int a = 3;
int b = 5;
int c = 0;
//逗号表达式 - 要从左到右依次计算,但是整个表达式的结果是最后一个表达式的结果
int d = (c = 5, a = c + 3, b = a - 4, c += 5);
//c=10 a=8 b=4
printf("%d\n", d);//10
return 0;
}int main()
{
//代码1
int a = 1;
int b = 2;
int c = (a > b, a = b + 10, a, b = a + 1);//逗号表达式
//c是多少？
printf("%d\n", c);//13
return 0;
}//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
c是多少？
//代码2
if (a =b + 1, c=a / 2, d > 0)
//代码3
a = get_val();
count_val(a);
while (a > 0)
{
//业务处理
a = get_val();
count_val(a);
}
如果使用逗号表达式，改写：
while (a = get_val(), count_val(a), a>0)
{
//业务处理
}11. 下标引用、函数调用和结构成员
1. [ ]
下标引用操作符
操作数：一个数组名
+
一个索引值
int arr [ 10 ]; // 创建数组arr [ 9 ] = 10 ; // 实用下标引用操作符。[ ] 的两个操作数是 arr 和 9 。
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("%d", arr[4]);//5 [] - 下标引用操作符
//[] 的操作数是2个 ： arr ， 4
}
2. ( )
函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
#include <stdio.h>
void test1()
{
printf("hehe\n");
}
void test2(const char *str)
{
printf("%s\n", str);
}
int main()
{
test1(); //实用（）作为函数调用操作符。
test2("hello bit.");//实用（）作为函数调用操作符。
return 0;
}//函数定义
int Add(int x,int y)
{
return x + y;
}
void test()
{
}
int main()
{
int a = 10;
int b = 20;
//函数调用
int ret = Add(a, b); //() - 函数调用操作符 操作数Add a b
test();//操作数test
return 0;
}3. 访问一个结构的成员
. 结构体.成员名
-> 结构体指针->成员名
#include <stdio.h>
struct Stu
{
char name[10];
int age;
char sex[5];
double score;
}；
void set_age1(struct Stu stu)
{
stu.age = 18;
}
void set_age2(struct Stu* pStu)
{
pStu->age = 18;//结构成员访问
}
int main()
{
struct Stu stu;
struct Stu* pStu = &stu;//结构成员访问
stu.age = 20;//结构成员访问
set_age1(stu);
pStu->age = 20;//结构成员访问
set_age2(pStu);
return 0;
}//结构成员访问操作符
// .
// ->
//结构体
//书：书名 ，书号，出版社，作者，定价
//自己创造的类型
struct Book
{
//结构体的成员（变量）
char name[20];
char id[20];//字符数组
int price;
};
int main()
{
int num = 10;
//结构体变量名.成员名
struct Book b = {"C语言","C20210509",55};
struct Book * pb = &b;//pb是一个struct Book类型指针，存放的是b的地址
printf("书名：%s\n", b.name);
printf("书号：%s\n", b.id);
printf("书价:%d\n", b.price);
printf("书名：%s\n", (*pb).name);//对pb解引用找到了b *pb等价于变量b
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;
}12. 表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。
12.1 隐式类型转换
C
的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为
整型
提升
。针对自身类型达不到int类型的 <=4
整型提升的意义
：
表达式的整型运算要在 CPU 的相应运算器件内执行， CPU 内整型运算器 (ALU) 的操作数的字节长度 一般就是int 的字节长度，同时也是 CPU 的通用寄存器的长度。因此，即使两个 char 类型的相加，在 CPU 执行时实际上也要先转换为 CPU 内整型操作数的标准长度。通用 CPU （ general-purpose CPU ）是难以直接实现两个 8 比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int 长度的整型值，都必须先转换为int 或 unsigned int ，然后才能送入 CPU 去执行运算。
// 实例 1char a , b , c ;...a = b + c ;
b
和
c
的值被提升为普通整型，然后再执行加法运算。
加法运算完成之后，结果将被截断，然后再存储于a中。
如何进行整体提升呢？
整形提升是按照变量的数据类型的符号位来提升的
// 负数的整形提升char c1 = - 1 ;变量 c1 的二进制位 ( 补码 ) 中只有 8 个比特位：1111111因为 char 为有符号的 char所以整形提升的时候，高位补充符号位，即为 1提升之后的结果是：11111111111111111111111111111111// 正数的整形提升char c2 = 1 ;变量 c2 的二进制位 ( 补码 ) 中只有 8 个比特位：00000001因为 char 为有符号的 char所以整形提升的时候，高位补充符号位，即为 0提升之后的结果是：00000000000000000000000000000001// 无符号整形提升，高位补 0
int main()
{
char a = 3;
//00000000 00000000 00000000 00000011
//00000011 - a 符号位0
char b = 127;
//00000000 00000000 00000000 01111111
//01111111 - b 符号位0
//
char c = a + b;
//00000000 00000000 00000000 00000011
//00000000 00000000 00000000 01111111 //按照数据类型的符号位来提升
//00000000 00000000 00000000 10000010
// char 8位 截断 存放低8位 10000010 - c
//发现a和b都是char类型的，都没有达到一个int的大小
//这里就会发生整型提升
printf("%d\n", c);//-126 %d 打印整型 需要整型提升
//10000010 - c
//11111111 11111111 11111111 10000010 - c //按照数据类型的符号位来提升 因为是有符号数所以现在是负数的补码
//我们打印出来的也就是说可以肉眼可见的数字是原码，内存中进行计算时用的是补码，所以需要把c转换成原码
//原码--》补码 -1 后取反 / 取反+1
//11111111 11111111 11111111 10000010 - c 补码
//10000000 00000000 00000000 01111101 反码 符号位不变，其他按位取反
//10000000 00000000 00000000 01111110 原码 -126
return 0;
}
整形提升的例子
:
//实例1
int main()
{
char a = 0xb6;
short b = 0xb600;
int c = 0xb6000000;
if(a==0xb6)
printf("a");
if(b==0xb600)
printf("b");
if(c==0xb6000000)
printf("c");
return 0;
}
实例1
中的
a,b
要进行整形提升
,
但是
c
不需要整形提升
a,b
整形提升之后
,
变成了负数
,
所以表达式
a==0xb6
,
b==0xb600
的结果是假
,
但是
c
不发生整形提升
,
则表达式 c==0xb6000000
的结果是真
.
所程序输出的结果是
:
c
实例
2
中的
,c
只要参与表达式运算
,
就会发生整形提升
,
表达式
+c
,
就会发生提升
,
所以
sizeof(+c)
是
4
个字节.
表达式
-
c
也会发生整形提升
,
所以
sizeof(
-
c)
是
4
个字节
,
但是
sizeof(c)
,
就是
1
个字节
.
比int大的不用整型提升
12.2 算术转换
如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换
。向上转换，向精度更高的转换。
long doubledoublefloatunsigned long intlong intunsigned intint
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
警告：
但是算术转换要合理，要不然会有一些潜在的问题。
float f = 3.14 ;int num = f ; // 隐式转换，会有精度丢失
12.3 操作符的属性
复杂表达式的求值有三个影响的因素。
1.
操作符的优先级
2.
操作符的结合性
3.
是否控制求值顺序。
两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
int main()
{
int a = 4;
int b = 5;
//int c = a + b * 7;//优先级决定了计算顺序
int c = a + b + 7;//优先级不起作用，结合性决定了计算顺序
return 0;
}
操作符优先级
N/A 表示不考虑结合性，L-R 表示从左向右结合 ，R-L表示从右向左结合
&& 逻辑与左边为假，右边不用计算了
|| 逻辑或左边为真，右边不用计算了
？：条件操作符，表达式1成立，表达式2计算表达式3不计算，表达式1不成立，表达式2不计算表达式3计算。
，逗号操作符，整个表达式从左向右计算，仅仅起到作用是最后的表达式的结果。
操作符优先级：
一些
问题表达式
// 表达式的求值部分由操作符的优先级决定。// 表达式 1a * b + c * d + e * f
注释：代码
1
在计算的时候，由于
*
比
+
的优先级高，只能保证，
*
的计算是比
+
早，但是优先级并不
能决定第三个
*
比第一个
+
早执行。
合理操作拆分计算
所以表达式的计算机顺序就可能是：
a *bc * da * b + c * de * fa * b + c * d + e * f或者：a * bc * de * fa * b + c * da * b + c * d + e * f// 表达式 2c + -- c ;
注释：同上，操作符的优先级只能决定自减
--
的运算在
+
的运算的前面，但是我们并没有办法得
知，
+
操作符的
左操作数的获取在右操作数之前还是之后求值
，所以结果是不可预测的，是有歧义
的。
// 代码 3- 非法表达式 这道题出自《C和指针》int main (){int i = 10 ;i = i -- - -- i * ( i = - 3 ) * i ++ + ++ i ;printf ( "i = %d\n" , i );return 0 ;}
表达式
3
在不同编译器中测试结果：非法表达式程序的结果
//代码4
int fun()
{
static int count = 1;
return ++count;
}
int main()
{
int answer;
answer = fun() - fun() * fun();
printf( "%d\n", answer);//输出多少？
return 0;
}这个代码有没有实际的问题？
有问题！
虽然在大多数的编译器上求得结果都是相同的。10
但是上述代码
answer = fun()
-
fun() * fun()
;
中我们只能通过操作符的优先级得知：先算乘法，
再算减法。 函数的调用先后顺序无法通过操作符的优先级确定。
//代码5
#include <stdio.h>
int main()
{
int i = 1;
int ret = (++i) + (++i) + (++i);
printf("%d\n", ret);
printf("%d\n", i);
return 0;
}
//尝试在linux 环境gcc编译器，VS2013环境下都执行，看结果。Linux环境的结果：
VS2013
环境的结果：
看看同样的代码产生了不同的结果，这是为什么？
简单看一下汇编代码
.
就可以分析清楚
.
这段代码中的第一个
+
在执行的时候，第三个
++
是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 +
和第三个前置 ++
的先后顺序。
总结
：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。
扫一扫
1382
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
