C语言——操作符篇

目录

前言

一.  什么是操作符？以及操作符的分类

二.  算术操作符

三.  移位操作符

3.1  左移操作符

3.2  右移操作符

四.  位操作符

五.  赋值操作符

六.  单目操作符        

6.1  单目操作符介绍

6.2  sizeof和数组

七.  关系操作符

八.  逻辑操作符

九.  条件操作符

十.  逗号表达式

十一.  下标应用、函数调用和结构成员

十二.  表达式求值

12.1  隐式类型转换

12.2  算术转换

12.3  操作符的属性

---

前言

小伙伴们好久不见！这段时间时间小编学业很忙碌，所以更新的速度自然没有前段时间那么勤快，不过小编还是会一直跟大家分享知识，咱们共同进步！

一.  什么是操作符？以及操作符的分类

操作符：操作符是一种计算机术语，指令系统的每一条指令都有一个操作符，它表示该指令应进行什么性质的操作。不同的指令用操作符这个字段的不同编码来表示，每一种编码代表一种指令。我们在编程中无时无刻都会见到操作符，因此操作符对于我们的重要性是无与伦比的。操作符种类繁多，我们自然要给予不同类型的操作符不同的分类名称，常见的操作符种类有：算术操作符，移位操作符，位操作符，赋值操作符，单目操作符等等很多，我们下面马上一一介绍。

二.  算术操作符

算术操作符，顾名思义就是跟算术有关的操作符，加减乘除，这些大家从小学到大的数学，但是计算机中还有一个算术操作符就是%（余），在数学中，除法当除不尽时我们会选择用小数或者分数来表示，但是在C语言中，我们会用余数来表示。

这就是我们的算术运算符，可以说是非常的常见。 

注意：

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

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

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

三.  移位操作符

移位操作符听起来也是非常的简单，不就是左移几个，右移几个嘛，有什么好讲的呢？没错，就是左移几格右移几格，但是这里的左移可不是你输入什么就移动你输入的，下面就讲讲这个只有<<和>>两个操作符的移位操作符

3.1  左移操作符

左移操作符的规则是：左边抛弃，右边补0。

在这里我们引入一个概念，叫做原码，反码，补码，这是什么意思呢？

我们输出一个函数的时候是原码，但是实际存入内存之中的却是补码，例如：

我们输入一个数字int a=3和int b=-5

我们输入到计算机中的实际是

a:

00000000000000000000000000000011       

这是a的原码

00000000000000000000000000000011           

这是a的反码

00000000000000000000000000000011   

这是a的补码

可以看到a的原码，反码，补码都是一样的，因此正数的原反补都是一样的。

b:

10000000000000000000000000000101

这是b的原码

111111111111111111111111111111010

这是b的反码

111111111111111111111111111111011

这是b的补码

可以看到b的原反补跟a就用很大的区别，32个比特位，第32位代表的是符号位，因此a的32位是1而b的是0，负数的反码也就是符号位不变，其他位按位取反，而补码就是将反码加1，当我们需要打印的时候再将补码转换成补码，如下图，不知道各位能不能理解，如果能理解接下来就比较容易了。

//当输入一个数字的时候
int main()
{
    int a=10;
    int b=a<<1;
    printf("%d",b);
}

这个时候我们会发现b是20，就是因为左移导致b的原码最后成为了000000000000000000000000010100                                                            

3.2  右移操作符

而右移操作符却又比左移操作符更复杂一点点，因为右移操作符需要分情况来考虑。

右移运算分为两种情况：

1.逻辑右移

   左边用0填充，右边丢弃。

2.算术右移

   左边用原该值的符号位来填充，右边丢弃。

例如当我们引入一个数字-1，int num=-1；

根据我们上面的介绍，-1的原码反码补码如下：

10000000000000000000000000000001；

11111111111111111111111111111110；

11111111111111111111111111111111；

-1存入内存的补码32位全都是1，如下图，算术右移就是补充符号位也就是-1的符号位（1），而逻辑右移就是补充符号0。这样大家一定都可以理解。

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

int num=10;
num>>-1;//这样是错误的

四.  位操作符

位操作符只有三个，分别是&（按位与），|（按位或），^（按位异或），下面将对三种进行介绍

我们输入两个数分别是int a=3，int b=5

然后其中a的补码是00000000000000000000000000000011

               b的补码是00000000000000000000000000000101

               a&b此时是每一位进行比较，如果都为1则为1，有一个不为1则就是0

               所以a&b也就是00000000000000000000000000000001

               a|b则是只要有一位数是1，则为1，当两者都为0的时候，才是0

               所以a|b就是00000000000000000000000000000111

               而最为特殊的则是^（按位异或），当两个位数相同则输入0，输入不同则输入1

               所以a^b就是00000000000000000000000000000110

               由此我们可以得到结果分别是1,7,6

               

