操作符详解

操作符分类

算术操作符
移位操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号表达式
下标引用、函数调用和结构成员

算数操作符

+ - * / %

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

移位操作符（操作符是对补码进行操作）

右移操作符

>> 右移操作符

（算数操作符右边丢弃，左边补原来符号位）一般用这个

（逻辑右移右边丢弃，左边直接补0）

正整数原码反码补码相同

正整数15

原码为000000000000000000000000000001111；

反码为000000000000000000000000000001111；

补码为000000000000000000000000000001111；

负整数-15

原码为10000000000000000000000000001111；

反码为11111111111111111111111111110000；除了符号位不变其他为1变0，0变1；

补码为11111111111111111111111111110001；反码加1

-15>>1

补码为11111111111111111111111111111000；

反码为11111111111111111111111111110111；

补码减1（这里的减1是借前前一位的1相当于112-1，借1就是把这为变成2）；

原码为10000000000000000000000000001000；反码除了符号位不变其他为1变0，0变1；

左移操作符

<<左移操作符
左移操作符

左边丢弃右边补0；

位操作符

#include 
int main() {
	int a = 3;
	//补码00000000000000000000000000000011
	int b = -5;
	//原码10000000000000000000000000000101
	//反码11111111111111111111111111111010
	//补码11111111111111111111111111111011
	int c = a & b;
	//规则有0则0两个都是1才是1
	//补码00000000000000000000000000000011
	//补码11111111111111111111111111111011
	//c 为00000000000000000000000000000011
	printf("&操作符操作后%d\n", c);
	int n = a | b;
	//规则有1则1
	//补码00000000000000000000000000000011
	//补码11111111111111111111111111111011
 //n补码为11111111111111111111111111111011
 //n反码为11111111111111111111111111111010
 //n原码为10000000000000000000000000000101
	printf("|操作符操作后%d\n", n);
	int y = a ^ b;
	//规则对应二进制相同为0不同为1
	//补码00000000000000000000000000000011
	//补码11111111111111111111111111111011
 //y补码为11111111111111111111111111111000
 //y反码为11111111111111111111111111110111
 //y原码为10000000000000000000000000001000
	printf("^操作符操作后%d\n", y);
	
	system("pause");
}

关于^的一道面试题

问题为如何不创建临时变量交换两个数

a^a=a;
a^0=0;//因为0的二进制补码全为0，
a^b^a=b;
a^a^b=b;
//说明^有交换律

#include 
int main() {
	int a = 1;
	int b = 2;
	printf("没交换前a=%d b=%d\n", a, b);
	a = a + b;
	b = a - b;
	a = a - b;
	printf("交换后a=%d b=%d\n", a, b);
	a = a ^ b;
	b = a ^ b;//将a带入b=(a^b)^b=a
	a = a ^ b;//将a和b带入a=(a^b)^a=b
	printf("再次交换后a=%d b=%d\n", a, b);
	system("pause");
}

复制操作符

合赋值符
+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=

单目操作符

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

演示代码：
关于sizeof其实我们之前已经见过了，可以求变量（类型）所占空间的大小。
#include 
int main()
{
int a = -10;
int *p = NULL;
printf("%d\n", !2);
printf("%d\n", !0);
a = -a;
p = &a;
int arr[10]={0};
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
printf("%d\n", sizeof a);//这样写行不行？行括号能去掉说明不是函数
printf("%d\n", sizeof int);//这样写行不行？
printf("%d\n", sizeof(arr));//特殊的数组名代表整个数组大小
printf("%d\n", sizeof(int [10]));
return 0;
}

~操作符代码演示

#include 
int main() {
	int a = 10;
	//补码00000000000000000000000000001010
	//取反11111111111111111111111111110101
	//反码11111111111111111111111111110100
	//原码10000000000000000000000000001011
	printf("%d", ~a);//-11；
	system("pause");
}

小问题

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

关系操作符

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

自行理解

逻辑操作符

&& 逻辑与（左边为0右边就不算了）
|| 逻辑或（左边为1右边就不算了）

