目录：
1. 操作符分类：
算术操作符
移位操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号表达式
下标引用、函数调用和结构成员
2. 算术操作符
+ - * / %
下表显示了 C 语言支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
- 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
- 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
- % 操作符的两个操作数必须为整数。返回的是整除之后的余数。
3. 移位操作符
左移操作符 <<
右移操作符 >>
注：移位操作符的操作数只能是整数。
位移操作符移动的是二进制
为了跟好地进行位移操作符的讲解，这里我们需要对进制有初步的了解
关于移位操作符，需要认识源码，反码，补码，从而对移位操作进行深度理解：
3.1 左移操作符
移位规则：
左边抛弃、右边补0
3.2 右移操作符
移位规则：
首先右移运算分两种：
- 逻辑移位
左边用0填充，右边丢弃- 算术移位
左边用原该值的符号位填充，右边丢弃
具体采用哪种移位，取决于编译器，一般编译器采用算数移位
警告⚠ ：
对于移位运算符，不要移动负数位，这个是标准未定义的。
例如
int num = 10;
num>>-1;//error
4. 位操作符
注：1.为操作符的操作数必须是整数。
2.位操作符作用于二进制数列
| 位操作符 | 名称 | 作用 |
|---|---|---|
| & | 按位与 | 有0则0，同1则1 |
| | | 按位或 | 有1则1 |
| ^ | 按位异或 | 相同为0，相异为1 |
按位与示例：
按位或示例：
按位异或示例：
不能创建临时变量（第三个变量），实现两个数的交换
一种巧妙的算法
如上算法存在缺陷，a+b若太大会溢出，下面让我们使用异或操作符来实现：
需要用到：
1.相同为0，0与任何数异或结果都为这个数
2.异或支持交换律
//3^3 = 0
//5^5=0
//3^5=6
//3^5^5=3
//3^5^3=5
//
//000
//011
//011
//011
//101
//110
//a^a=0
//0^a=a
//异或是支持交换律
//3^5^3
//3^3^5
//
int main()
{
int a = 3;
int b = 5;
a = a ^ b;
b = a ^ b;//b=a ^ b ^ b
a = a ^ b;//a^b^a
//a = a + b;
//b = a - b;
//a = a - b;
printf("a=%d b=%d\n", a, b);
return 0;
}
练习：
编写代码实现：求一个整数存储在内存中的二进制中1的个数。
参考代码：
//方法1
#include <stdio.h>
int count_bit( int m)
{
int count = 0;
while (m)
{
if (m % 2 == 1)
count++;
m /= 2;
}
return count;
}
int main() {
int n = 0;
scanf("%d", &n);
int num = count_bit(n);
printf("%d\n", num);
return 0;
}
这种方法明显是有错误的，如果输入的是负数，无法输出正确的值，因此我们可以联想到无符号
int count_bit(unsigned int m)
若将上述函数的自定义声明改为这个，则可以避免上述问题的出现。
接下来我们运用操作符实现这个程序：
//方法2：
#include <stdio.h>
int count_bit(n)
{
int i = 0;
int count = 0;
for (i = 0; i < 32; i++)
{
if (1 == ((n >> i) & 1))
count++;
}
return count;
}
int main()
{
int n = 0;
scanf("%d", &n);
int num = count_bit(n);
printf("%d\n", num);
return 0;
}
还能不能更加优化，上述两种方式都必须循环32次。
//方法3：
int count_bit(int m)
{
int count = 0;
while (m)
{
m = m & (m - 1);
count++;
}
return count;
}
int main() {
int n = 0;
scanf("%d", &n);
int num = count_bit(n);
printf("%d\n", num);
return 0;
}
//n=11
//n = n&(n-1)
//1011 - n
//1010 - n-1
//1010 - n
//1001 - n-1
//1000 - n
//0111 - n-1
//0000 - n
//根据上述规律可知，有几个n&(n-1)就有多少个1
这种方式很好，达到了优化的效果，但是难以想到。
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 x = 10;
x = x+10;
x += 10;//复合赋值
//其他运算符一样的道理。这样写更加简洁。
6. 单目操作符
6.1 单目操作符介绍
! 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof 操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
– 前置、后置–
++ 前置、后置++
* 间接访问操作符(解引用操作符) (类型) 强制类型转换
- ！举例
int main()
{
int flag = 0;
//if (!flag)
if(flag == 0)
{
printf("hehe\n");
}
return 0;
}
- &和解引用操作符的举例
int main()
{
int a = 10;
char c = 0;
// printf("%p\n", &a);//取出地是二进制数列
// printf("%p\n", &c);
int* pa = &a;//& - 取地址操作符 pa是指针变量 int*是类型
//*pa = 20;//* - 解引用操作符 把a拿出来进行赋值
*pa = 20;
return 0;
}
- sizeof操作符举例
int main()
{
short s = 10;
int a = 2;
s = a + 5;
printf("%zu\n", sizeof(s = a + 5));//输出结果为2，sizeof（）内部放的表达式不会计算
printf("%d\n", s);//，输出结果为10
int a = 10;
int* p;
int arr[10];
printf("%zu\n", sizeof(a));//int 4
printf("%zu\n", sizeof a);//int 4
printf("%zu\n", sizeof(int));//int 4
//printf("%zu\n", sizeof int);//err
printf("%zu\n", sizeof(p));//int* 4
printf("%zu\n", sizeof(arr));//int [10] 40
printf("%zu\n", sizeof(arr[10]));//int 4
return 0;
}
⭐️ 这里需要注意的是sizeof（数组名）是指数组整体的类型长度，而不是数组首元素的类型长度，sizeof（）内部放的表达式不会计算。
- 原理：
在文件转向可执行程序的时候在编译阶段，编译器就进行了判断，进行了截断把后面括号中两个字节的内容给了short类型
- ~按位取反操作符
- 代码与原理展示：
int main()
{
int a = 0;
/*00000000000000000000000000000000 - ~按位取反
11111111111111111111111111111111 - 内存中-补码
11111111111111111111111111111110 -反码（补码减1）
10000000000000000000000000000001 -源码（反码符号位不变其他位按位取反）
-1*/
printf("%d\n", ~a);
return 0;
}
上面的内容仅仅是铺垫，相信看完下面的内容你会对~（按位取反操作符）有更加深入的了解
int main()
{
int a = 10;
int n = 0;
scanf("%d", &n);
//把a的第n位置为1
a = a | (1 << (n-1));
printf("a=%d\n", a);
//把a的第n位置为0
a = a & ~(1 << (n - 1));
printf("a=%d\n", a);
//00000000000000000000000000001010
//00000000000000000000000000010000
//1<<2;
//00000000000000000000000000011010
//11111111111111111111111111101111
//00000000000000000000000000010000
//00000000000000000000000000001010
return 0;
}
6.2 sizeof 和 数组
#include <stdio.h>
void test1(int arr[]) {
printf("%d\n", sizeof(arr));//(结果4)
}
void test2(char ch[]) {
printf("%d\n", sizeof(ch));//(结果4)
}
int main() {
int arr[10] = { 0 };
char ch[10] = { 0 };
printf("%d\n", sizeof(arr));//(结果40)
printf("%d\n", sizeof(ch));//(结果10)
test1(arr);
test2(ch);
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型的变量时，编译器会报错，这里就需要用到强制类型转换，下面的代码中我们就运用了强制类型转换，只要认真观察区别，就可以学会
int main()
{
int a = (int)3.14;
printf("%d\n", a);
return 0;
}
这里输出的值自然为整数3
7. 关系操作符
关系操作符
>
>=
<
<=
!= 用于测试“不相等”
== 用于测试“相等”
这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。
注意：
在编程的过程中== 和=不小心写错，导致的错误。
如图，如果因为少写了等号=，如果常量放在后面，编译器会认为是赋值语句而不报错，但常量放在前面，少写了等号，编译器必然会报错。
因此，在判断变量和常量是否相等时建议使用 if(10==a);这种写法。
int main()
{
char arr[] = “abcdef”;
==不能比较2个字符串的内容，实际上比较的是2个字符串的首字符的地址,所以这样写是错误的
if (arr == “abcdef”)
{
printf(“==\n”);
}
return 0;
}
8. 逻辑操作符
逻辑操作符有哪些：
&& 逻辑与
|| 逻辑或
区分逻辑与和按位与
区分逻辑或和按位或
1&2----->0
1&&2---->1
1|2----->3
1||2---->1
逻辑与和或的特点：
若逻辑或运算符左边操作数的值为1，则就不继续执行其右边的操作数。
“&&” 同理，若左边的操作数为0，则就不继续执行其右边的操作数
int main()
{
int a = 3;
int b = 0;
if (a && b) //这里的&&仅仅判断真假，如果两边都是真，则继续执行，非0即为真
//if (a || b) //同样的，有真则为真
{
printf("呵呵\n");
}
return 0 ;
}
int main()
{
int age = 20;
18~36 青年
if (age >= 18 && age <= 36)
{
printf("青年\n");
}
int main()
{
int year = 2000;
if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
printf("闰年");//这里的&&是并且的意思 ||是或的意思
return 0;
}
360笔试题
#include <stdio.h>
int main()
{
int i = 0,a=0,b=2,c =3,d=4;
i = a++ && ++b && d++;
//i = a++||++b||d++;
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
return 0;
}
//程序输出的结果是什么？
因为a++先使用a的值，a==0，&&只要有a就为假，所以后面不会运行，自然值也不变，而a最后还要++，所以运行结果如下
这里有几个变式，如果可以都计算正确，说明该知识点已经掌握，如果没有，则需要认真思考
输出结果为2335；
运行结果为2234，因为a是1，||后面不管是几都为真，所以后面不计算直接跳过，而a还要++
结果为1334
9. 条件操作符
exp1 ? exp2 : exp3
int main()
{
int a = 3;
int b = 0;
if (a > 5)
b = 3;
else
b = -3;
return 0;
}
转换成条件表达式，是什么样？
b = ((a > 5) ? 3 : -3);
2.使用条件表达式实现找两个数中较大值。
int m = (a > b ? a : b);
10. 逗号表达式
exp1, exp2, exp3, …expN
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
c是多少？
13
//代码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)
{
//业务处理
}
通过如上代码，我们可以看出，代码3中，相对于用while循环写出的代码，用逗号表达式写出来的代码更加简洁。
11. 下标引用、函数调用和结构成员
- 1. [ ] 下标引用操作符
注意：[ ]不是定义数组时的操作符，而是在要访问数组的第某个元素时所使用的操作符
arr[4];访问数组的第5个元素，
这里的[ ]就交下标引用操作符，
操作数是arr和4
操作数：一个数组名 + 一个索引值 - 2. ( ) 函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
void test(int x, int y)
{
}
void test2()
{}
int main()
{
test2();
//操作数：test2
test(3, 4);//()函数调用操作符
//操作数：test,3,4
return 0;
}
- 3. 访问一个结构的成员
. 结构体.成员名
-> 结构体指针->成员名
//结构体成员
//书：书名 + 定价
代码演示：
struct Book
{
char name[20];
int price;
};
int main() {
struct Book sb = { "C语言", 55 };
printf("%s %d\n", sb.name, sb.price);//结构体变量.结构体成员名
struct Book* ps = &sb;
printf("%s %d\n", (*ps).name, (*ps).price);//ps指向sb，*ps找到sb
printf("%s %d\n", ps->name, ps->price);//结构体指针->结构体成员名
//->name找到了ps所指向的对象sb的name
return 0;
}
运行结果：
12. 表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。
12.1 隐式类型转换
C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度
一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长 度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转 换为int或unsigned int，然后才能送入CPU去执行运算。
如何进行整体提升呢？
整形提升是按照变量的数据类型的符号位来提升的
//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111
//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001
//无符号整形提升，高位补0
//实例1
int main()
{
char a = 5;
char b = 126;
char c = a + b;
printf("%d\n", c);
return 0;
}
b和c的值被提升为普通整型，然后再执行加法运算。
加法运算完成之后，结果将被截断，然后再存储于a中。
整形提升是按照变量的数据类型的符号位来提升的
那么上面代码的结果是不是131呢？接下来让我们来细细分析一番：
⭐️例1:
int main()
{
char a = 5;//截断
char b = 126;//截断
char c = a + b;//截断
//00000000000000000000000000000101
//00000101 - a
//00000000000000000000000001111110
//01111110 - b
//整型提升
//00000000000000000000000000000101-a
//00000000000000000000000001111110-b
//00000000000000000000000010000011
//10000011 - c
printf("%d\n", c);
//%d 十进制的方式打印有符号整数
//11111111111111111111111110000011
//11111111111111111111111110000010
//10000000000000000000000001111101
//-125
//
return 0;
}
配图解
⭐️例2:
int main()
{
char a = 0xb6;
//10110110
//
short b = 0xb600;
int c = 0xb6000000;
if (a == 0xb6)
printf("a");
if (b == 0xb600)
printf("b");
if (c == 0xb6000000)
printf("c");
return 0;
}
实例1中的a,b要进行整形提升,但是c不需要整形提升
a,b整形提升之后,变成了负数,所以表达式 a0xb6 , b0xb600 的结果是假,但是c不发生整形提升,则表
达式 c==0xb6000000 的结果是真.
需要注意的是无符号整型提升，高位直接补0
⭐️例3:
int main()
{
char c = 1;
printf("%u\n", sizeof(c));
printf("%u\n", sizeof(+c));
printf("%u\n", sizeof(-c));
return 0;
}
实例3中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字
节.表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof© ,就是1个字节
12.2 算术转换
如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运
算。
警告：
但是算术转换要合理，要不然会有一些潜在的问题
float f = 3.14;
int num = f;//隐式转换，会有精度丢失
12.3 操作符的属性
复杂表达式的求值有三个影响的因素。
- 操作符的优先级
- 操作符的结合性
- 是否控制求值顺序。
两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
操作符优先级
一些问题表达式
//表达式的求值部分由操作符的优先级决定。
//表达式1
ab + cd + e*f
注释：代码1在计算的时候，由于*比+的优先级高，只能保证，的计算是比+早，但是优先级并不
能决定第三个比第一个+早执行。
所以表达式的计算机顺序就可能是：
ab
cd
ab + cd
ef
ab + cd + ef
或者：
ab
cd
ef
ab + cd
ab + cd + ef
//表达式2
c + --c;
注释：同上，操作符的优先级只能决定自减–的运算在+的运算的前面，但是我们并没有办法得知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。
//代码3-非法表达式
int main()
{
int i = 10;
i = i-- - --i * ( i = -3 ) * i++ + ++i;
printf(“i = %d\n”, i);
return 0;
}
表达式3在不同编译器中测试结果不同
//代码4
int fun()
{
static int count = 1;
return ++count;
}
int main()
{
int answer;
answer = fun() - fun() * fun();
printf( "%d\n", answer);//输出多少？
return 0;
}
这个代码有没有实际的问题？
有问题！
虽然在大多数的编译器上求得结果都是相同的。
但是上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。
函数fun（）的调用先后顺序无法通过操作符的优先级确定。
//代码5
#include <stdio.h>
int main()
{
int i = 1;
int ret = (++i) + (++i) + (++i);
printf("%d\n", ret);
printf("%d\n", i);
return 0;
}
Linux环境的结果：
VS2013环境的结果：
看看同样的代码产生了不同的结果，这是为什么？
简单看一下汇编代码.就可以分析清楚.这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序。
总结：
我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。
希望以上内容对大家有所帮助👀，如有不足望指出🙏
扫一扫
1408
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
