1. 操作符分类：

2. 算术操作符

int main()
{double a = 5 % 2;//商2余1printf("a = %lf\n", a);return 0;
}

3. 移位操作符

3.1 左移操作符

左边抛弃、右边补0

3.2 右移操作符

首先右移运算分两种：

1. 逻辑移位 左边用0填充，右边丢弃

2. 算术移位 左边用原该值的符号位填充，右边丢弃

对于移位运算符，不要移动负数位，这个是标准未定义的。

int main()
{int a = 16;//>> -- 右移操作符//移动的是二进制位//00000000000000000000000000010000int c = a >> 1;//8int b = a >> 2;//4printf("%d\n", c);printf("%d\n", b);return 0;
}int main()
{int a = -1;////整数的二进制表示有：原码、反码、补码//存储到内存的是补码//10000000000000000000000000000001 - 原码//11111111111111111111111111111110 - 反码【原码除符号位全部取反】//11111111111111111111111111111111 - 补码【反码+1】//int b = a >> 1;//-1printf("%d\n", b);return 0;
}
int main()
{int a = 5;int b = a << 1;//00000000000000000000000000000101printf("%d\n", b);//10return 0;
}

4. 位操作符

int main()
{//& - 按2进制位与【全部为1才为1，其他为0】/*int a = 3;int b = 5;int c = a&b;*///00000000000000000000000000000011//00000000000000000000000000000101//00000000000000000000000000000001//printf("%d\n", c);//| - 按2进制位或【只要有1，则为1】/*int a = 3;int b = 5;int c = a | b;printf("%d\n", c);*///00000000000000000000000000000011//00000000000000000000000000000101//00000000000000000000000000000111//按2进制位异或【相同为0，相异为1】/*int a = 3;int b = 5;int c = a ^ b;printf("%d\n", c);*///00000000000000000000000000000011//00000000000000000000000000000101//00000000000000000000000000000110//return 0;
}

不能创建临时变量（第三个变量），实现两个数的交换

^:相反为1，相同为0

//不能创建临时变量（第三个变量），实现两个数的交换
int main()
{int a = 3;int b = 5;//int tmp = 0;//临时变量printf("before: a=%d b=%d\n", a, b);//tmp = a;//a = b;//b = tmp;//加减法-可能会溢出/*a = a + b;b = a - b;a = a - b;*///异或的方法a = a^b;b = a^b;a = a^b;printf("after : a=%d b=%d\n", a, b);return 0;
}

练习

编写代码实现：求一个整数存储在内存中的二进制中1的个数。

参考代码：
//方法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 main()
{//a = a + 2;//a += 2;//复合赋值符////a = a >> 1;//a >>= 1;//a = a & 1;//a &= 1;return 0;
}

6. 单目操作符

6.1 单目操作符介绍

int main()
{int a = 0;if (a){printf("呵呵\n");}if (!a){printf("呵呵\n");}return 0;
}

int main()
{int a = 10;int* p = &a;//取地址操作符//*p：是存放a的内容 p:是存放a的地址*p = 20;//解引用操作符return 0;
}

int main()
{int a = 10;//printf("%d\n", ++a);//前置++，先++，后使用printf("%d\n", a++);//后置++，先使用，再++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 = (int)3.14;//int a = int(3.14);//errreturn 0;
}

难点:&和|

| 和 ||，& 和 && 的区别

注意点： & 1:一定可以得到最后一位

int main()
{int a = 11;a = a | (1 << 2);printf("%d\n", a);//15//要求想把第三位0变成1//0000000000000000000000000000001011-->11//0000000000000000000000000000000100-->1<<2【4】两者进行按位或，只要有1则为//0000000000000000000000000000001111//a = a & (~(1 << 2));printf("%d\n", a);//11//要求想把第三位1变成0//0000000000000000000000000000001111--->15// 0000000000000000000000000000000100<-【向右移动2位】---0000000000000000000000000000000001//             ||并且按位取反//             👇//1111111111111111111111111111111011--->~(1<<2)//0000000000000000000000000000001011//////int a = 0;~ 按（2进制）位取反0000000000000000000000000000000011111111111111111111111111111111 - 补码=反码+111111111111111111111111111111110 - 反码10000000000000000000000000000001 - 原码=补码-1+除符号位外全部取反//printf("%d\n", ~a);//-1return 0;
}

int a = 11;
a = a | (1 << 2);
printf("%d\n", a);//15

a = a & (~(1 << 2));
printf("%d\n", a);//11

7 sizeof 和 数组

sizeof

int main()
{int a = 10;char c = 'r';char* p = &c;int arr[10] = { 0 };//sizeof 计算的变量所占内存空间的大小，单位是字节printf("%d\n", sizeof a);//4printf("%d\n", sizeof(int));//4printf("%d\n", sizeof(c));//1printf("%d\n", sizeof(char));//1//指针大小4或者8printf("%d\n", sizeof(p));//4printf("%d\n", sizeof(char*));//4printf("%d\n", sizeof(arr));//40printf("%d\n", sizeof(int [10]));//40return 0;
}

