【C语言】操作符详解

一、操作符分类

1、算术操作符

C语言中的算术操作符有加法、减法、乘法、除法和取余。

+    -    *    /    %

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

int a = 10;
int b = 3;
int c = a + b; // c的值为13
int d = a - b; // d的值为7
int e = a * b; // e的值为30
int f = a / b; // f的值为3
int g = a % b; // g的值为1

2、移位操作符

<<  左移操作符
>>  右移操作符

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

左移操作将一个数的二进制位向左移动指定的位数，右移操作将一个数的二进制位向右移动指定的位数。

整数在内存中存储的是补码的二进制

整数的二进制表示有3种形式：原码、反码、补码
正整数的原码、反码、补码是相同的
负整数的原码、反码、补码是要计算的


符号位：
0——正数
1——负数

负整数原码、反码、补码的转换方法

2.1、左移操作符

左移操作符的移位规则：
左边抛弃、右边补0

int main()
{
	int a = 5;
	int b = a << 1;//移位操作符操作的是二进制位
	printf("%d\n", a);
	printf("%d\n", b);
	return 0;
}

代码解读

在内存中5的补码为
00000000000000000000000000000101
因为5为正整数，故原码和反码均为
000000000000000000000000000000101

a<<1，则左边抛弃一位、右边补0
故原码、反码、补码为 000000000000000000000000000001010
所以b的输出结果为10

2.2、右移操作符

移位规则：
首先右移运算分两种：
1. 逻辑移位
左边用0填充，右边丢弃
2. 算术移位
左边用原该值的符号位填充，右边丢弃

到底是逻辑移位还是算术移位取决于编译器

int main()
{
	int a = -5;
	int b = a >> 1;
	//a的原码00000000000000000000000000000101
	//a的反码11111111111111111111111111111010
	//a的补码11111111111111111111111111111101
	//a>>1的补码11111111111111111111111111111101
	//a>>1的原码10000000000000000000000000000011
	printf("a=%d b=%d\n", a, b);
	return 0;
}

3、位操作符

&   //按位与
|   //按位或
^   //按位异或
注：他们的操作数必须是整数。

按位与操作符(&)：将两个操作数的二进制位进行与运算，只有当两个二进制位都为1时，结果才为1，否则为0。

int a = 10; // 二进制表示为1010
int b = 6; // 二进制表示为0110
int c = a & b; // c的值为2，二进制表示为0010

按位或操作符(|)：将两个操作数的二进制位进行或运算，只有当两个二进制位都为0时，结果才为0，否则为1。

int a = 10; // 二进制表示为1010
int b = 6; // 二进制表示为0110
int c = a | b; // c的值为14，二进制表示为1110

按位异或操作符(^)：将两个操作数的二进制位进行异或运算，只有当两个二进制位不同时，结果才为1，否则为0。

int a = 10; // 二进制表示为1010
int b = 6; // 二进制表示为0110
int c = a ^ b; // c的值为12，二进制表示为1100

4、赋值操作符

赋值操作符是C语言中的一种基本操作符，用于将一个值赋给一个变量。赋值操作符用等号(=)表示，例如：

int weight = 130;
weight = 120;

赋值操作符可以连续使用，比如：

int a = 10;
int x = 0;
int y = 20;
a = x = y+1;

复合赋值符

+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=

int a = 10;
a -= 5; // 等价于a = a - 5;
a += 3; // 等价于a = a + 3;
a *= 2; // 等价于a = a * 2;
a /= 4; // 等价于a = a / 4;
a %= 3; // 等价于a = a % 3;
a &= 6; // 等价于a = a & 6;
a |= 9; // 等价于a = a | 9;
a ^= 12; // 等价于a = a ^ 12;
a <<= 2; // 等价于a = a << 2;
a >>= 3; // 等价于a = a >> 3;

5、单目操作符

!           逻辑反操作
-           负值
+           正值
&           取地址
sizeof      操作数的类型长度（以字节为单位）
~           对一个数的二进制按位取反
--          前置、后置--
++          前置、后置++
*           间接访问操作符(解引用操作符)
(类型)       强制类型转换

6、关系操作符

关系操作符是C语言中的一种基本操作符，用于比较两个值的大小关系。这些关系操作符可以用于控制程序的流程，例如if语句、while语句、for语句等。

