操作符是计算的基础，正所谓基础不牢，地动山摇，这篇文章就是为了巩固操作符量身定做

操作符详解

1.操作符分类
2.算术操作符
3.移位操作符
- 3.1左移操作符
- 3.2右移操作符
[4. 位操作符](#4. 位操作符)
- 4.1练习
5.赋值操作符
[6. 单目操作符](#6. 单目操作符)
7.关系操作符
[8. 逻辑操作符](#8. 逻辑操作符)
[9. 条件操作符](#9. 条件操作符)
[10. 逗号表达式](#10. 逗号表达式)
[11. 下标引用、函数调用和结构成员](#11. 下标引用、函数调用和结构成员)
[12. 表达式求值](#12. 表达式求值)
- [12.1 隐式类型转换](#12.1 隐式类型转换)
- [12.2 算术转换](#12.2 算术转换)
- 12.3操作符优先级

1.操作符分类

算术操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

下标引用、函数调用和结构成员

2.算术操作符

＋－ * / %

除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。

对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。

% 操作符的两个操作数必须为整数。返回的是整除之后的余数。

3.移位操作符

左移操作符 <<

右移操作符 >>

注：移位操作符的操作数只能是整数。

3.1左移操作符

移位规则：
移位中的位代表的就是二进制位

左边抛弃，右边补0

3.2右移操作符

移位规则：

首先右移运算分两种：

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

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

到这肯定有人疑惑，移位操作符可以干什么呢？

移位操作符一般与位操作符可以搭配使用，马上就展示，稍安勿躁

警告⚠：
对于移位运算符，不要移动负数位，这个是标准未定义的。
例如

c 复制代码

int num = 10;
num>>-1;//error

4. 位操作符

位操作符有：

& 按位与（按位与：同1为1，否则为0）

| 按位或（按位或：同0为0，否则为1）

^ 按位异或（按位异或：相同为0，不同为1）

注：他们的操作数必须是整数。

一道变态的面试题：

不能创建临时变量（第三个变量），实现两个数的交换

我们有2种方法

利用两数相加

c 复制代码

#include<stdio.h>
int main()
{
  int a=10;
  int b=20;
  a=a+b;
  b=a-b;
  a=a-b;
return 0;
}

2.利用按位异或

c 复制代码

#include <stdio.h>
int main()
{
  int a = 10;
  int b = 20;
  a = a^b;
  b = a^b;
  a = a^b;
  printf("a = %d b = %d\n", a, b);
 return 0;
}

4.1练习

编写代码实现：求一个整数存储在内存中的二进制中1的个数。

这里可以用到移位与位操作符

方法 1 .

例1 2 3 4，想看这个10进制有几个2，可以%10后/10，将每一位遍历，最后与2比较

根据这种方法，可以对一个二进制的数字%2再/2，将每一位遍历，最后与1比较

c 复制代码

#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;
}

但是这样做有一个弊端，不能解决n为负数的情况

为了改变这一情况，将num改为unsigned int即可

方法2.

c 复制代码

#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;
}

方法3.

这种方法很精妙

每一次num = num&(num-1)都可以将二进制最后一位1给消掉

最后利用count计数，观察消除了几个1

c 复制代码

11111  //n
11110  //n-1
11110  //新的n
11101  //n-1
11100  //新的n
....
当最后一位1时，减1会变为0，&后就为0
当最后一位0时，会向前借1，&后就为0

c 复制代码

#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.赋值操作符

赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值

c 复制代码

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;

这样的写法是不是更加清晰爽朗而且易于调试。

复合赋值符

+=

-=

*=

/=

%=

&=

|=

^=

<<=与>>=

6. 单目操作符

! 逻辑反操作

－负值

＋正值

& 取地址

sizeof 操作数的类型长度（以字节为单位）

~ 对一个数的二进制按位取反

-- 前置、后置--

++ 前置、后置++

※间接访问操作符(解引用操作符)

(类型) 强制类型转换

7.关系操作符

c 复制代码

>
>=
<
<=
!= 用于测试"不相等"
== 用于测试"相等"

这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。

8. 逻辑操作符

逻辑操作符有哪些：

&& 逻辑与

|| 逻辑或

区分逻辑与 和按位与

区分逻辑或 和按位或

c 复制代码

1&2----->0
1&&2---->1
1|2----->3
1||2---->1

9. 条件操作符

exp1 ? exp2 : exp3

当exp1为真，结果为exp2，否则为exp3

c 复制代码

if (a > 5)
b = 3;
else
b = -3;
转换成条件表达式，是什么样？

答案为

c 复制代码

int a = 0;
sacnf("%d",a);
int b = (a > 5 ? 3 : -1);

10. 逗号表达式

逗号表达式，就是用逗号隔开的多个表达式。

逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果

例：

c 复制代码

int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);

c为13

11. 下标引用、函数调用和结构成员

[ ]下标引用操作符
操作数：一个数组名 + 一个索引值

int arr[10];//创建数组

arr[9] = 10;//实用下标引用操作符。

[ ]的两个操作数是arr和9。

( ) 函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

c 复制代码

#include <stdio.h>
void test1()
{
printf("hehe\n");
}
void test2(const char *str)
{
printf("%s\n", str);
}
int main()
{
test1(); //实用（）作为函数调用操作符。
test2("hello bit.");//实用（）作为函数调用操作符。
return 0;
}

访问一个结构的成员

. 结构体.成员名

-> 结构体指针->成员名

c 复制代码

#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去执行运算。

c 复制代码

char a,b,c;
...
a = b + c;

b和c的值被提升为普通整型，然后再执行加法运算

加法运算完成之后，结果将被截断，然后再存储于a中

如何进行整体提升呢？

整形提升是按照变量的数据类型的符号位来提升的

c 复制代码

//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111
//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001
//无符号整形提升，高位补0

整形提升的例子:

c 复制代码

int main()
{
char a = 0xb6;
short b = 0xb600;
int c = 0xb6000000;
if(a==0xb6)
printf("a");
if(b==0xb600)
printf("b");
if(c==0xb6000000)
printf("c");
return 0;
}

a,b要进行整形提升,但是c不需要整形提升

a,b整形提升之后,变成了负数,所以表达式 a＝＝0xb6 , b＝＝0xb600 的结果是假,但是c不发生整形提升,则表

达式 c==0xb6000000 的结果是真

程序输出结果是

c

12.2 算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类

型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

long double

double

float

unsigned long int

long int

unsigned int

int

12.3操作符优先级

级别（由高到低）操作符（使用空格分隔）结合性

1 () [] -> . 由左向右

2 ! ~ ++ -- + - * (type) sizeof 由右向左

3 * / % 由左向右

4 + - 由左向右

5 << >> 由左向右

6 < <= > >= 由左向右

7 == != 由左向右

8 & 由左向右

9 ^ 由左向右

10 | 由左向右

11 && 由左向右

12 || 由左向右

13 ?: 由右向左

14 = += -= *= /= %= &= ^= |= <<= >>= 由右向左

15 , 由左向右

欢迎小伙伴的讨论

【C语言】操作符详解

操作符详解

1.操作符分类

2.算术操作符

3.移位操作符

3.1左移操作符

3.2右移操作符

4. 位操作符

4.1练习

5.赋值操作符

6. 单目操作符

7.关系操作符

8. 逻辑操作符

9. 条件操作符

10. 逗号表达式

11. 下标引用、函数调用和结构成员

12. 表达式求值

12.1 隐式类型转换

12.2 算术转换

12.3操作符优先级