注意点：sizeof中的算术不进行运算

int main()
{short s = 0;int a = 10;//siezof：表达式中不参与运算printf("%d\n", sizeof(s = a + 5));//2printf("%d\n", s);//0return 0;
}

---

---

#include <stdio.h>
void test1(int arr[])//首元素地址
{printf("%d\n", sizeof(arr));//(2)  4【32平台】
}
void test2(char ch[])//首元素地址
{printf("%d\n", sizeof(ch));//(4)  4【32平台】
}
int main()
{int arr[10] = { 0 };char ch[10] = { 0 };printf("%d\n", sizeof(arr));//(1)printf("%d\n", sizeof(ch));//(3)test1(arr);test2(ch);return 0;
}

8. 关系操作符

9. 逻辑操作符

9.1 逻辑与&&

int main()
{int a = 0;int b = 5;int c = a && b;printf("%d\n", c);//truereturn 0;
}

9.2 逻辑或|

int main()
{int a = 0;int b = 5;int c = a || b;printf("%d\n", c);//truereturn 0;
}

9.3 难点

#include <stdio.h>
int main()
{int i = 0, a = 1, b = 2, c = 3, d = 4;i = a++||++b||d++;printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);//return 0;
}

10 . 条件操作符

exp1 ? exp2 : exp

int main()
{int a = 10;int b = 20;int max = 0;if (a > b)max = a;elsemax = b;//如果a>b，则结果取a，否则取bmax = (a > b ? a : b);//if (a > 5)//	b = 3;//else//	b = -3;//b = (a > 5 ? 3 : -3);return 0;
}

11 . 逗号表达式

12 . 下标引用、函数调用和结构成员

1. [ ] 下标引用操作符

操作数：一个数组名 + 一个索引值

int main()
{int a[10] = { 0 };a[4] = 10;1 + 2;return 0;
}

2. ( ) 函数调用操作符

接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

int get_max(int x, int y)
{return x > y ? x : y;
}int main()
{int a = 10;int b = 20;//调用函数的时候的()就是函数调用操作符int max = get_max(a, b);printf("max = %d\n", max);return 0;
}

3. 访问一个结构的成员

. 结构体.成员名

-> 结构体指针->成员名

学生
int float创建一个结构体类型-struct Stu
struct Stu
{//成员变量char name[20];int age;char id[20];
};int main()
{int a = 10;//使用struct Stu这个类型创建了一个学生对象s1，并初始化struct Stu s1 = {"张三", 20, "2019010305"};struct Stu* ps = &s1;printf("%s\n", ps->name);printf("%d\n", ps->age);//结构体指针->成员名/*printf("%s\n", (*ps).name);printf("%d\n", (*ps).age);*//*printf("%s\n", s1.name);printf("%d\n", s1.age);printf("%s\n", s1.id);*///结构体变量.成员名return 0;
}

13 . 表达式求值

13.1 隐式类型转换【难点--小类型转换大类型】

//实例1
char a,b,c;
...
a = b + c;

b和c的值被提升为普通整型，然后再执行加法运算

如何进行整体提升呢？

整形提升是按照变量的数据类型的符号位来提升的

//负数的整形提升
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;//00000000000000000000000000000011-->3//00000011 - a//char b = 127;//‭00000000000000000000000001111111//‬01111111 - b//a和b如何相加//00000000000000000000000000000011//00000000000000000000000001111111//00000000000000000000000010000010  -->a+b//char c = a + b;//10000010-c//11111111111111111111111110000010 - 补码//11111111111111111111111110000001 - 反码//10000000000000000000000001111110- 原码//-126printf("%d\n", c);return 0;
}

int main()
{char a = 0xb6;//0xb6:十六进制：b:1011 6:0110short b = 0xb600;int c = 0xb6000000;if (a == 0xb6)//类型转换printf("a");if (b == 0xb600)//类型转换printf("b");if (c == 0xb6000000)printf("c");//结果输出creturn 0;
}

int main()
{char c = 1;printf("%u\n", sizeof(c));//1//[+c]表示进行计算printf("%u\n", sizeof(+c));//4printf("%u\n", sizeof(!c));//1return 0;
}

13.2 算术转换【大类型转换小类型】

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

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运 算。

警告： 但是算术转换要合理，要不然会有一些潜在的问题

float f = 3.14;
int num = f;//隐式转换，会有精度丢失

13.3 操作符的属性

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级 2. 操作符的结合性 3. 是否控制求值顺序

一些问题表达式

1 

//表达式的求值部分由操作符的优先级决定。
//表达式1
a*b + c*d + e*f

注释：代码1在计算的时候，由于*比+的优先级高，只能保证，*的计算是比+早，但是优先级并不 能决定第三个*比第一个+早执行。

2

//表达式2
c + --c;

3

//代码3-非法表达式
int main()
{int i = 10;i = i-- - --i * ( i = -3 ) * i++ + ++i;printf("i = %d\n", i);return 0;
}

4

