【C语言】操作符

目录

 1. 操作符分类：

 2. 算术操作符

3. 移位操作符

3.1 左移操作符

 3.2 右移操作符

4. 位操作符

5. 赋值操作符

6. 单目操作符

6.1 单目操作符介绍

sizeof

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

7. 关系操作

8. 逻辑操作符

9. 条件操作符

 10. 逗号表达式

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

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

2. ( ) 函数调用操作符

3. 访问一个结构的成员

12. 表达式求值

12.1 隐式类型转换（整型提升）

12.2 算术转换

12.3 操作符的属性

---

 1. 操作符分类：

算术操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

 2. 算术操作符

+ - * / %

简单来说就是我们尝说的四则运算加减乘除

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

2. 对于/操作符如果两个操作数都为整数，执行整数除法。

而只要有浮点数执行的就是浮点数除法。

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

int r = 7/2;
printf("%d",r);
//3

double d = 7/2;
printf("%lf",d)
//3.000000

double a = 7 /2.0;
printf("%lf",a);
//3.500000

 对于%操作符的一个常见的运用就是一个数%10，得到这个数的末位

3. 移位操作符

<<左移操作符

>>右移操作符

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

3.1 左移操作符

移位规则： 左边抛弃、右边补0

但是实际上num在没有被赋值的情况下，自身的值不会变化

 3.2 右移操作符

移位规则：

首先右移运算分两种：

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

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

移位之后不会改变原来的值

是赋值

a自身没有变化，是结果赋值给了b

移位操作的是二进制位，对于负数来说操作的是它的补码

【举例】

对于算术右移的环境下，对于负数，可以直接在反码上操作，因为算术算术右移之后，反码变为补码加上的1被舍弃。所以反码不管是左移还是右移都是补1，之后转换位原码是取反末尾加1

【提示】

右移来说对于整数右移一位有除2的效果，因为是二进制.

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

4. 位操作符

位操作符有：

&  /按位与

|   //按位或

^     //按位异或

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

&  /按位与   有0则为0，同1才为1

|   //按位或   有1则为1；同0才为0

^     //按位异或  相同才为0，不然都是1

电路中与门就是有高电平就输出高电平的，除非都是低电平

或门有低电平就输出低电平，除非是都是高电平

 【练习】

#include <stdio.h>
 int main()
 {
 int num1 = 3;
 int num2 = -5;
 num1 & num2;
 num1 | num2;
 num1 ^ num2;
 return 0;
 }

【练习】

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

a^a^b, 和a^b^a是一样的。异或是支持交换律的

int a =10;
int b =20;
a= a^b;
b= b^a;
a= a^b; 


a =a+b;
b = a-b;
a = a-b;

 a^a ->0

a^0->1

a^b^a =b

---

一个数异或自己是0，一个数异或全0得到的是自己

其实一个数异1得到的是自己

 【练习】：

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

思想：判断每一位是不是1就好了，ran

让末尾的每一位来按位与上1个1，因为同1才为1

int countSetBits(int num) {
    int count = 0;
    
    while (num) {
        count += num & 1;
        num >>= 1;
    }
    
    return count;
}

 不过也有缺陷那就是一定会循环32次，比如1，二进制是只有末尾为1，循环32次，未免效率有点低

第二种

先思考一下十进是怎么得到每一位的比如1234

想要得到4，1234%10，之/10，就变成了123

二进制通过摩2除2可以得到每一位

int number_of_1(int m)
{

int count =0;
while(m)
{
if(m%2==1)
  count++;
m/2;
}

}

 但是这里有一个问题那就是如果是负数就不可用了

最好的方法就是让这个表达式会让n的二进制中的最右边的1消失了，在n的二进制里面的1全部去掉，也就是说有几个1就执行几次.究极解法了

比如100 减去一之后是001，按位或之后就是去掉n的二进制中的最右边的1

5. 赋值操作符

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

&和*操作数作用于指针。都是单目操作符&取出指针的地址。*解引用