然后有一道很经典的题目，就是不使用临时变量来实现两个数字的交换，有的小伙伴就懵了，不使用临时变量那怎么做呢？咱们接着看：

刚刚学习了按位异或，大家想想看，a^b^a是不是等价与a^a^b，而a^a的结果是什么呢？是0！这样0^b是不是就是b，那我们是不是也就可以用这种方法实现两个数字的交换。

int main()
{
    int a=3;
    int b=5;
    a=a^b;//等价于a^b
    b=b^a;//等价于b^a^b
    a=a^b;//等价于a^b^b
    printf("%d %d",a,b);
    return 0;
}

大家可以发现这样子也可以实现对于两个数字的交换，但是这种方法并不是适用，我们最好还是使用引用一个变量，三个值交换来交换两个数字的值，这种方法还是更好一些。

五.  赋值操作符

赋值操作符对于我们而言是非常的好用，我们可以更改变量的值，让它成为我们想让它成为的值。

赋值操作符有赋值操作符也有复合赋值符，赋值操作符我们可以连续的使用，例如

a=b=c+213，它同时也等价于b=c+213，a=b，非常的方便。

复合赋值符就是将两个运算符合并成为一个并且也达到赋值的效果，就如a

a+=1        等价于a=a+1

a-=1        等价于a=a-1

a*=1        等价于a=a*1

a/=1        等价于a=a/1

a%=1        等价于a=a%1

a>>=1        等价于a=a>>1

a<<=1        等价于a=a<<1

a&=1        等价于a=a&1

a|=1        等价于a=a|1

a^=1        等价于a=a^1

可以看到实现这些功能的时候并且让我们的冗杂的代码变的更加简洁明了。

六.  单目操作符        

6.1  单目操作符介绍

单目操作符，顾名思义就是只进行一种操作的操作符。

!           逻辑反操作

-           负值

+           正值

&           取地址

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

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

--          前置、后置--

++          前置、后置++

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

(类型)       强制类型转换

其中前置++，--和后置++，--，后置是先使用后++，后置则是先++后使用，这是唯一要注意的地方。

6.2  sizeof和数组

sizeof可是我们的老熟人了，那么为什么还要拿出来讲呢？当然是还有一些很容易混淆的地方。

#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），（3），（4）分别会打印什么呢？

正确答案应该是40,10,4或8，4或8，这个4或8是根据是x64版本还是x32版本决定的。

七.  关系操作符

关系操作符是非常的简单的，也没有什么可讲的地方就给大家介绍一下：

>

>=

<

<=

！=  用于测试“不相等”

==      用于测试“相等”

注意：唯一需要注意的地方就是一定一定不能将==和=搞错了，这样你的程序很可能不会按你设计的运行，甚至有可能栈溢出，小编就经常犯这种低级错误，都是血和泪的经验啊！！！

八.  逻辑操作符

逻辑操作符很少，只有两个&&逻辑与和||逻辑或，大家一定要区分逻辑与和按位与，逻辑或和按位或，两者是有很大的区别的：

1&4=0         按位与

1&&4=1        逻辑与

1|4=5        按位或

1||5=1        逻辑或

这就是两者区别，按位与（或）是将补码进行比较，而逻辑与（或）则是将两边条件进行比较，逻辑与是两边条件都为真则返回1，如果都是假则返回0，逻辑或是两边条件有任意一个为真就返回1，只有当两个条件都为假的时候，这时才会返回1。

因此用逻辑与和逻辑或写判断闰年的函数是相当的完美：

#include<stdio.h>
int main()
{
	int year=0;
	for(year=1000;year<=2000;year++)
	{
		if((year%4 == 0&year%100 != 0)||(year%400 == 0))
		{
			printf("%d\n",year);
		}	
	}
	return 0;
 } 

但是有这样一道题，大家来看看他的结果应该是什么呢？

#include <stdio.h>

int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++||++b||d++;

    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    return 0;
}
//a，b，c，d的值应该分别是多少？