//代码4
int fun()
{static int count = 1;return ++count;
}
int main()
{int answer;answer = fun() - fun() * fun();printf( "%d\n", answer);//输出多少？return 0;
}

5

//代码5
#include <stdio.h>
int main()
{int i = 1;int ret = (++i) + (++i) + (++i);printf("%d\n", ret);printf("%d\n", i);return 0;
}

14.作业

注意点1：

#include <stdio.h>
int main()
{int arr[] = { 1, 2, 3, 4, 5 };short *p = (short*)arr;int i = 0;for (i = 0; i<4; i++){*(p + i) = 0;}for (i = 0; i<5; i++){printf("%d ", arr[i]);//0034}return 0;
}

注意点2： 

#include <stdio.h>
int main()
{int a = 0x11223344;//实际上是倒着放-->地址上是：44332211char *pc = (char*)&a;*pc = 0;//实际上是将首元素位置上的值修改为:00printf("%x\n", a);//11223300return 0;
}

注意点3：

#include <stdio.h>
int i;//全局变量-不初始化-默认是0
int main()
{i--;//-1//10000000000000000000000000000001-->-1原码//11111111111111111111111111111110--->-1反码//11111111111111111111111111111111--->-1补码//	👇// 1111111111111111111111111111111【无穷大】if (i > sizeof(i))//sizeof()-计算变量/类型所占内存的大小 >=0 返回的值是：无符号数{printf(">\n");}else{printf("<\n");}return 0;
}

注意点4：

#include <stdio.h>
int main()
{int a, b, c;a = 5;c = ++a;//c=6  a=6//  7    8    6     7b = ++c, c++, ++a, a++;//c=8 a=8 b=7b += a++ + c;//b=b+(a++)+c=7+8+8=23printf("a = %d b = %d c = %d\n:", a, b, c);//9 23 8return 0;
}

注意点5：写一个函数求a的二进制（补码）表示中有几个1【按位与】

int count_bit_one(int n)
{int count = 0;while (n){if (n % 2 == 1)//存在问题：无法计算负数{count++;}n = n / 2;//去除为1的数值}return count;
}

//改进1
//使用接收进来的是无符号数;unsigned,则忽略符号
int count_bit_one(unsigned int n)
{int count = 0;while (n){if (n % 2 == 1)//存在问题：无法计算负数{count++;}n = n / 2;//去除为1的数值}return count;
}

//改进2
int count_bit_one(int n)
{int count = 0;int i = 0;for (i = 0; i < 32; i++){//(n >> i)：将输入的值向右移动1位if (((n >> i) & 1) == 1)//全为1，则1{count++;}}return count;
}

最经典解法

//改进3
int count_bit_one(int n)
{int count = 0;while (n){n = n & (n - 1);count++;}return count;
}//n = n&(n-1)-->每一次都会去除最右边的1消失
//n
//13
//1101 n
//1100 n-1
// n = n&(n-1)
// 👇
//1100 n
//1011 n-1
//1000 n
//0111 n-1
//0000 n

注意点6：求二进制中不同的个数

int get_diff_bit(int m, int n)
{//为1表示，有一个1和一个0int tmp = m^n;//异或【相同为0，相反为1】int count = 0;//return count_bit_one(tmp);while (tmp){tmp = tmp&(tmp - 1);count++;}return count;
}int main()
{int m = 0;int n = 0;scanf("%d%d", &m, &n);int count = get_diff_bit(m, n);printf("count = %d\n", count);return 0;
}

第37分钟左右

注意点7：打印二进制的奇数位和偶数位

第42分钟左右

void print(int m)
{int i = 0;printf("奇数位：\n");//将二进制向右移动，每一次移动2位，可以将其奇数位放在第一位，与1进行比较for (i = 30; i >= 0; i -= 2){//& 按位与操作，按二进制位进行"与"运算。运算规则：（有 0 则为 0）printf("%d ", (m >> i) & 1);// 注意点【任何数值与 &1 都可以得到最后一位】}printf("\n");printf("偶数位：\n");for (i = 31; i >= 1; i -= 2){printf("%d ", (m >> i) & 1);}printf("\n");
}int main()
{int m = 0;scanf("%d", &m);print(m);return 0;
}

注意点8：交换两个变量，不使用第三位数【重点】

//不能创建临时变量（第三个变量），实现两个数的交换
int main()
{int a = 3;int b = 5;//int tmp = 0;//临时变量printf("before: a=%d b=%d\n", a, b);//tmp = a;//a = b;//b = tmp;//加减法-可能会溢出/*a = a + b;b = a - b;a = a - b;*///异或的方法a = a^b;b = a^b;a = a^b;printf("after : a=%d b=%d\n", a, b);return 0;
}

注意点9：打印arr数组的内容，不使用数组下标

//打印arr数组的内容，不使用数组下标
void print(int *p, int sz)
{int i = 0;for (i = 0; i < sz; i++){printf("%d ", *(p + i));}
}
int main()
{int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };int sz = sizeof(arr) / sizeof(arr[0]);print(arr, sz);return 0;
}