05C语言中的操作符和表达式

在第一章初识C语言中大家对操作符已经有了初步的了解。这一章将带大家深入了解C语言中的操作符，同时也会了解原码、反码、补码的概念。

---

---

一、操作符

1.算数操作符

算数操作符除了我们熟知的加减乘除以外，还有取模（取余）操作符。

+  -   *   /
% 取余操作符

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

2.移位操作符

在介绍移位操作符之前，必须介绍整数在内存中是如何存储的。（其他类型的数据如浮点型将在以后的文章中介绍）

2.1原码、反码和补码

整数在内存中以二进制的形式存储，那么什么是原码、反码和补码呢？

在内存中，整数都以补码的形式存储，正整数的原反补码相同，负数的则不同。
我们以左边第一位表示符号位，1表示负数，0表示正数。

所谓原码就是整数的二进制表示形式，比如整形负数-16，它用二进制这样表示：

int a=-16;
10000000000000000000000000010000
最左边的1表示负数的意思。

而反码就是原码的符号位不变，其他位按位取反（0变成1,1变成0），因此上面的原码转换成反码如下：

int a=-16;
11111111111111111111111111101111

补码则是在反码的基础上加1，所以补码为：

int a=-16;
11111111111111111111111111110000

在内存中，-16就是以补码的形式存在

由于我们一般的编译器都采用小端存储，低位数据都放在左边，因此该内存的实际情况为ff ff ff f0，在内存中以16进制形式存储，翻译成2进制正是我们上面的补码。
至于小端存储和大端存储，在之后的数据存储章节会讲到。

注意： 负数在内存中以补码的形式存储，但负数真实的二进制值还是它的原码，千万不要把补码当成二进制的值

由于整数的原反补码相同，在此以正整数16来举例

int a=16;
00000000000000000000000000010000
原码、反码、补码都是这样

那为什么要设置原反补码呢？

为了简化计算机基本运算电路,于是人们想出了让符号位也参与运算的方法。我们知道根据运算法则减去一个正数等于加上一个负数即1-1=1+(-1)=0,所以机器可以只有加法而没有减法,这样计算机运算的设计就更简单了。

我们拿上面的-16+16来举例子，如果将他们的补码相加：

 -16+16在内存中是补码相加
 11111111111111111111111111110000
 +
 00000000000000000000000000010000
 =
 1 00000000000000000000000000000000

可以看到，它们相加以后就变成了一个33位的数，而int型只能存储32位，多出来的1就自然被丢弃了没有存储，所以最后的结果就是00000000000000000000000000000000也就是0了。

因此，补码的存在是为了简化计算机的运算电路，使加减法都能通过加法电路来实现。

---

移位操作符分为左移操作符和右移操作符：

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

左移操作符移位规则：

左边抛弃、右边补0

右移操作符移位规则：

首先右移运算分两种：

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

但右移操作符一般都采用第二种规则

由于左移比较简单，在此仅以16和-16进行右移两位位的举例

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

16的原反补相同：
00000000000000000000000000010000
进行右移两位，右边补符号位
00000000000000000000000000000100
转化为二进制结果为4

-16的补码为：
11111111111111111111111111110000

右移两位，右边补符号位1：（左边空缺的两位都要补符号位1）
11111111111111111111111111111100

补码为反码加1，因此反码就是补码减1，所以反码为：
11111111111111111111111111111011

反码为原码符号位不变，其他位按位取反，因此原码就是反码符号位不变，其他位按位取反：
10000000000000000000000000000100

转化为二进制结果为-4

更多的左移和右移操作可以自己上机验证一下。

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

int num = 5;
num>>-1;//错误

3.位操作符

• 按位与 &
  只有两个数的补码二进制同时为1，结果才为1，否则为0。
  比如：3 &5 即 0000000000000011 & 0000000000000101 = 0000000000000001 ，所以 3 & 5的值为1。
• 按位或 |
  参加运算的两个数的补码只要两个数中的一个为1，结果就为1。
  比如：2 | 4 即 0000000000000010 | 0000000000000100 = 0000000000000110 ，所以2 | 4的值为 6 。
• 按位异或 ^
  参加运算的两个数的补码，如果两个相应的二进制位值不同，则该位结果为1，相同则为0。
  比如： 2 ^ 4 即 0000000000000010 ^ 0000000000000100 =0000000000000110 ，所以 2 ^ 4 的值为6 。

注意： 位操作符都是以补码进行操作，比如我们（16）^（-16）

 11111111111111111111111111110000  //-16的补码
 ^
 00000000000000000000000000010000  //16的补码
 =
 11111111111111111111111111100000   //异或后的补码
 
 补码转化成原码为：
 10000000000000000000000000100000   //结果为-32

位操作符有很多有趣的用法，特别是异或操作符，比如下面的一道题：

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

这道题可以用加减法，但是当两个数特别大时相加可能会特别大导致内存无法储存，丢失准确性：

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

