本文详细介绍了C语言中的操作符，包括算术操作符、移位操作符（左移和右移）、位操作符（按位与、按位或、按位异或）、赋值操作符、单目操作符、关系操作符、逻辑操作符、条件操作符、逗号表达式、下标引用、函数调用和结构成员。还探讨了表达式求值过程中的类型转换、操作符优先级和求值顺序，以及一些实践中的例子和注意事项。
目录
1.操作符分类
- 算术操作符
- 移位操作符
- 位操作符
- 赋值操作符
- 单目操作符
- 关系操作符
- 逻辑操作符
- 条件操作符
- 逗号表达式
- 下标引用、函数调用和结构成员
2.算术操作符
+ - * / %
1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。
3. 移位操作符
- << 左移操作符
2. >> 右移操作符
3.1左移操作符
左边抛弃、右边补0
3.2右移操作符
首先右移运算分两种：
- 逻辑移位
左边用0填充，右边丢弃 - 算术移位
左边用原该值的符号位填充，右边丢弃
注意：
- 整数在内存中存的补码
- 正数的原码、反码、补码相同
- 负数补码是原码符号位不变，其余按位取反形成反码，反码+1就是补码
- 对于移位运算符，不要移动负数位，这个是标准未定义的。
4. 位操作符
& //按位与
| //按位或
^ //按位异或
注：他们的操作数必须是整数。
4.1 按位与&
int a = 3;
//00000000000000000000000000000011
int b = -2;
//10000000000000000000000000000010
//11111111111111111111111111111101
//11111111111111111111111111111110
int c = a & b;
//00000000000000000000000000000011 //3
//11111111111111111111111111111110 //-2
//00000000000000000000000000000010 //2
printf("%d\n", c);//%d 有符号打印c的值，以有符号的形式
4.2 按位或|
int a = 3;
//00000000000000000000000000000011
int b = -2;
//10000000000000000000000000000010
//11111111111111111111111111111101
//11111111111111111111111111111110
int c = a | b;
//00000000000000000000000000000011 //3
//11111111111111111111111111111110 //-2
//11111111111111111111111111111111 //-1
printf("%d\n", c);//%d 有符号打印c的值，以有符号的形式
4.3按位异异或^
int a = 3;
//00000000000000000000000000000011
int b = -2;
//10000000000000000000000000000010
//11111111111111111111111111111101
//11111111111111111111111111111110
int c = a ^ b;
//00000000000000000000000000000011 //3
//11111111111111111111111111111110 //-2
//11111111111111111111111111111101 //是多少呢？？？求一下
//补码 11111111111111111111111111111101
//反码 11111111111111111111111111111100
//原码 10000000000000000000000000000011 //就是-3
printf("%d\n", c);//%d 有符号打印c的值，以有符号的形式
4.4交换两个数的值，不创建临时变量
int a = 3;
int b = 5;
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);
上面代码当数很大时，会出问题。
int a = 3;
int b = 5;
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);
5. 赋值操作符
赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。
5.1符合操作符
+= -= *= /= %=
>>= <<= &= |= ^=
6. 单目操作符
6.1 单目操作符介绍
! 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof 操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
-- 前置、后置--
++ 前置、后置++
* 间接访问操作符(解引用操作符) (类型) 强制类型转换
int a = -10;
int* p = NULL;
printf("%d\n", !2);
printf("%d\n", !0);
a = -a;
p = &a;
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
printf("%d\n", sizeof a);//这样写行不行？
//printf("%d\n", sizeof int );//这样写行不行？不行,对于类型加括号()
6.2 sizeof 和 数组
sizeof内部的表达式不参与运算
int main()
{
int a = 5;
short s = 10;
printf("%d\n", sizeof(s = a + 2));//int 4字节 short 2字节
//sizeof内部的表达式不参与运算
printf("%d\n", s);
return 0;
}
#include <stdio.h>
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//(2)
}
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));//(1)
printf("%d\n", sizeof(ch));//(3)
test1(arr);
test2(ch);
return 0; }
问：
（1）、（2）两个地方分别输出多少？
40 4
（3）、（4）两个地方分别输出多少？
10 4
//++和--运算符
//前置++和--
#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; }
7. 关系操作符
=
<
<=
!= 用于测试“不相等”
== 用于测试“相等”
8. 逻辑操作符
&& 逻辑与
|| 逻辑或
区分逻辑与和按位与
区分逻辑或和按位或
1&2----->0
1&&2---->1
1|2----->3
1||2---->1
练习
#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=0，逻辑与都为0.后面不执行
故只有a加1为1，故结果为a=1，b=2，c=3，d=4
9. 条件操作符
exp1 ? exp2 : exp3
if (a > 5)
b = 3;
else
b = -3;
转换成条件表达式，是什么样？
a>5? 3:-3
10. 逗号表达式
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果
int a = 1;
int b = 2;
int c = (a > b, a = b + 10, a, b = a + 1);//逗号表达式
printf("%d", c);
//代码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) {
//业务处理
}
11. 下标引用、函数调用和结构成员
1.[ ] 下标引用操作符
操作数：一个数组名 + 一个索引值
int arr[10];//创建数组
arr[9] = 10;//实用下标引用操作符。
[ ]的两个操作数是arr和9。
2.( ) 函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数.
3.访问一个结构的成员
**. 结构体.成员名
-> 结构体指针->成员名**
#include <stdio.h>
struct Stu
{
char name[10];
int age;
char sex[5];
double score; }；
void set_age1(struct Stu stu) {
stu.age = 18; }
void set_age2(struct Stu* pStu) {
pStu->age = 18;//结构成员访问
}
int main()
{
struct Stu stu;
struct Stu* pStu = &stu;//结构成员访问
stu.age = 20;//结构成员访问
set_age1(stu);
pStu->age = 20;//结构成员访问
set_age2(pStu);
return 0; }
12. 表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。
12.1 隐式类型转换
C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度，一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。
int main()
{
char a = 3;//1byte=8bit
//00000000000000000000000000000011
//00000011 --a
char b = 127;
//00000000000000000000000001111111
//01111111 --b
//a和b都是char类型，大小都是1个字节，所以计算进行整型提升
//00000011 --a
//01111111 --b
//对a，b整型提升
//00000000000000000000000000000011 --a
//00000000000000000000000001111111 --b
//00000000000000000000000010000010 --c
char c = a + b;
//10000010 --c
//对c进行整型提升
//11111111111111111111111110000010 补码
//10000000000000000000000001111110 原码
//-126
printf("%d\n", c);
return 0;
}
int main()
{
char a = 0xb6;//11111111111111111111111111010110
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 的结果是真.
所程序输出的结果是:
int main()
{
char c = 1;
printf("%u\n", sizeof(c));
printf("%u\n", sizeof(+c));
printf("%u\n", sizeof(-c));
return 0; }
c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字节.
12.2 算术转换
如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。
long double
double
float
unsigned long int
long int
unsigned int
int
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
12.3 操作符的属性
复杂表达式的求值有三个影响的因素。
- 操作符的优先级
- 操作符的结合性
- 是否控制求值顺序。
两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
操作符优先级：
int main()
{
int a = 1;
int d = 0;
d = (++a) + (++a) + (++a);
printf("%d\n", d);
return 0;
}
上面的代码在不同的编译器上运行的结果可能不同。
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(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。
函数的调用先后顺序无法通过操作符的优先级确定。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
