1.各种操作符介绍

1.操作符分类：

算数操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

2.算数操作符

+  -  *  /  %

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

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

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

3.移位操作符（移动的是二进制）

 << 左移操作符

 >> 右移操作符

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

二进制：

·正的整数的原码、反码、补码相同。

·负的整数的原码、反码、补码要计算。

如：-7

原码：10000000000000000000000000000111

反码：111111111111111111111111111111111000（原码符号位不变，其它位按位取反）

补码：111111111111111111111111111111111001（反码+1 就是补码）

（整数在内存中存储的是补码）

3.1左移操作符位

移位规则：

左边抛弃，右边补0

3.2右移操作

移位规则：

首先右移运算分两种：

       1.逻辑移位

          左边用填充，右边丢弃

       2.算数移位

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

警告：

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

例如：

int num = 10 ;

num >> -1 ;//error

4.位操作符

位操作符有：

&   //按（二进制）位与

|    //按（二进制）位或

^   //按（二进制）位异或-相同为0，相异为1

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

练习一下：

#include<stdio.h>

int main()
{
	//整数在二进制中存的是补码

	int num1 = 3;
	//0000000000000000000000000000011 - 3的原码、反码、补码
	int num2 = -5;
	//1000000000000000000000000000101 - -5的原码
	//1111111111111111111111111111010 - -5的反码
	//1111111111111111111111111111011 - -5的补码

	int a = num1 & num2;//& ：两边同时为1才为1
	//a
	//0000000000000000000000000000011 - 3的补码

	int b = num1 | num2;// | ：两边只要有一个为1，就为1
	//b
	//1111111111111111111111111111011 - -5的补码

	int c = num1 ^ num2;// ^ :相同为0，相异为1
	//c
	//11111111111111111111111111111000 - 补码
	//11111111111111111111111111110111 - 反码
	//10000000000000000000000000001000 - 原码 - -8

	printf("a = %d\n", a);//3
	printf("b = %d\n", b);//-5
	printf("c = %d\n", c);//-8

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

练习：

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

参考代码：

//方法1
#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;
}

//方法2
#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
#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.赋值操作符

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

int  weight = 120 ;//体重

weight = 89 ;//不满意就赋值

double salary = 10000.0;

salary = 20000.0 ;//使用赋值操作符赋值。

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

int a = 10 ;

int x = 0 ;

a = x = y + 1 ;//连续赋值

这里的代码感觉怎么样？

那同样的语义，你看看：

x = y + 1 ;

a = x ;

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

符合赋值符

+=

-=

*=

/=

%=

>>=

<<=

&=

|=

^=

这些运算都可以写成复合的效果。

比如：

int x = 10 ;

x = x + 10 ;

x += 10 ;//复合赋值

//其他运算符一样的道理。这样写更加简洁。

6.单目操作符

6.1单目操作符介绍

演示代码：

#include<stdio.h>
int main()
{
	int a = -10;
	int* p = NULL;
	printf("%d\n", !2);//0
	printf("%d\n", !0);//1
	a = -a;
	p = &a;
	printf("%d\n", sizeof(a));//4
	printf("%d\n", sizeof(int));//4
	printf("%d\n", sizeof a);//这样写行不行？ok
	printf("%d\n", sizeof int);//这样写行不行？error
	return 0;
}

6.2sizeof和数组

#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）两个地方分别输出多少？  40  4

（3）、（4）两个地方分别输出多少？  10  4

7.关系操作符

关系操作符

警告：

       在编程过程中 == 和 = 不小心写错，导致错误。

8.逻辑操作符

逻辑操作符有哪些：

&&   逻辑与

||      逻辑或 

区分逻辑与和按位与

区分逻辑或和按位或

1 & 2 -----------> 0

1 && 2 ---------> 1

1 | 2 ------------->3

1 || 2 ------------>1

逻辑与和或的特点：

&&      左边为假，右边就不计算了

||         左边为真，右边就不计算了

360笔试题：

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

	return 0;
}
//程序输出的结果是什么？

9.条件操作符（三目操作符）

exp1?exp2:exp3

练习：

1.

if(a>5)

         b = 3 ;

else

         b = -3 ;

转换成条件表达式，是什么样？

2.使用条件表达式实现找两个数中较大值。

//1
#include<stdio.h>
int main()
{
	int a = 3;
	int b = 0;

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

	return 0;
}

#include<stdio.h>
int main()
{
	int a = 3;
	int b = 0;

	int max = (a > b ? a : b);

	return 0;
}

10.逗号表达式

exp1,exp2,exp3,...expN

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

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

//代码1

int a = 1 ;

int b = 2 ;

int c  = (a > b , a = b + 10 , a , b = a + 1) ;//逗号表达式

c是多少？      13

//代码2

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

//代码3

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

2.表达式求值

12.表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

  12.1隐式类型转换

C的整型算数运算总是至少以缺省整型类型的精度来进行的。

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

整型提升的意义：

表达式的整型运算要在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个比特位；

11111111

因为char为有符号的char

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

提升之后的结果是：

11111111111111111111111111111111

//正数的整型提升

char  c2 = 1 ;

变量c2的二进制位（补码）中只有8比特位：

00000001

因为char为有符号的char

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

提升之后的结果是：

00000000000000000000000000000001

//无符号整型的提升，高位补0.

整型提升的例子：

//案例1
#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;
}

案例1中的a，b要进行整型提升，但是c不需要整型提升

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

所以程序输出的结果是：c

//实例2
#include<stdio.h>
int mian()
{
	char c = 1;
	printf("%u\n", sizeof(c));//1
	printf("%u\n", sizeof(+c));//4
	printf("%u\n", sizeof(-c));//4

	return 0;
}

实例2中的c只要参与表达式运算，就会发生整型提升，表达上+c就会发生提升，所以sizeof(+c)是4个字节。

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

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.是否控制求值顺序

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

操作符的优先级：

一些问题表达式

//表达式的求值部分由操作符的优先级决定。

//表达式1

a*b + c*d + e*f

注释：代码1在计算的时候，由于比+的优先级高，只能保证，*的计算是比+早，但是优先级并不能决定第三个*比第一个+早执行。

所以表达式的计算机顺序就可能是：

a*b

c*d

a*b + c*d

e*f

a*b + c*d + e*f

//表达式2

c + --c ;

注释：同上，操作符的优先级只能决定自减--的运算在+的运算的前面，但是我们并没有办法得知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。

//代码3 - 非法表达式
#include<stdio.h>
int main()
{
	int i = 10;
	i = i-- - --i * (i = -3) * i++ + ++i;
	printf("i = %d\n", i);

	return 0;
}

表达式3在不同编译器中测试结果：非法表达式程序的结果

//代码4
#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();中我们只能通过操作符的优先级得知：先算乘法，再减法。

函数的调用先后顺序无法通过操作符的优先级确定。

//代码5
#include<stdio.h>
int main()
{
	int i = 1;
	int ret = (++i) + (++i) + (++i);
	printf("%d\n", ret);
	printf("%d\n", i);

	return 0;
}
//尝试在linux环境、gcc编译器、vs2022环境下都执行，看结果。

linux环境的结果： 10  4

vs2022环境的结果： 12  4

看看同样的代码产生了不同的结果，这是为什么呢？

简单看一下汇编代码，就可以分析清楚。

这段代码中的第一个+在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个和+和第三个前置++的先后是顺序。

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

时光匆匆，一篇博客又到了结尾处啦。真心感谢每一位愿意花时间阅读我文字的朋友，希望你们每天都过得开开心心的，生活顺顺利利哦，咱们下次再通过文字‘相遇’呀。