我们可以用异或的方式来做这道题：

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

将a和b的二进制结果写出来异或一下，不难得到结果。但为什么可以这样做呢？

仔细观察我们可以发现，如果两个数相同，它们异或的结果必定是0，而任何数和0异或其结果必定为这个数本身，知道这两个结论我们就不难理解上面的程序了：

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

我们将上面程序的后三行展开，为了区分所以加上下标，可以写成下面这样的式子：
    a1 = a ^ b;
	b1 = a1 ^ b=a ^ b ^ b=a;
	a2 = a1 ^ b1=a ^ b ^ a=b;

4.赋值操作符

赋值操作符可以给一个变量赋值，由于太简单，在此不作过多说明，赋值操作符可以给一个变量多次赋值，变量的值以最后一次赋值为准，同时也可以连续赋值：

int a = 10;
int x = 0;
int y = 20;
a = x = y+1;//这句话可以写成x = y+1; a = x;因此a为21

4.1复合赋值操作符

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

这些运算符都可以起到复合赋值的效果，使代码更简洁。 比如：

int x = 10;
x = x+10; 
x += 10;//这两种赋值方法是等效的
//其他运算符同理。

5.单目操作符

顾名思义就是只有一个操作数的操作符

!           逻辑反操作 将真变为假，假变为真
-           负值
+           正值
&           取地址  一般和指针配合使用，将变量的地址取出来存放到指针里
sizeof      操作数的类型长度（以字节为单位）
~           对一个数的二进制按位取反
--          前置、后置--
++          前置、后置++
*           间接访问操作符(解引用操作符) 
(类型)       强制类型转换

以上的这些操作符有的我们在第一章已经讲过，或者在平时的程序中经常用到已经很熟悉，在此仅说一下要注意的点:
sizeof括号里面的表达式不参与运算，如果计算一个表达式的大小，以表达式左边变量的类型为主

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

sizoef以b的类型为准，b为short型，所以结果为2；sizeof中的表达式b=a+10并没有真实运算，因此b的值仍然为0

6.关系操作符

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

这些关系运算符比较简单，没什么可讲的，但是千万要注意不要把 == 写成 =

7.逻辑操作符

&&   逻辑与   从左向右所有表达式都为真（非0），那整体就为真（1），否则为假（0）
||   逻辑或   从左向右所有表达式有一个为真（非0），那么整体就为真（1），只有所有表达式都为假时整体才为假（0）

区分逻辑与和按位与 区分逻辑或和按位或

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++;
	printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
	printf("i = %d", i);
	return 0;
}

在从左向右执行表达式i = a++ && ++b && d++;时，由于a++是先使用a，后进行+1，a的值是0为假，因此这个逻辑与的表达式就为假，后面的表达式将不再执行，所以++b和d++的操作并没有执行。

我们再把条件改一下：

#include <stdio.h>
int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++||++b||d++;
	printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
	printf("i = %d", i);
	return 0;
}

在从左向右执行表达式i = a++ || ++b || d++;时，由于a++是先使用a，后进行+1，a的值是0为假，因此继续执行，后面的++b为真，因此整个表达式的结果就为真，后面的d++的操作将不再执行。

总结一下： 当有多个逻辑与表达式时，程序从左向右执行，遇到为假的表达式程序停止，后面的程序不再执行，整体表达式结果为假；当有多个逻辑或表达式时，程序从左向右执行，遇到为真的表达式程序停止，后面的程序不再执行，整体表达式为真。

8.条件操作符（三目运算符）

exp1 ? exp2 : exp3    如果表达式1的值为真，整体的值就是表达式2，如果表达式1的值为假，整体的值就是表达式3

三目运算符和if-else语句十分类似：

if (a > 5)
        b = 3;
else
        b = -3;


b= (a>5 ? 3 : -3);

上面两种形式是等价的

9.逗号表达式

exp1, exp2, exp3, …expN  每个表达式从左向右依次进行计算，
整个表达式的结果是最后一个表达式计算结束的结果

分析下面的代码：

#include <stdio.h>
int main()
{
	int a = 0;
	int b = 1;
	int c = (a > b, a = b + 10, a, b = a + 1);
	printf("c = %d", c);
	return 0;
}

c = (a > b, a = b + 10, a, b = a + 1)从左向右依次计算，a>b结果为假，这个表达式的结果为0;a=b+10的结果为11，此时a的值为11;a这个单独放在这里，由于后面还有表达式，因此并没有产生效果 ; b=a+1的值为12, 因此整个表达式的结果就是最后一个表达式 b = a + 1的结果12

逗号表达式可以和while循环结合，使语句更简洁

#include <stdio.h>
int main()
{

	int a = 0;
	while (a ++, a < 10)
	{
		printf("hello world\n");

	}
	return 0;
}

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

• [ ]下标引用操作符
  用来访问和使用数组

int arr[10];//创建数组
 arr[9] = 10;//使用下标引用操作符对其赋值。
 [ ]的两个操作数是arr和9。

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

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