#include 
int main（）{

int i = 0,a=0,b=2,c =3,d=4;
i = a++ && ++b && d++;//a为0右边不计算了
//i = a++||++b||d++;
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);//1,2,3,4
return 0;
}

条件操作符

三目运算符

exp1表达式为真整个表达式为exp2
exp1表达式为假整个表达式为exp3

代码实现

#define _CRT_SECURE_NO_WARNINGS 1
#include 
int main() {
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int max = a > b ? a : b;//如果a>b,max=a,反之则为max=b;
	printf("%d", max);
}

上面的代码还可以表示为

#define _CRT_SECURE_NO_WARNINGS 1
#include 
int main() {
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int max = 0;
	if (a > b) {
		max = a;
	}else{
		max = b;
	}
	printf("%d",max);
}

逗号表达式

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

int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
c是多少
答案是13（从左往右依次计算，c就是最后一个表达式的值）；

下标引用，函数调用，结构成员

下标引用

1.[ ] 下标引用操作符
操作数：一个数组名 + 一个索引值
说白了就是数组中下标

int arr[10]={1,2,3,4,5,6,7,8,9,10};
printf("%d",arr[0]);

arr[0]就能找到数组中下标为0的值1

函数调用

函数名加（）括号里是参数
特殊的是printf（）；他的参数是可变参数列表

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

结构成员

访问一个结构的成员
. 结构体.成员名
-> 结构体指针->成员名
第一种方式

struct yinyue {
	char arr[10];
	char sum[100];
};
int main() {
	struct yinyue p = { "周杰伦","我落泪情绪零碎" };
	printf("%s的作者是%s", p.sum, p.arr);
	system("pause");
}

第二种方式（不同的是结构体地址访问成员变量）

struct yinyue {
	char arr[10];
	char sum[100];
};
print(struct yinyue* p) {
	printf("%s的作者是%s", p->sum, p->arr);
}
int main() {
	struct yinyue p = { "周杰伦","我落泪情绪零碎" };
	print(&p);
	system("pause");
}

表达式求值

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

int main() {
	int a = 1;
	int b = 2;
	int c = 1 + a * b;//*优先级较高
}

隐式类型转换

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

1.cpu运算时都是标准长度，都要提供四字节空间
2.cpu运算很难用8比特位进行计算所以要转为int或unsigned int才好运算
3.并且char相加进位有可能会丢位

//负数的整形提升
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 = 5;
	//二进制00000000000000000000000000000101
	//截断后为00000101
	char b = 127;
	//二进制00000000000000000000000001111111
	//截断后为01111111
	char c = a + b;
	//a整形提升00000000000000000000000000000101
	//b整形提升00000000000000000000000001111111
	//c为      00000000000000000000000010000100
	//截断后为10000100
	printf("%d",c);
	//c整形提升11111111111111111111111110000100
	//反码为   11111111111111111111111110000011
	//补码为   10000000000000000000000001111100
}

//实例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;
}

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

//实例2
int main()
{
char c = 1;
printf("%u\n", sizeof(c));
printf("%u\n", sizeof(+c));
printf("%u\n", sizeof(-c));
return 0;
}

//%u打印10进制无符号位（二进制是否看成符号）
实例2中的,
c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字
节.
表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof© ,就是1个字节.

算数转化

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

int a=0;
float b=1.0f;
float c=a+b

操作符的属性

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

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

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(); 中我们只能通过操作符的优先级得知：先算乘法，
再算减法。
函数的调用先后顺序无法通过操作符的优先级确定。

#include 
int main()
{
int i = 1;
int ret = (++i) + (++i) + (++i);
printf("%d\n", ret);
printf("%d\n", i);
return 0;
}
//尝试在linux 环境gcc编译器，VS2013环境下都执行，看结果。

linux运行
10
4
vs运行
12
4
看看同样的代码产生了不同的结果，这是为什么？
简单看一下汇编代码.就可以分析清楚.
这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级
和结合性是无法决定第一个 + 和第
三个前置 ++ 的先后顺序。
总结：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题
的。