复合赋值符

+=

-=

*=

/=

%=

>>=

<<=

&=

|=

^= 

【举例】

int x = 10;

x = x+10;

x += 10;//复合赋值

6. 单目操作符

6.1 单目操作符介绍

!          逻辑反操作

-           负值

+           正值

&          取地址

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

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

--          前置、后置-

++            前置、后置++

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

(类型)         强制类型转换

sizeof

可以说明sizeof不是函数，因为括号可以去掉。但是算类型的时候不能把括号去掉

去掉名字剩下的就是类型。是int [10],10不能省略 

sizeof后面写类型和写名字是一样的

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

让第5位的0变为1，那就让那一位按位或上1

让第5位的1变回0，那就是按位或，除了那一位是0，其他位是1的二进制数

 连续输入时候的写法

while( scanf("%d". &a) !=  EOF);

现在还可以这样写：
 

while(~scanf("%d",&a))

EOF是-1；-1的二进制是全1，~之后就是全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;
 }
 //程序输出的结果是什么？

这段代码中，首先将变量i、a、b、c和d初始化为0、0、2、3和4。

然后，在i的赋值语句中，使用了逻辑与运算符（&&）连接了三个表达式：a++、++b和d++。
逻辑与运算符的规则是先计算左侧的操作数，如果左侧的操作数为假（0），则整个表达式的结果为假（0），不再计算右侧的操作数；如果左侧的操作数为真（非0），则继续计算右侧的操作数，并返回右侧操作数的值作为整个表达式的结果。

在这里，a++的结果是0，并且a的值会自增1，变为1。由于左侧操作数为假，整个表达式的结果为假（0），所以不会计算后面的++b和d++。因此，i被赋值为0。

【答案】1234

&&只关心真假，表达式为真那整个表达式的结果就是1

9. 条件操作符

exp1 ? exp2 : exp3

exp1 ? exp2 : exp3 是条件运算符的语法形式。它的意思是，如果 exp1 的值为真（非零），则整个表达式的结果为 exp2 的值；如果 exp1 的值为假（0），则整个表达式的结果为 exp3 的值。

这种语法形式也被称为三元条件运算符，因为它由三个表达式组成。它提供了一种更简洁的条件语句的写法。

表达式1为真表达式二计算，表达式三不算

表达式1为假表达式三计算，表达式二不计算

 10. 逗号表达式

exp1, exp2, exp3, …expN

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

 【举例】

//代码1
 int a = 1;
 int b = 2;
 int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
c是多少？

 【答案】分别是12 13 13

if (a =b + 1, c=a / 2, d > 0)

【答案】c是1

 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. ( ) 函数调用操作符

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

对于函数调用操作符来说，

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

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的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型 提升。

字符存储也是存储的ASCII码值，也是整型

整型提升的意义： 表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度 一般就是int的字节长度，同时也是CPU的通用寄存器的长度。 因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长 度。 通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令 中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转 换为int或unsigned int，然后才能送入CPU去执行运算。

//实例1
 char a,b,c;
 ...
 a = b + c;

b和c的值被提升为普通整型，然后再执行加法运算。加法运算完成之后，结果将被截断，然后再存储于a中。

如何进行整体提升呢？

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

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

负数的整型提升是在高位补充符号位，正数是在高位补0，无符号整数也是

整形提升的例子:
 //实例1
 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

【举例】

 都是字符类型，发生截断，相加的时候整型提升，加完之后整型截断，%d是以10进制的形式来·打印有符号的整数，所以还要发生整型提升

 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个字 节.

表达式-c也会发生整形提升,所以 sizeof(-c) 是4个字节,但是sizeof(c) ,就是1个字节.

下面是除了char类型和short类型的

12.2 算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类 型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

这里的类型都是大于4字节的，然后是向上转换的

long double

double

float

unsigned long int

long int

unsigned int

int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运 算

12.3 操作符的属性

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。 操作符优先级