>
>=
<
<=
!=      用于测试“不相等”
==      用于测试“相等”

7、逻辑操作符

&&          逻辑与
||          逻辑或

逻辑与操作符(&&)用于判断两个逻辑表达式是否同时为真，只有当两个表达式都为真时，整个表达式才为真。逻辑或操作符(||)用于判断两个逻辑表达式是否有一个为真，只要有一个表达式为真，整个表达式就为真。逻辑非操作符(!)用于将一个非0的值转换为0，将0转换为1。

int height = 180;
int weight = 125;
if (height > 0 && weight > 0) 
{
    printf("完美\n");
}
if (height > 0 || weight > 0) 
{
    printf("可以0\n");
}
if (!(height > 0))
{
    printf("一般\n");
}

8、条件操作符

表达式1 ? 表达式2 : 表达式3

其中，表达式1为条件表达式，如果它的值为真，则整个表达式的值为表达式2的值，否则整个表达式的值为表达式3的值。例如：

int a = 2;
int b = 1;
int max = (a > b) ? a : b; // max的值为2

9、逗号表达式

表达式1,表达式2,表达式3,...表达式n

整个逗号表达式的值为最后一个表达式的值。

int main()
{
	int a = 1;
	int b = 2;
	int c = 3;
	int d = (a = b + 10, b = a + 1, c = b + 2);//逗号表达式
	printf("%d", d);//d的结果为15
	return 0;
}

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

 [ ] 下标引用操作符
 ( ) 函数调用操作符
 
 访问一个结构的成员 :
  .          结构体.成员名
  ->         结构体指针->成员名

下标引用、函数调用和结构成员操作符，它们分别用于访问数组元素、调用函数和访问结构体成员。

int a[10]={1,2,3,4,5,6,7,8,9,10};
a[5] = 6;

int max(int x, int y) 
{
    return (x > y) ? x : y;
}
int n = max(2, 1);

#include <stdio.h>
#include <string.h>
struct Stu
{
    char name[20];
    int age;
    float score;
};
void print1(struct Stu N)
{
    printf("%s %d %f\n", N.name, N.age, N.score);//结构体变量.成员名
}
void print2(struct Stu* ps)
{
    printf("%s %d %f\n", (*ps).name, (*ps).age, (*ps).score);
    printf("%s %d %f\n", ps->name, ps->age, ps->score);//结构体指针->成员名
    //这两行代码的效果是一样的
}
int main()
{
    struct Stu s = { "lzy",20,87.5f };
    print1(s);
    print2(&s);
    return 0;
}

二、表达式求值

①隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
如何进行整体提升呢？
整形提升是按照变量的数据类型的符号位来提升的

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

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;
}
//输出结果为c

实例1中的a,b要进行整形提升,但是c不需要整形提升
a,b整形提升之后,变成了负数,所以表达式 a0xb6 , b0xb600 的结果是假,但是c不发生整形提升,则表达式 c==0xb6000000 的结果是真

②算术转换

在C语言中，算术转换是指在进行算术运算时，将操作数转换为相同的类型，然后再进行运算的过程。C语言中的算术转换规则如下：

如果两个操作数的类型相同，则不需要进行转换。
如果两个操作数的类型不同，则需要将它们转换为相同的类型，转换的规则如下：
如果两个操作数中有一个是long double类型，则将另一个操作数转换为long double类型。
否则，如果两个操作数中有一个是double类型，则将另一个操作数转换为double类型。
否则，如果两个操作数中有一个是float类型，则将另一个操作数转换为float类型。
否则，将两个操作数都转换为有符号整型。
如果两个操作数都是整型，则进行整型提升，将它们转换为相同的有符号或无符号整型，转换的规则如下：
如果两个操作数都是有符号整型，则不需要进行转换。
否则，如果两个操作数都是无符号整型，则将它们都转换为无符号整型。
否则，如果一个操作数是有符号整型，另一个操作数是无符号整型，则将无符号整型转换为有符号整型。
如果两个操作数中有一个是指针类型，则进行指针转换，将它们转换为相同的指针类型。
如果两个操作数中有一个是浮点型，另一个是整型，则进行浮点型提升，将整型转换为浮点型。

long double
double
float
unsigned long int
long int
unsigned int
int

从下往上转换

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

③操作符的属性

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

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。
   如果两个相邻的操作符则取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。