1. 操作符分类：

2. 算术操作符

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

3. 移位操作符

3.1 左移操作符

左边抛弃、右边补0

3.2 右移操作符

首先右移运算分两种：

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

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

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

int main()
{
	int a = 16;
	//>> -- 右移操作符
	//移动的是二进制位
	//00000000000000000000000000010000
	int c = a >> 1;//8
	int b = a >> 2;//4
	printf("%d\n", c);
	printf("%d\n", b);
	return 0;
}


int main()
{
	int a = -1;
	//
	//整数的二进制表示有：原码、反码、补码
	//存储到内存的是补码
	//10000000000000000000000000000001 - 原码
	//11111111111111111111111111111110 - 反码【原码除符号位全部取反】
	//11111111111111111111111111111111 - 补码【反码+1】
	//
	int b = a >> 1;//-1
	printf("%d\n", b);
	return 0;
}
int main()
{
	int a = 5;
	int b = a << 1;
	//00000000000000000000000000000101
	printf("%d\n", b);//10
	return 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);//err

	return 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进制）位取反
	00000000000000000000000000000000
	11111111111111111111111111111111 - 补码=反码+1
	11111111111111111111111111111110 - 反码
	10000000000000000000000000000001 - 原码=补码-1+除符号位外全部取反
	//printf("%d\n", ~a);//-1

	return 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);//4
	printf("%d\n", sizeof(int));//4

	printf("%d\n", sizeof(c));//1
	printf("%d\n", sizeof(char));//1

	//指针大小4或者8
	printf("%d\n", sizeof(p));//4
	printf("%d\n", sizeof(char*));//4

	printf("%d\n", sizeof(arr));//40
	printf("%d\n", sizeof(int [10]));//40

	return 0;
}

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

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

	return 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);//true
	return 0;
}

9.2 逻辑或|

int main()
{
	int a = 0;
	int b = 5;
	int c = a || b;
	printf("%d\n", c);//true
	return 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;
	else
		max = b;
	//如果a>b，则结果取a，否则取b
	max = (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- 原码
	//-126
	printf("%d\n", c);

	return 0;
}

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

int main()
{
	char c = 1;
	printf("%u\n", sizeof(c));//1
	//[+c]表示进行计算
	printf("%u\n", sizeof(+c));//4
	printf("%u\n", sizeof(!c));//1
	return 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;//实际上是倒着放-->地址上是：44332211
	char *pc = (char*)&a;
	*pc = 0;//实际上是将首元素位置上的值修改为:00
	printf("%x\n", a);//11223300
	return 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     7
	b = ++c, c++, ++a, a++;//c=8 a=8 b=7
	b += a++ + c;//b=b+(a++)+c=7+8+8=23
	printf("a = %d b = %d c = %d\n:", a, b, c);//9 23 8
	return 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和一个0
	int 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;
}