操作符详解，超详细的介绍操作符的作用与功能还要注意事项
1.操作符分类
算术操作符
位移操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号操作符
下标引用、函数调用和结构体成员操作符
2.算术操作符
+ - * / %
- 除%操作符外，其他的4个操作符都是可以作用于整数和浮点数。即取模的操作符的两端必须都是整数。
- 对于/操作符如果两个操作数都为整数，执行整数除法。而有浮点数执行的就是浮点数除法
- %操作符的两个操作符必须为整数。返回的是整数之后的余数
程序当中的二进制位
程序的最底层都是二进制位，在C语言中也不例外。数与数的运算都是以二进制位运算的，以正整数15为例，它的二进制表达为：00000000 00000000 00000000 00001111。同时二进制有三种表达形式。
整数的二进制表达形式：
原码 反码 补码。
正整数的原 反 补码是相同的
负整数的原 反 补码是要计算的
计算负整数的反码与补码
负数的反码等于原码的符合位不变，其他位按位取反得到的就是反码
补码等于反码加1
以-15为例 -15的原码为 10000000 00000000 00000000 00001111 -15的补码为 11111111 11111111 11111111 11110000 -15的补码为 11111111 11111111 11111111 11110001
什么是符号位
符号位就是在整数的进制位最左侧的一位为符号位，1表示负数 0表示正数。
补码的作用
在计算机中的运算都是围绕着补码来计算的。
在内存中存储的是补码，计算也是用的补码
3.移位操作符
> 右移操作符 //移位操作符的操作数只能是整数
3.1 左移操作符
左边抛弃、右边补0
在num没有被赋值的情况下，自身的值不会改变。
3.2 右移操作符
规则
右移运算有两种规则：
> 1.逻辑移位
> 左边用0填充，右边抛弃
> 2.算术移位
> 左边用原该值的符号位填充，右边抛弃
C语言没有明确规定是算术右移还是符号右移，一般编译器上采用的是算术右移
#include int main() { int num = -1; int b = num >> 1; printf("%d\n", b); return 0; } //打印结果 -1
注意：对于移位操作符，不能移动负数位，这是标准为定义行为
//错误写法 int num = 10; num>>-1;//error
4.位操作符
位操作符：
& //按位与 | //按位或 ^ //按位异或 //以上操作符的操作数必须是整数
位操作符也是对二进制进行操作的，且为双目操作符
&的作用就是将，两个二进制位的补码，对应位置有0为0，两个同时为1才是1.
1&2 00000000 00000000 00000000 00000001 00000000 00000000 00000000 00000010 结果 00000000 00000000 00000000 00000000
|的作用就是将，两个二进制位的补码，对应位置有1为1，两个同时为0才是0.
1|2 00000000 00000000 00000000 00000001 00000000 00000000 00000000 00000010 结果 00000000 00000000 00000000 00000011
^的作用就是将，两个二进制位的补码，对应位置相同为0，不同为1.
1^2 00000000 00000000 00000000 00000001 00000000 00000000 00000000 00000010 结果 00000000 00000000 00000000 00000011
练习：
#include int main() { int num1 = 1; int num2 = 2; printf("%d\n",num1&num2); printf("%d\n",num1|num2); printf("%d\n",num1^num2); return 0; } //打印结果 /* 0 3 3 */练习
在不能创建临时变量（第3个变量）的情况下，实现两个数的交换
//代码1 #include int main() { int a = 5; int b = 3; a = a^b; b = a^b; a = a^b; printf("a = %d,b = %d",a,b); return 0; } //代码2 #include int main() { int a = 5; int b = 3; a = a-b; b = a+b; a = b-a; printf("a = %d,b = %d\n",a,b); return 0; }练习
编写代码实现：求一个整数存储在内存中的二进制中的1的个数
#include int main() { int a = 0; scanf("%d",&a); int num = 1; int count = 0; for(int i = 0;i num = 1 count++; } } printf("%d\n",count); return 0; } int a = 1; int* pa = &a; a = -a; printf("%d\n",sizeof(a)); printf("%d\n",sizeof a); printf("%d\n",sizeof(int)); printf("%d\n",sizeof int);//错误写法，对应类型计算要加() return 0; } printf("%d\n",sizeof(arr)); } void test2(char ch[10]) { printf("%d\n",sizeof(ch)); } int main() { int arr[10] = {0}; char ch[10] = {0}; printf("%d\n",sizeof(arr)); printf("%d\n",sizeof(ch)); test1(arr); test2(ch); return 0; } //打印结果 /* 40 10 4/8 4/8 */ int a = 10; int x = ++a; //a先自增1，然后再用a对x赋值 int y = a++; //先用a赋值y，然后a再自增1 return 0; } int i = 0,a = 0,b = 2,c = 3,d = 4; i = a++&&++b&&d++; printf(" a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d); return 0; } //打印结果 /* a = 1 b = 2 c = 3 d = 4 */ //代码1 #include int i = 0,a = 0,b = 2,c = 3,d = 4; i = a++||++b||d++; printf(" a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d); return 0; } //打印结果 /* a = 1 b = 3 c = 3 d = 4 */blockquote p对于多个&&连接的一个式子，从左到右当出现一个表达式为假时，此时该条式子已经为假，计算机便不要再往右计算。/pp对于多个||连接的一个式子，从左到右当出现一个表达式为真时，此时该条式子已经为真，计算机便不要再往右计算。/p /blockquote h29.条件操作符/h2 pre class="brush:python;toolbar:false"exp1?exp2:exp3 //当exp1为真时执行exp2反之执行exp3 /pre pre class="brush:python;toolbar:false"if(a5) b = 3; else b = -3; //利用条件操作符简化 b = a>5?3:-310.逗号表达式
exp1,exp2,exp3,...expn
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，c从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
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] = {0}; arr[9] = 10; //[]的两个操作数是arr和9。 //数组也是有类型的，去掉名字就是数组类型，如int arr[10] = {0};类型为：int [10]2.（）函数调用操作符
接受一个或者多个操作符：第一个操作数是函数名，剩余的操作数就是传递给函数的参数
#include void test1() { printf("hahaha\n"); } void test2(const char* str) { printf("%s\n",str); } int main() { test1(); test2("hello!"); }3.访问一个结构的成员
.结构体.成员名
-> 结构体指针->成员名
#include struct stu { char name[10]; int age; char sex[5]; }; int main() { struct stu s; struct stu* ps; ps = &s; s.age = 17; s.name = Yui; s.sex = female; ps->age = 18; ps->name = Yui; s->sex = female; }12.表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定的。
同样，有些表达式的操作符在求值的过程中可能需要转换类型为其他类型。
12.1隐式类型转换
C的整型算术总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升
整型提升的意义：
表示式的整型要在CPU的相应运算器执行，CPU内整型运算器（ALU）的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
通用CPU是难以直接实现两个8比特字节直接相加运算（虽然机器指令可能有这种字节相加的指令）。所以，表达式中的各种长度可能小于int长度的整型值，都必须先转换为int或者unsigned int
，然后才能送入CPU去执行。
//实例1 char a,b,c; ... a = b+c;
b和c的值被提升为普通整型，然后再执行加法运算。
加法完成后，结果将被截断，然后再存储于a当中。
然后进行整型提升
整型提升是按照变量的数据类型的符合位来提升的。
#include int main() { //负数的整型提升 char c1 = -1; //变量c1的二进制位（补码）中只有8个比特位 //11111111 //因为char为符合的char //所以在整型提升的时候，高位补充符合位，即为1 //提升后的结果： //11111111 11111111 11111111 11111111 char c2 = 1; //变量c2的二进制位（补码）中只有8个比特位 //00000001 //因为char为符合的char //所以在整型提升的时候，高位补充符合位，即为1 //提升后的结果： //00000000 00000000 00000000 00000001 //无符号整型提升，高位补0 }#include int main() { char c = 1; printf("%u\n",sizeof(c)); printf("%u\n",sizeof(+c)); printf("%u\n",sizeof(-c)); return 0; } //打印结果 /* 1 4 4 */该实例中，c只要参加表达式运算，就会发生整型提升，所以在执行+c/-c的过程中就有整型提升。变为整型4个字节
12.2 算术转换
如果某个操作符的各个操作符属于不同的类型，那么除非其中一个操作数的转换位另一个操作数的类型，否则就无法计算。下面的层次体系称为寻常算术转换。
long double double float unsigned long int long int unsigned int int
如果，某个操作数的类型在上面这个列表的排名较低，那么首先要转换位另一个操作数的类型后执行运算。
注意：
算术转换要合理，不然可能会有精度丢失等一些问题。
float f = 3.14; int num = f;//隐式转换，会有精度丢失
12.3操作符的属性
复杂表达式的求值有3个影响因素。
- 操作符的优先级
- 操作符的结合性
- 是否控制求值顺序
两个相邻的操作符先执行哪个，取决于它们的优先级。如果两者优先级相同，取决于它们的结合性。
操作符优先级
操作符 描述 用法示例 结果类 型 结合性 是否控制求值 顺序 （） 聚组 （表达式） 与表达式同 N/A 否 （） 函数调用 rexp（rexp，…,rexp） rexp L-R 否 [ ] 下标引用 rexp[rexp] lexp L-R 否 . 访问结构成员 lexp.member_name lexp L-R 否 -> 访问结构指针成员 rexp->member_name lexp L-R 否 ++ 后缀自增 lexp ++ rexp L-R 否 – 后缀自减 lexp – rexp L-R 否 ! 逻辑反 ! rexp rexp R-L 否 ~ 按位取反 ~ rexp rexp R-L 否 + 单目，表示正值 + rexp rexp R-L 否 - 单目，表示负值 - rexp rexp R-L 否 ++ 前缀自增 ++ lexp rexp R-L 否 – 前缀自减 – lexp rexp R-L 否 * 间接访问 * rexp lexp R-L 否 & 取地址 & lexp rexp R-L 否 sizeof 取其长度，以字节
表示sizeof rexp sizeof(类型) rexp R-L 否 (类型） 类型转换 (类型) rexp rexp R-L 否 * 乘法 rexp * rexp rexp L-R 否 / 除法 rexp / rexp rexp L-R 否 % 整数取余 rexp % rexp rexp L-R 否 + 加法 rexp + rexp rexp L-R 否 - 减法 rexp - rexp rexp L-R 否 > rexp rexp L-R 否 > 大于 rexp > rexp rexp L-R 否 >= 大于等于 rexp >= rexp rexp L-R 否 int i = 10; i = i-- - --i * (i=-3) * i++ + ++i; printf("i = %d\n",i); return 0; }
