admin管理员组文章数量:1794759
操作符详解，超详细的介绍操作符的作用与功能和注意事项
1.操作符分类
算术操作符 位移操作符 位操作符 赋值操作符 单目操作符 关系操作符 逻辑操作符 条件操作符 逗号操作符 下标引用、函数调用和结构体成员操作符
2.算术操作符
代码语言：javascript代码运行次数：0运行复制+ - * / %- 除
%操作符外，其他的4个操作符都是可以作用于整数和浮点数。即取模的操作符的两端必须都是整数。 - 对于
/操作符如果两个操作数都为整数，执行整数除法。而有浮点数执行的就是浮点数除法 %操作符的两个操作符必须为整数。返回的是整数之后的余数
程序当中的二进制位
程序的最底层都是二进制位，在C语言中也不例外。数与数的运算都是以二进制位运算的，以正整数15为例，它的二进制表达为：00000000 00000000 00000000 00001111。同时二进制有三种表达形式。 整数的二进制表达形式：
原码 反码 补码。
正整数的原 反 补码是相同的 负整数的原 反 补码是要计算的 计算负整数的反码与补码 负数的反码等于原码的符合位不变，其他位按位取反得到的就是反码 补码等于反码加1
代码语言：javascript代码运行次数：0运行复制以-15为例
-15的原码为 10000000 00000000 00000000 00001111
-15的补码为 11111111 11111111 11111111 11110000
-15的补码为 11111111 11111111 11111111 11110001什么是符号位 符号位就是在整数的进制位最左侧的一位为符号位，1表示负数 0表示正数。 补码的作用 在计算机中的运算都是围绕着补码来计算的。 在内存中存储的是补码，计算也是用的补码
3.移位操作符
代码语言：javascript代码运行次数：0运行复制<< 左移操作符
>> 右移操作符
//移位操作符的操作数只能是整数3.1 左移操作符
左边抛弃、右边补0
在num没有被赋值的情况下，自身的值不会改变。
3.2 右移操作符
规则
右移运算有两种规则： > 1.逻辑移位 > 左边用0填充，右边抛弃 > 2.算术移位 > 左边用原该值的符号位填充，右边抛弃
C语言没有明确规定是算术右移还是符号右移，一般编译器上采用的是算术右移
代码语言：javascript代码运行次数：0运行复制#include <stdio.h>
int main()
{
int num = -1;
int b = num >> 1;
printf("%d\n", b);
return 0;
}
//打印结果 -1注意：对于移位操作符，不能移动负数位，这是标准为定义行为
代码语言：javascript代码运行次数：0运行复制//错误写法
int num = 10;
num>>-1;//error4.位操作符
位操作符：
代码语言：javascript代码运行次数：0运行复制& //按位与
| //按位或
^ //按位异或
//以上操作符的操作数必须是整数位操作符也是对二进制进行操作的，且为双目操作符 &的作用就是将，两个二进制位的补码，对应位置有0为0，两个同时为1才是1.
代码语言：javascript代码运行次数：0运行复制1&2
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
结果
00000000 00000000 00000000 00000000|的作用就是将，两个二进制位的补码，对应位置有1为1，两个同时为0才是0.
代码语言：javascript代码运行次数：0运行复制1|2
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
结果
00000000 00000000 00000000 00000011^的作用就是将，两个二进制位的补码，对应位置相同为0，不同为1.
代码语言：javascript代码运行次数：0运行复制1^2
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
结果
00000000 00000000 00000000 00000011练习：
代码语言：javascript代码运行次数：0运行复制#include <stdio.h>
int main()
{
int num1 = 1;
int num2 = 2;
printf("%d\n",num1&num2);
printf("%d\n",num1|num2);
printf("%d\n",num1^num2);
return 0;
}
//打印结果
/*
0
3
3
*/练习
代码语言：javascript代码运行次数：0运行复制在不能创建临时变量（第3个变量）的情况下，实现两个数的交换
//代码1
#include <stdio.h>
int main()
{
int a = 5;
int b = 3;
a = a^b;
b = a^b;
a = a^b;
printf("a = %d,b = %d",a,b);
return 0;
}
//代码2
#include <stdio.h>
int main()
{
int a = 5;
int b = 3;
a = a-b;
b = a+b;
a = b-a;
printf("a = %d,b = %d\n",a,b);
return 0;
}练习
代码语言：javascript代码运行次数：0运行复制编写代码实现：求一个整数存储在内存中的二进制中的1的个数
#include <stdio.h>
int main()
{
int a = 0;
scanf("%d",&a);
int num = 1;
int count = 0;
for(int i = 0;i<32;++i)
{
num = 1<<i;
if(a&num)
{
count++;
}
}
printf("%d\n",count);
return 0;
}5.赋值操作符
代码语言：javascript代码运行次数：0运行复制int weight = 120;
weight = 89;
double salary = 10000.0;
salary = 20000.0;//赋值操作符可以连续使用，比如
int a = 10;
int b = 20;
int c = 30;
a = b = c = 50;//连续赋值
//推荐使用分开赋值，代码更简单，调试也很方便复合赋值符
+= -= *= /= %= >>= <<= &= |= ^=
这些运算符都可以写成复合的效果
6.单目操作符
6.1 介绍单目操作符
代码语言：javascript代码运行次数：0运行复制! 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof 操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
-- 前置、后置--
++ 前置、后置++
* 间接访问操作符（解引用操作符）
(类型) 强制类型转化* 通过指针变量中存放的地址，找到指向的空间（内容）
代码语言：javascript代码运行次数：0运行复制#include <stdio.h>
int main()
{
int a = 1;
int* pa = &a;
a = -a;
printf("%d\n",sizeof(a));
printf("%d\n",sizeof a);
printf("%d\n",sizeof(int));
printf("%d\n",sizeof int);//错误写法，对应类型计算要加()
return 0;
}6.2 sizeof和数组
代码语言：javascript代码运行次数：0运行复制#include <stdio.h>
void test1(int arr[10])
{
printf("%d\n",sizeof(arr));
}
void test2(char ch[10])
{
printf("%d\n",sizeof(ch));
}
int main()
{
int arr[10] = {0};
char ch[10] = {0};
printf("%d\n",sizeof(arr));
printf("%d\n",sizeof(ch));
test1(arr);
test2(ch);
return 0;
}
//打印结果
/*
40
10
4/8
4/8
*///关于前置++ 后置++与前置-- 后置--
#include <stdio.h>
int main()
{
int a = 10;
int x = ++a;
//a先自增1，然后再用a对x赋值
int y = a++;
//先用a赋值y，然后a再自增1
return 0;
}7.关系操作符
代码语言：javascript代码运行次数：0运行复制>
>=
<
<=
!= 不等于
== 等于注意== 和 = 的区分
8.逻辑操作符
代码语言：javascript代码运行次数：0运行复制&& 逻辑与
|| 逻辑或区分逻辑与和按位与 区分逻辑或和按位或 练习
代码语言：javascript代码运行次数：0运行复制//代码1
#include <stdio.h>
int main()
{
int i = 0,a = 0,b = 2,c = 3,d = 4;
i = a++&&++b&&d++;
printf(" a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d);
return 0;
}
//打印结果
/*
a = 1
b = 2
c = 3
d = 4
*/
//代码1
#include <stdio.h>
int main()
{
int i = 0,a = 0,b = 2,c = 3,d = 4;
i = a++||++b||d++;
printf(" a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d);
return 0;
}
//打印结果
/*
a = 1
b = 3
c = 3
d = 4
*/对于多个&&连接的一个式子，从左到右当出现一个表达式为假时，此时该条式子已经为假，计算机便不要再往右计算。 对于多个||连接的一个式子，从左到右当出现一个表达式为真时，此时该条式子已经为真，计算机便不要再往右计算。
9.条件操作符
代码语言：javascript代码运行次数：0运行复制exp1?exp2:exp3
//当exp1为真时执行exp2反之执行exp3if(a>5)
b = 3;
else
b = -3;
//利用条件操作符简化
b = a>5?3:-310.逗号表达式
代码语言：javascript代码运行次数：0运行复制exp1,exp2,exp3,...expn逗号表达式，就是用逗号隔开的多个表达式。 逗号表达式，c从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
代码语言：javascript代码运行次数：0运行复制a = get_val();
count_val(a);
while(a>0)
{
//.....
a = get_val();
count_val(a);
}
//利用逗号表达式
while(a = get_val(),count_val(a),a>0)
{
//.....
}11.下标引用、函数调用和结构成员
1.[] 下标引用操作符 操作数：一个数组名+一个索引值
代码语言：javascript代码运行次数：0运行复制int arr[10] = {0};
arr[9] = 10;
//[]的两个操作数是arr和9。
//数组也是有类型的，去掉名字就是数组类型，如int arr[10] = {0};类型为：int [10]2.（）函数调用操作符 接受一个或者多个操作符：第一个操作数是函数名，剩余的操作数就是传递给函数的参数
代码语言：javascript代码运行次数：0运行复制#include <stdio.h>
void test1()
{
printf("hahaha\n");
}
void test2(const char* str)
{
printf("%s\n",str);
}
int main()
{
test1();
test2("hello!");
}3.访问一个结构的成员
代码语言：javascript代码运行次数：0运行复制.结构体.成员名 -> 结构体指针->成员名
#include <stdio.h>
struct stu
{
char name[10];
int age;
char sex[5];
};
int main()
{
struct stu s;
struct stu* ps;
ps = &s;
s.age = 17;
s.name = Yui;
s.sex = female;
ps->age = 18;
ps->name = Yui;
s->sex = female;
}12.表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定的。 同样，有些表达式的操作符在求值的过程中可能需要转换类型为其他类型。
12.1隐式类型转换
C的整型算术总是至少以缺省整型类型的精度来进行的。 为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升 整型提升的意义：
代码语言：javascript代码运行次数：0运行复制表示式的整型要在CPU的相应运算器执行，CPU内整型运算器（ALU）的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。 因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。 通用CPU是难以直接实现两个8比特字节直接相加运算（虽然机器指令可能有这种字节相加的指令）。所以，表达式中的各种长度可能小于int长度的整型值，都必须先转换为int或者unsigned int ，然后才能送入CPU去执行。
//实例1
char a,b,c;
...
a = b+c;b和c的值被提升为普通整型，然后再执行加法运算。 加法完成后，结果将被截断，然后再存储于a当中。 然后进行整型提升
代码语言：javascript代码运行次数：0运行复制整型提升是按照变量的数据类型的符合位来提升的。
#include <stdio.h>
int main()
{
//负数的整型提升
char c1 = -1;
//变量c1的二进制位（补码）中只有8个比特位
//11111111
//因为char为符合的char
//所以在整型提升的时候，高位补充符合位，即为1
//提升后的结果：
//11111111 11111111 11111111 11111111
char c2 = 1;
//变量c2的二进制位（补码）中只有8个比特位
//00000001
//因为char为符合的char
//所以在整型提升的时候，高位补充符合位，即为1
//提升后的结果：
//00000000 00000000 00000000 00000001
//无符号整型提升，高位补0
}#include <stdio.h>
int main()
{
char c = 1;
printf("%u\n",sizeof(c));
printf("%u\n",sizeof(+c));
printf("%u\n",sizeof(-c));
return 0;
}
//打印结果
/*
1
4
4
*/该实例中，c只要参加表达式运算，就会发生整型提升，所以在执行+c/-c的过程中就有整型提升。变为整型4个字节
12.2 算术转换
如果某个操作符的各个操作符属于不同的类型，那么除非其中一个操作数的转换位另一个操作数的类型，否则就无法计算。下面的层次体系称为寻常算术转换。
代码语言：javascript代码运行次数：0运行复制long double
double
float
unsigned long int
long int
unsigned int
int如果，某个操作数的类型在上面这个列表的排名较低，那么首先要转换位另一个操作数的类型后执行运算。 注意： 算术转换要合理，不然可能会有精度丢失等一些问题。
代码语言：javascript代码运行次数：0运行复制float f = 3.14;
int num = f;//隐式转换，会有精度丢失12.3操作符的属性
复杂表达式的求值有3个影响因素。
- 操作符的优先级
- 操作符的结合性
- 是否控制求值顺序 两个相邻的操作符先执行哪个，取决于它们的优先级。如果两者优先级相同，取决于它们的结合性。
操作符优先级
操作符 | 描述 | 用法示例 | 结果类 型 | 结合性 | 是否控制求值 顺序 |
|---|---|---|---|---|---|
（） | 聚组 | （表达式） | 与表达式同 | N/A | 否 |
（） | 函数调用 | rexp（rexp，…,rexp） | rexp | L-R | 否 |
[ ] | 下标引用 | rexp[rexp] | lexp | L-R | 否 |
. | 访问结构成员 | lexp.member_name | lexp | L-R | 否 |
-> | 访问结构指针成员 | rexp->member_name | lexp | L-R | 否 |
++ | 后缀自增 | lexp ++ | rexp | L-R | 否 |
– | 后缀自减 | lexp – | rexp | L-R | 否 |
! | 逻辑反 | ! rexp | rexp | R-L | 否 |
~ | 按位取反 | ~ rexp | rexp | R-L | 否 |
+ | 单目，表示正值 | + rexp | rexp | R-L | 否 |
- | 单目，表示负值 | - rexp | rexp | R-L | 否 |
++ | 前缀自增 | ++ lexp | rexp | R-L | 否 |
– | 前缀自减 | – lexp | rexp | R-L | 否 |
* | 间接访问 | * rexp | lexp | R-L | 否 |
& | 取地址 | & lexp | rexp | R-L | 否 |
sizeof | 取其长度，以字节 表示 | sizeof rexp sizeof(类型) | rexp | R-L | 否 |
(类型） | 类型转换 | (类型) rexp | rexp | R-L | 否 |
* | 乘法 | rexp * rexp | rexp | L-R | 否 |
/ | 除法 | rexp / rexp | rexp | L-R | 否 |
% | 整数取余 | rexp % rexp | rexp | L-R | 否 |
+ | 加法 | rexp + rexp | rexp | L-R | 否 |
- | 减法 | rexp - rexp | rexp | L-R | 否 |
<< | 左移位 | rexp << rexp | rexp | L-R | 否 |
>> | 右移位 | rexp >> rexp | rexp | L-R | 否 |
> | 大于 | rexp > rexp | rexp | L-R | 否 |
>= | 大于等于 | rexp >= rexp | rexp | L-R | 否 |
< | 小于 | rexp < rexp | rexp | L-R | 否 |
<= | 小于等于 | rexp <= rexp | rexp | L-R | 否 |
操作 符 | 描述 | 用法示例 | 结果类 型 | 结合 性 | 是否控制求值 顺序 |
== | 等于 | rexp == rexp | rexp | L-R | 否 |
!= | 不等于 | rexp != rexp | rexp | L-R | 否 |
& | 位与 | rexp & rexp | rexp | L-R | 否 |
^ | 位异或 | rexp ^ rexp | rexp | L-R | 否 |
| | 位或 | rexp | rexp | rexp | L-R | 否 |
&& | 逻辑与 | rexp && rexp | rexp | L-R | 是 |
| | 逻辑或 | rexp | rexp | rexp | L-R | 是 |
? : | 条件操作符 | rexp ? rexp : rexp | rexp | N/A | 是 |
= | 赋值 | lexp = rexp | rexp | R-L | 否 |
+= | 以…加 | lexp += rexp | rexp | R-L | 否 |
-= | 以…减 | lexp -= rexp | rexp | R-L | 否 |
*= | 以…乘 | lexp *= rexp | rexp | R-L | 否 |
/= | 以…除 | lexp /= rexp | rexp | R-L | 否 |
%= | 以…取模 | lexp %= rexp | rexp | R-L | 否 |
<<= | 以…左移 | lexp <<= rexp | rexp | R-L | 否 |
>>= | 以…右移 | lexp >>= rexp | rexp | R-L | 否 |
&= | 以…与 | lexp &= rexp | rexp | R-L | 否 |
^= | 以…异或 | lexp ^= rexp | rexp | R-L | 否 |
|= | 以…或 | lexp |= rexp | rexp | R-L | 否 |
， | 逗号 | rexp，rexp | rexp | L-R | 是 |
a*b+c*d+e*f代码语言：javascript代码运行次数：0运行复制在上面的代码当中，由于*比+的优先级高，只能保证，*的计算比+早，但是优先级并不能决定第三个*比第一个+早执行。
//计算机的计算顺序可能是
a*b
c*d
a*b+c*d
e*f
a*b+c*d+e*f
//或者
a*b
c*d
e*f
a*b+c*d
a*b+c*d+e*f再看一段代码
代码语言：javascript代码运行次数：0运行复制c + --c代码语言：javascript代码运行次数：0运行复制操作符的优先级只能决定自减–的运算在+的运算前面，但是我们并没有办法得知，+的操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧意的。
//非法表达式
int main()
{
int i = 10;
i = i-- - --i * (i=-3) * i++ + ++i;
printf("i = %d\n",i);
return 0;
}本段代码出在《C与指针》。该书的作者尝试了市面上所有的主流编译器，得到的答案却都不相同。所以这段代码没有实际的意义。 总结： 我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那么这个表达式就是存在问题的。
完
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。 原始发表：2024-07-09，如有侵权请联系 cloudcommunity@tencent 删除变量二进制计算机指针int本文标签： 操作符详解，超详细的介绍操作符的作用与功能和注意事项
版权声明：本文标题：操作符详解，超详细的介绍操作符的作用与功能和注意事项 内容由林淑君副主任自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：http://www.xiehuijuan.com/baike/1754817797a1706847.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论