可能有的小伙伴猜1,3,3,5，但是它的结果其实应该是1,3,3,4，那这到底是为什么呢？，接下来就解答大家的疑惑，逻辑或是两边只要有一个条件是真就为1，当第一个a++时，先使用后++，这个时候a++不能返回1，这个时候我们看++b，它为3则为真，那这个时候无论后面的d++是真是假，对于我们的i来说是并没有影响的，所以我们默认就不会去计算d++了，而
逻辑与也是同样的道理，当第一个为假的时候这个值的后续所有都不会继续计算下去了，因为无论如何这个表达式都只会返回0，后面的计算就没有了意义，大家一定要注意这一点。

九.  条件操作符

条件操作符对于我们而言其实也是很常见的，可以减少代码的冗杂性，不过小编个人认为条件操作符还是对于代码的熟练度够高了在选择去使用，

if (a > 5)
        b = 3;

else
        b = -3;
//这个if语句使用判断操作符就是：
a>5?b=3:b=-3

虽然非常的简短，不过对于代码熟练度的要求太高了。

十.  逗号表达式

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

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

就是这样的形式exp1, exp2, exp3, …expN

int a=3;
int b=5;
int c=(a*3,b/2,a+b+1);
//这个表达式就是将逗号表达式一一计算，结果c等于12
if(a+=1,c=b*5-3;d<0)
/*这样子的表达式也是逗号表达式，虽然前面有很多计算式，但是真正的对于这个if语句的判断只在于最后一句
d<0上*/
a = get_val();
count_val(a);
while (a > 0)
{
    //需要实现的功能
    a = get_val();
    count_val(a);
}
//如果使用逗号表达式，改写：
while (a = get_val(), count_val(a), a>0)
{
         //需要实现的功能
}
    

可以看到逗号表达式使用起来非常的方便。

十一.  下标应用、函数调用和结构成员

1. [ ] 下标引用操作符

操作数：一个数组名 + 一个索引值

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.1  隐式类型转换

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

整型提升的意义：

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

如何进行整体提升呢？

//负数的整形提升

char c1 = -1;

变量c1的二进制位(补码)中只有8个比特位：

1111111

因为 char 为有符号的 char

所以整形提升的时候，高位补充符号位，即为1

提升之后的结果是：

11111111111111111111111111111111

//正数的整形提升

char c2 = 1;

变量c2的二进制位(补码)中只有8个比特位：

00000001

因为 char 为有符号的 char

所以整形提升的时候，高位补充符号位，即为0

提升之后的结果是：

00000000000000000000000000000001

//无符号整形提升，高位补0

下面再举一个例子：

#include <stdio.h>
int main()
{
	//char --> signed char
	char a = 3;
	//截断
	//00000000000000000000000000000011
	//00000011 - a
	//
	char b = 127;
	//00000000000000000000000001111111
	//01111111 - b

	char c = a + b;
	//00000011
	//01111111
	//整型提升
	//00000000000000000000000000000011
	//00000000000000000000000001111111
	//00000000000000000000000010000010
	//10000010 - c
	printf("%d\n", c);
	//%d 是打印十进制的整数
	//11111111111111111111111110000010 - 补码
	//11111111111111111111111110000001
	//10000000000000000000000001111110 - 原码
	//-126
	return 0;
}

可以看到并没有打印我们以为的130而是-126，这无疑证明的整型提升的存在。

12.2  算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类 型，否则操作就无法进行。下面的层次体系称为寻常算术转换。换句话讲就是低位采用高位的类型。而类型的排序优先级如下（从高往低）：

long double

double

float

unsigned long int

long int

unsigned int

int

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

警告： 但是算术转换要合理，要不然会有一些潜在的问题。

例如：

float f = 3.14;

int num = f;//隐式转换，会有精度丢失

12.3  操作符的属性

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

1. 操作符的优先级

2. 操作符的结合性

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

我们写出一个表达式要保证在不同的编译器上不会出现不同的结果，这样子的表达式被称作问题表达式，就如：

a*b+c*d+e*f

那么计算机就会认为：

a*b c*d a*b + c*d e*f a*b + c*d + e*f

或者：

a*b c*d e*f a*b + c*d a*b + c*d + e*f

那到底是哪种呢？你这让计算机也很为难嘛，你让计算机为难计算机就不干了，这个表达式就成问题表达式了。

而下面这个表达式更过分了

int main()
{
 int i = 10;
 i = i-- - --i * ( i = -3 ) * i++ + ++i;
 printf("i = %d\n", i);
 return 0;
}

计算机想到底应该现将哪一个--又将哪一个后++呢？计算机根本不能理解，所以我们写代码的时候一定不能写让计算机为难的代码。

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

到这里，所有关于操作符的内容都讲解完了，小伙伴要是看的满意的话，希望多多点赞，收藏，小编需要大家的鼓励，大家一起共同进步！！！

​​​​​​​