一 ，操作符的分类
1.算术操作符：+ ，-， * ，/ ，%
2.移位操作符：<< >>
3.位操作符 : & | ^ ~
4.赋值操作符: = ，+= ，-= ，*= ，/= ，%= ，<<= , >>= ，&= ，|= ，^=
5.单目操作符：! , ++ , --, - , + , * , & , ~ ,sizeof(类型)
6.关系操作符:> , < , >= ,<= , == , !=
7.逻辑操作符：&& || !
8.条件操作符：? :
9.逗号表达式： ,
10.下标引用 ： [ ]
11.函数调用 ： ( )
12.结构成员访问： . , ->
二 ，二级制和进制转化
在日常生活中，我们常常听到不同的进制，时钟有60进制，12进制，每周的7进制。其实无论是多少进制，都是数值的不同表示方法:
比方说：数值15的各种进制表现形式：
15的2进制：1111
15的8进制：17
15的10进制：15
15的16进制：F
// 16 进制的数值之前写： 0x
// 8进制的数值之前写 ：0
以我们日常生活中常见的10进制做类比：
- 10进制满10进1
- 10进制的每一位数值是0-9组成的
推理到2进制：
- 2进制满2进1
- 2进制的每一位数值都是0-1组成的
2.1 二进制转十进制
在10进制中，520表示的是五百二十，是因为10进制中的每一位数都是有权重的，这里的520=0*10^0 + 2*10^1 + 5*10^2;
这与二进制也是类似的，只不过权重不同：
这里以二进制1101来举例：
2.2 10进制转二进制
2.3 2进制转8进制
8进制的数字每一位都是0-7的，然后0-7的数字写成2进制，最多需要3位二进制数就足够了，比方说7的二进制数是111，所以在2进制数转成8进制数的时候，从最右边的最低为开始选3个数为一组来计算即可，如果不够3位，前补0或者直接换算；
2.4 2进制数转16进制数
16进制的每一位是0-9，a-f,然后把它们写成二进制的数，最多需要4位二进制数即可；
注意16进制表示时，前面加0x,所以二进制数 01101011 的16进制形式为 0x6b;
三 ，原码，补码，反码
整数中的2进制表示方法有三种，即原码，反码，补码；
有符号整数的三种表示方法均有符号位和数值为两部分，2进制序列中，最高位的1位被当作符号位，其余的都是数值为。
符号位中以0表示“正”，以1表示”负“；
四 ， 移位操作符
<< 左移操作符
>> 右移操作符
注意： 操作数只能是整数
4.1 左移操作符
移位规制：左边抛弃，右边补0 ---->进行运算的是数值的二进制（内存中的补码）
正数：
int main()
{
int n = 10;
int m = n << 1;
printf("%d\n", n);
printf("%d\n", m);
return 0;
}
负数：
int main()
{
int a = -10;
int b = a << 1;
int c = a << 2;
//10000000 00000000 00000000 00001010
//补码：
//11111111 11111111 11111111 11110110
//左移：
//11111111 11111111 11111111 11101100 --- b在内存中的补码
//10000000 00000000 00000000 00010100
printf("%d\n", a);
printf("%d\n", b);
printf("%d\n", c);
return 0;
}
我们不难发现：左移运算符在一定程度上(并不是都是），每次左移一位，数值会在原有的基础上乘以2；
需要注意的是：负数要转化成补码进行移动，最后在转化原码得到移动结果。
4.2 右移操作符
移动规则： 右移运算分为两种
1.逻辑右移：左边用0填充，右边丢弃
2.算数右移：左边用原来该数值的符号位填充，右边丢弃
右移是逻辑右移还是算数右移是取决于编译器的，但大多数的编译器采用的是算数右移。
int main()
{
int a = -10;
int b = a >> 1;
int c = a >> 2;
int d = a >> 3;
//10000000 00000000 00000000 00001010
//11111111 11111111 11111111 11110110 --- 补码
//11111111 11111111 11111111 11111011
//10000000 00000000 00000000 00000101 -- -5
//右移到底是算数右移还是逻辑右移，是取决于编译器，但是大部分编译其采用的都是算术右移
printf("%d\n", a);
printf("%d\n", b);
printf("%d\n", c);
printf("%d\n", d);
return 0;
}注意：对于移位符号位，不要移动负数位，这个标准是未定义的。
五 ，位操作符
& 按位与
| 按位或
^ 按位异或
~ 按位非
注意：他们的操作数必须是整数
int main()
{
int a = -5;
int b = 13;
int c = a & b;
int d = a | b;
int e = a ^ b;
int f = ~a;
//a:10000000 00000000 00000000 00000101
//a:11111111 11111111 11111111 11111011 -5补码
//b:00000000 00000000 00000000 00001101 13补码
// 00000000 00000000 00000000 00001001 & 9
// 11111111 11111111 11111111 11111111 |
// 10000000 00000000 00000000 00000001
// 11111111 11111111 11111111 11110110 ^
// 10000000 00000000 00000000 00001010
// 00000000 00000000 00000000 00000100 ~
printf("%d\n", c);
printf("%d\n", d);
printf("%d\n", e);
printf("%d\n", f);
return 0;
}试着完成：
题目：不能创建临时变量（第三个变量），从而实现两个整数交换；
如果我们使用第三个变量就很容易实现，就像现在你有一瓶酱油和一瓶醋，我们可以通过一个空瓶子把这两个容器里的液体交换；
int main()
{
int a = 10;
int b = 20;
int c = 0;
printf("交换前:%d %d\n", a, b);
c = a;
a = b;
b = c;
printf("交换后:%d %d\n", a, b);
return 0;
}但是题目要求不可以用第三个变量，但我们可以先把两个数相加，然后赋值给a,然后再用赋值后的a减去b 实则上就是我们原来的a值，然后把这个值赋给 b ,再用a值减去 b ，就是我们原来的 b 值，然后赋值给a ,即可实现交换；
int main()
{
int a = 10;
int b = 20;
printf("交换前:%d %d\n", a, b);
a = a + b;
b = a - b;
a = a - b;
printf("交换后:%d %d\n", a, b);
return 0;
}这样计算，当数值较小的时候的确可以实现我们的数值交换，但是当数值越来越大的时候，两个数值进位相加，可能会超出整数表达的最大值，可能会存在溢出问题！
所以我们再次优化这个算法：
a^a == 0
a^0 ==a
异或：相异为1，相同为0
两个二进制数没有进位运算，不会导致溢出！
int main()
{
int a = 10;
int b = 20;
printf("交换前：a=%d b=%d\n", a, b);
a = a ^ b;
b = a ^ b; //a ^ b^ b; ----> a
a = a ^ b; //a ^ b ^ a ---->b
printf("交换后：a=%d b=%d\n", a, b);
return 0;
}练习1：
编写代码实现：求⼀个整数存储在内存中的⼆进制中1的个数； 思路：在10进制中，我们 %10取余，得到某一个数值的最后一位数； /10取整得到某一个数值去掉最后一位数的数值；int main()
{
int n = 0;
scanf("%d", &n);
int count = 0;
while (n)
{
if (n % 2 == 1) {
count++;
}
n /= 2;
}
printf("二进制中1的个数为%d\n", count);
return 0;
}但是我们很快就可以发现，针对负数是有问题的；
然后我们，就会想，什么运算会不丢失原有而二进制的数值，然后又可以方便计算的，最后，我们可以想到按位与（&），让每一个二进制数按位与1 ；
int main()
{
int n = 0;
scanf("%d", &n);
int count = 0;
for (int i = 0; i < 32; i++)
{
if ((1 & (n >> i)) == 1)
{
count++;
}
}
printf("%d\n", count);
return 0;
}
但是这里我们计算了32次，然后我们思考，能不能再优化一下：
int main()
{
int n = 0;
scanf("%d", &n);
int count = 0;
while (n)
{
n = n & (n - 1);
count++;
}
printf("%d\n", count);
return 0;
}练习二：
题目：写一个代码判断 n 是否是2的次方数
2次方数有：1 2 4 8 16 32 64 .....
我们把他们转成二进制数：
00000001
00000010
00000100
00001000
00010000
................
我们发现他们有且仅有一个1
int main()
{
int n = 0;
scanf("%d", &n);
if ((n & (n - 1)) == 0)
{
printf("Yes!\n");
}
else
{
printf("No!\n");
}
return 0;
}
案例3：
题目：编写代码将13⼆进制序列的第5位修改为1，然后再改回0
13 的 2 进制序列： 00000000000000000000000000001101 将第 5 位置为 1 后： 00000000000000000000000000011101 将第 5 位再置为 0 ： 00000000000000000000000000001101
int main()
{
int n = 13;
n |= (1 << (5 - 1));
//00000000 00000000 00000000 00001101
printf("%d\n", n);
//00000000 00000000 00000000 00001101 --13
//00000000 00000000 00000000 00010000 |
// 1 <<4
//00000000 00000000 00000000 00011101
//11111111 11111111 11111111 11101111 &
//00000000 00000000 00000000 00001101
n &= (~(1 << (5 - 1)));
printf("%d\n", n);
return 0;
}
六 ，单目操作符
！、++、--、&、*、+、-、~ 、sizeof、(类型)
七 ， 逗号表达式
1.以逗号依次隔开的多个表达式
2.从左向右依次执行，整个表达式的结果是最后一个表达式的结果。
//代码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)
{
//业务处理
}
八 ， 下标访问[]，函数调用（）
1.下标引用操作符[]: 操作数：一个数组名+一个索引值
int arr[ 10 ]; // 创建数组 arr[ 9 ] = 10 ; // 实⽤下标引⽤操作符。 [ ] 的两个操作数是 arr 和 9 。
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 ; }
九，操作符的属性：优先级，结合性
C语⾔的操作符有2个重要的属性：优先级、结合性，这两个属性决定了表达式求值的计算顺序。
优先级指的是，如果⼀个表达式包含多个运算符，哪个运算符应该优先执⾏。各种运算符的优先级是不⼀样的。 如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就看结合性了，则根据运算符 是左结合，还是右结合，决定执⾏顺序。⼤部分运算符是左结合（从左到右执⾏），少数运算符是右 结合（从右到左执⾏）
十， 表达式求值
1.整型提升：
C语⾔中整型算术运算总是⾄少以缺省（默认）整型类型的精度来进⾏的。为了获得这个精度，表达式中的字符和短整型操作数在使⽤之前被转换为普通整型，这种转换称为整型提升。int main()
{
char a = 5;
//00000000 00000000 00000000 00000101
//00000101 截断
char b = 126;
//00000000 00000000 00000000 01111110
//01111110
char c = a + b;
//00000101 --- 发生整型提升 --00000000 00000000 00000000 00000101
//01111110 --- 发生整型提升 --00000000 00000000 00000000 01111110
//char --- signed char
//00000000 00000000 00000000 10000011 --- 截断 -- 10000011
//当以%d 形式进行打印的时侯，打印的是有符号整数
//又会对c发生整形提升
//11111111 11111111 11111111 10000011 -- 内存中的补码
//10000000 00000000 00000000 01111101
printf("%d\n", c);
return 0;
}
如何进⾏整体提升呢？
1. 有符号整数提升是按照变量的数据类型的符号位来提升的 2. 无 符号整数提升，高位补0
2.算数转换：
如果某个操作符的各个操作数属于不同的类型，那么除⾮其中⼀个操作数的转换为另⼀个操作数的类型，否则操作就⽆法进⾏。下⾯的层次体系称为寻常算术转换long double double float unsigned long int long int unsigned int int如果某个操作数的类型在上⾯这个列表中排名靠后，那么⾸先要转换为另外⼀个操作数的类型后执⾏运算
标签：11111111,10,进制,int,00000000,详解,操作符,printf From： https://blog.csdn.net/khjjjgd/article/details/141988669