学习小结
c语言操作符与表达式学习笔记汇总
//#define _CRT_SECURE_NO_WARNINGS 1
//#include<stdio.h>
//操作符详解
//操作符与表达式
//算术操作符
//int main()
//{
// int b = 0;
// int a = 5 / 2;//商2
// printf("a=%d\n", a);
// b = 5 % 2;// 1
// printf("b=%d\n", b);
// return 0;
//}
//注意：对于取模操作符% 左右两端必须都是整数
//移位操作符（移动的是二进制位）
//int main()
//{
// int a = 16;
// //>>右移操作符（右移一位有除二的效果）
// //00000000000000000000000000010000 16的二进制
// //00000000000000000000000000001000 16右移1位
// //右移操作符有两种移发
// //1、算术右移
// //右边丢弃，左边补原符号位
// //2、逻辑右移
// //右边丢弃，左边补0
// //注意：
//
// int b=a >> 1;
// printf("%d\n", b); // 8
//
// return 0;
//}
//int main()
//{
// int a = 5;
// int b = a << 1;
// //<<左移操作符（左移一位有乘二的效果）
// //右移操作符：左边丢弃，右边补0
// printf("%d\n", b);
// return 0;
//}
//对于移位操作符不要移动负数位，这个是标准未定义的
//整数的二进制表示有：原码，反码，补码（注意:一个正数的原码 补码 反码都相同）
//存储到内存的是补码
//位操作符
// & 按位与
// | 按位或
// ^ 按位异或
//注意：他们的操作符必须都是整数
//int main()
//{
// & 按二进制位与
// //int a = 3;
// //int b = 5;
// //int c = a & b;
// //printf("%d\n", c); //1
// 011 3
// 101 5
// 001 1
// // | 按二进制位或
// //int a = 3;
// //int b = 5;
// //int c = a | b;
// //printf("%d\n", c); //7
// 011 3
// 101 5
// 111 7
//
// // | 按二进制位异或(对于的二进制位如果相同为0，不同则为1)
// int a = 3;
// int b = 5;
// int c = a ^ b;
// printf("%d\n", c); //6
// //011 3
// //101 5
// //110 6
// return 0;
//}
//不创建临时变量（第三个变量），实现两个数的交换
//创建临时变量的方法
//int main()
//{
// int a = 5;
// int b = 3;
// int tmp = 0;//临时变量
// printf("交换前:a=%d b=%d\n", a, b);
// tmp = a;
// a = b;
// b = tmp;
// printf("交换后:a=%d b=%d\n", a, b);
// return 0;
//}
//加减法
//int main()
//{
// int a = 5;
// int b = 3;
// printf("交换前:a=%d b=%d\n", a, b);
// a = a + b;
// b = a - b;
// a = a - b;
// printf("交换后:a=%d b=%d\n", a, b);
// return 0;
//}
//利用按位异或的方法
//int main()
//{
// int a = 5;
// int b = 3;
// printf("交换前:a=%d b=%d\n", a, b);
// b = a ^ b;
// a = b ^ a;
// b = b ^ a;
// printf("交换后:a=%d b=%d\n", a, b);
// return 0;
//}
//编写代码，求一个整数存储在内存中二进制中1的个数
//（此代码除了负数）
//int main()
//{
// int count = 0;
// int num = 0;
// scanf("%d", &num);
// //统计num二进制的补码中有几个1，因为计算机存储中存储的是二进制补码
// while (num)
// {
// if (num % 2 == 1)
// count++;
// num = num / 2;
// }
// printf("%d\n", count);
// return 0;
//}
//int main()
//{
// int num = 0;
// int i = 0;
// int count = 0;
// scanf("%d", &num);
// for (i = 0; i < 32; i++)
// {
// if (1 == ((num >> i) & 1))
// count++;
// }
// printf("%d\n", count);
// return 0;
//}
//单目操作符
//注意：只有一个操作数
//! 逻辑反操作
//int main()
//{
// int a = 10;
// int b = 0;
// printf("%d\n", !a); //0 因为a的值是10，为真，!a就是把真变成假，假变成真
// printf("%d\n", !b); //1
// return 0;
//}
//int main()
//{
// int a = 10;
// if (!a)//意思如果a为假，进行打印
// {
// printf("hehe\n");
// }
// if (a)//意思如果a为真，进行打印
// {
// printf("haha\n");
// }
// return 0;
//}
//- 负值（不是减号）
//int main()
//{
// int a = -6;
// a = -a;
// printf("%d\n", a);//6
// return 0;
//}
//+ 正值（不是加号）
//& 取地址
//int main()
//{
// int a = 10;
// int* p = &a;//取地址操作符，c语言中指针用来存放地址的
// *p = 20;//解引用操作符，表示的是此地址的值
// printf("%d\n", a); //20
// return 0;
//}
//sizeof 操作数的类型长度（以字节为单位）,求变量在内存中的大小
//int main()
//{
// int a = 10;
// char c = 'r';
// char* p = &c;
// int arr[10] = { 0 };
// //sizoef计算的变量所占内存空间的大小，单位是字节
// printf("%d\n", sizeof(a));//4 一个整形在内存中的大小是4给字节
// printf("%d\n", sizeof(int));//4
//
// printf("%d\n", sizeof(c));//1
// printf("%d\n", sizeof(char));//1
//
// printf("%d\n", sizeof(p));//8 一个指针的大小是4个字节或者8个字节，32位操作系统是4个字节，64位操作系统是8个字节
// printf("%d\n", sizeof(char*));//8
//
// printf("%d\n", sizeof(arr));//40
// printf("%d\n", sizeof(int [10]));//40
// return 0;
//}
//int main()
//{
// short s = 0;//short在内存中只有两个的字节的内存空间
// int a = 10;
// printf("%d\n", sizeof(s=a+5));//因为是把a+5的结果放到s里面，所以最后计算内存的大小还是以s为主
// printf("%d\n", s);
// return 0;
//}
// ~ 按位取反
//int main()
//{
// int a = 0;
// //~按（二进制）位进行取反
// //00000000000000000000000000000000
// //11111111111111111111111111111111 -按位取反之后的结果 补码
// //11111111111111111111111111111110 -反码 补码减1得到反码
// //10000000000000000000000000000001 -原码 反码符号位不变按位取反得到原码
// //原码取反加1得到补码
// //计算机存储的二进制是补码
// //打印出来的二进制是原码
// printf("%d\n", ~a);//-1
// return 0;
//}
//按位取反应用的一个场景
//让11的二进制倒数第三位变成1
//int main()
//{
// int a = 11;
// a = a | (1 << 2);
// //00000000000000000000000000001011 -11的二进制
// //00000000000000000000000000000100 -按位或这个数字
// //00000000000000000000000000001111 -最终结果 15
// printf("%d\n", a);
// a = a & ~(1 << 2);
// printf("%d\n", a);
// return 0;
//}
//++前置加加，后置加加++
//int main()
//{
// int a = 10;
// int b = 10;
// printf("%d\n", ++a);//前置++ 规则：先++，后使用 11
// printf("%d\n", b++);//后置++ 规则：先使用，后++ 10
// printf("%d\n", b);//11
// return 0;
//}
//(类型) 强制类型转换
//强制类型转换是把变量从一种类型转换为另一种数据类型
//int main(O)
//{
// //int a = 3.14;// warning C4244: “初始化”: 从“double”转换到“int”，可能丢失数据
// int a = (int)3.14;//无警告
// return 0;
//}
//关系操作符
//> 大于
//>= 大于等于
//< 小于
//<= 小于等于
//!= 不等于
//== 等于
//注意：要区分出 == 与 = 的区别，=是赋值操作符
//逻辑操作符
//对真假进行判断
//&& 逻辑与（并且） 两个为真，最后的结果才为真，否则假
//|| 逻辑或（或者） 只有有一个为真，最后就是真
//int main()
//{
// //int a = 3;
// //int b = 5;
// //int c = a && b;
// //printf("%d\n", c);//1
// //int a = 0;
// //int b = 3;
// //int c = a && b;
// //printf("%d\n", c);//0
// //int a = 0;
// //int b = 3;
// //int c = a || b;
// //printf("%d\n", c);//1
// //return 0;
//}
//条件操作符(三目操作符)
//exp1? exp2: exp3
//如果exp1的表达式为真，执行exp2的表达式，表达式2的结果是整个表达式的结果；如果为假，执行exp3的表达式，表达式3的结果为整个表达式的结果
//int main()
//{
// //int a = 0;
// //int b = 0;
// //if (a > 5)
// // b = 3;
// //else
// // b = -3;
// //把上边的代码用三目操作符表示
// int a = 0;
// int b = 0;
// scanf("%d", &a);
// b = (a > 5 ? 3 : -3);
// printf("%d\n", b);
// return 0;
//}
//逗号表达式
//逗号表达式，就是用逗号隔开的多个表达式。
//逗号表达式，从左到右依次执行，整个表达式的结果是最后一个表达式的结果
//int main()
//{
// int a = 1;
// int b = 2;
// int c = (a > b, a = b + 10, a, b = a + 1);
// printf("%d\n", c);//13
// return 0;
//}
//下标引用操作符
//注意：只要有操作符就有操作数
//操作数：数组名[索引值]
//int main()
//{
// int a[10] = { 0 };
// a[4] = 10;//为a数组的第五个元素更改为10
// return 0;
//}
//函数调用操作符 ()
//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("最大值为：%d", max);
// return 0;
//}
//访问一个结构的成员
// .结构体
// -> 结构体指针操作符
//创建了一个结构体类型， 类型名为 struct Stu
//struct Stu
//{
// char name[20];
// int age;
// char id[20];
//};
//int main()
//{
// //使用struct Stu这个类型创建了一个学生对象，并初始化
// struct Stu s1 = { "张三",20,"20220302" };
// struct Stu* p = &s1;
// // -> 箭头是结构体指针操作符
// //printf("%s\n", p->name);
// //printf("%d\n", p->age);
// //写法：结构体指针->成员名
// //printf("%s\n", (*p).name);
//
// //printf("%s\n", s1.name);
// //printf("%d\n", s1.age);
// //printf("%s\n", s1.id);
// //写法：结构体变量.成员名
// return 0;
//}
//表达式求值
//1、隐式类型转换
//为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整形，这种被成为整形提升
//注意：整形提升是按照变量的数据类型的符号位来提升的
//int main()
//{
// char a = 3;
// //00000000000000000000000000000011
// //因为char类型只能存放一个字节，所以要截断，从最低位开始截断
// //00000011 a
// char b = 127;
// //00000000000000000000000001111111
// //01111111 b
// char c = a + b;
// //整形提升a和b
// //按照变量的数据类型的符号位来提升的
// //00000000000000000000000000000011 a
// //00000000000000000000000001111111 b
// //00000000000000000000000010000010
// //因为c是char类型，所以截断
// //10000010 c
// //11111111111111111111111110000010 c的补码
// //11111111111111111111111110000001 反码
// //10000000000000000000000001111110 原码 -126
// printf("%d\n", c);//-126
// return 0;
//}
//有整形提升
//int main()
//{
// char a = 0xb6;
// printf("%d\n", a); //-74
// if (a == -74)
// printf("hehe\n");
// return 0;
//}
//2、算数转换
//如果某个操作符的各个操作数属于不同的类型，
//那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。
//long double
//double
//float
//unsigned long int
//long int
//unsigned int
//int
//如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算
//操作符的属性
//1、操作符的优先级
//两个相邻操作符的执行顺序，取决于他们的优先级。若两者优先级相同，则取决于结合性
以上代码均在vs2022环境下编译