• 访问一个结构的成员

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

struct Stu
{
    char name[20];//名字
    int age;      //年龄
    char sex[5];  //性别
    char id[15]； //学号
};
int main()
{
struct Stu s = {"张三"， 20， "男"， "20180101"};//创建一个学生s，并对其进行初始化赋值
//.为结构成员访问操作符，能够访问结构体的成员
printf("name = %s age = %d sex = %s id = %s\n", s.name, s.age, s.sex, s.id);
//创建一个结构体指针，用来存放s的地址
struct Stu *ps = &s;
//->操作符可以通过指针来访问到结构体的具体成员
printf("name = %s age = %d sex = %s id = %s\n", ps->name, ps->age, ps->sex, ps- >id);
}

---

二、表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型，这就是隐式类型转换。

1.隐式类型转换

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

以下是整形提升的意义：

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

举个例子：

#include <stdio.h>
int main()
{
	char a = 3;
	char b = 127;
	char c = a + b;
	printf("%d", c);
	return 0;
}

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

上面两条是什么意思呢？我们来一步步分析：

char a=3;
首先3是一个整数，它的大小是4个字节也就是32位，00000000000000000000000000000011
但是a是char类型，这个类型的变量a只能存放1个字节也就是8位：00000011

同理
char b=127;
127写成32位是00000000000000000000000001111111
char 类型的b只能存放8位：01111111

a和b在相加时，由于它们的大小只有1字节，并不满足普通整形类型4字节的大小，
因此为了提升计算精度要把它们进行整形提升

整形提升是按照变量的数据类型的符号位来提升的
也就是最左边是1提升的位就补1，是0就补0

因此a和b在相加时，要先整形提升为32位，即
00000000000000000000000000000011
+
00000000000000000000000001111111
=
00000000000000000000000010000010

但是c是char类型，只能存放8位
因此c里面放的是
10000010

在打印c的时候，c也要进行整形提升：

c最左边的符号位是1，所以提升的位都补1
整形提升以后的32位结果是：
11111111111111111111111110000010

整形提升以后得到的是补码，我们再把补码转换成原码，就是打印的结果：

11111111111111111111111110000010  补码
11111111111111111111111110000001  反码
10000000000000000000000001111110  原码

这个原码就是我们打印的结果-126

再看一个例子：

#include <stdio.h>
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;
	
}

实际上，ab在比较的时候，也会发生整形提升，由于a和b在整形提升以后它们的值和0xb6以及0x600并不相等，所以它们各自的if条件并不成立；c本身就是个32位的int整形，在比较的时候并不用整形提升，因此c中的0x60000000就是它本身。我们可以打印出来看一下它们各自的值：

只有c的值是相等的，c本身就是个int型，它并不用整形提升。a和b整形提升以后，它们的值发生了改变。至于如何把16进制转换成2进制，然后整形提升，这些以及在前面说过很多遍了，在这里就不具体说明了。

强调一点： 只要参与到表达式运算，就会发生整形提升：

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

c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 和 sizeof(~c)是4个字节，而sizeof( c )并不会发生整形提升，所以是一个字节 。

2.算数转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面是各种类型的优先级：

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

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
比如一个int类型和float类型相加，那int类型首先就要转化成float类型，然后再相加。
这不难理解，在此不作过多说明。
但是算术转换要合理，要不然会丢失精度。比如：

float f = 3.14;
int num = f;//会有精度丢失

3.操作符属性

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

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。

下面是各种操作符的优先级和结核性表：

由于操作符具有优先级和结合性，因此非常容易写出很多有问题的代码，比如：

c + --c;

操作符的优先级只能决定自减–的运算在+的运算的前面，但是我们无法知道最左边的c是已经自减以后的c还是没自减之前的c

再看一个例子：

#include <stdio.h>
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();的时候，虽然根据优先级知道先算乘再算减，但是哪个fun()先调用呢？这个问题其实是未知的，函数的调用顺序不一样，其运算的结果也是不一样的。

还有下面这种：

#include <stdio.h>
int main()
{
	int i = 1;
	int ret = (++i) + (++i) + (++i);
	printf("%d\n", ret);
	printf("%d\n", i);
	return 0;
}

这段代码中的第一个 ++ 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 ++ 和第三个前置 ++ 的先后顺序。
以上这些代码在不同的编译器下运行的结果都是不同的，因为不同的编译器其运算和函数调用的顺序都是不同的。

因此：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。

---

总结：

这篇博客带大家了解了C语言中的操作符以及原反补码，还有整形提升。
操作符部分只需要熟悉如何使用即可，整形提升部分需要着重注意，因为可能会出面试题。
另外我们也要了解操作符的优先级和结合性，要不然很容易写出错误的代码，特别是那种很长的代码。

当然，这篇博客如果有任何错误，或者各位大佬有任何建议，可以在评论区指出和提出，我会对博客进行修改和完善。