2.移位操作符

移位操作符操作的是整数，整数在内存中存储的是补码，打印或者使用时，用的原码值

<<   >>   二进制位的移动

一.左移操作符   <<

#include <stdio.h>
int main()
{
	int a = 5;
	a = a << 2;
	//     00000000000000000000000000000101原码 5
	//     00000000000000000000000000000101反码
	//     00000000000000000000000000000101补码
	//  00|00000000000000000000000000010100     20
	//     二进制位往左移两位
	printf("%d", a);
	return 0;
}

 左移的规则：左边的抛弃、右边空缺的补0

二.右移操作符    >>

#include <stdio.h>
int main()
{
	int i = -5;
	i = i >> 2;
	//   10000000000000000000000000000101 原码    -5
	//   11111111111111111111111111111010 反码
	//   11111111111111111111111111111011 补码
	//   二进制位往右移两位
	//   11111111111111111111111111111110|11   补码
	//   11111111111111111111111111111101 反码
	//   10000000000000000000000000000010 原码    -2
	printf("%d", i);
	return 0;
}

右移的规则：

1. 逻辑移位左边用0填充，右边丢弃 

2. 算术移位左边用原该值的符号位填充，右边丢弃（现在的编译器一般为第二种移位规则）

*******对于移位计算符，需要注意的是：

不要移动负数位，这个是标准未定义的

3.位操作符

&    按位与                        |       按位或                        ^     按位异

它们的操作数必须为整数

用一道练习来加深理解：

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

#include <stdio.h>
int main()
{
	int a = 5;
	int b = 3;
	printf("打印前：a=%d,b=%dn", a, b);
	a = a ^ b;
	b = a ^ b;//此时的a = a^b,所以 b = a^b = a^b^b 。此处b^b=0 , b = a^(b^b)= a^0 = a
	a = a ^ b;//由上可知b = a , a = a^b ,所以a = a^b^b 。此处a^a=0 , a = (a^a)^b = b
	printf("交换后: a=%d,b=%dn", a, b);
	return 0;
}

4.单目操作符

sizeof

#include <stdio.h>
int main()
{
	int a = 0;
	printf("%dn", sizeof(int));
	printf("%dn", sizeof a);
//  printf("%dn",sizeof int);这是错误的写法
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%dn", sizeof(arr));//4×10=40
	printf("%dn", sizeof(ch)); //1×10=10
	return 0;
}

1.使用sizeof求操作数的类型长度时，其中变量可以不用括号，但是基本类型就需要

2.sizeof()内部单独放一个数组名，数组名表示整个数组，所求也是整个数组的大小

3.sizeof（）返回的的值类型为size_t(无符号整型)，会将括号里的值自动转化为无符号整型

4.sizeof（）内部不会进行计算，如下

#include <stdio.h>
int main()
{
	short s = 20;
	int a = 5;
	printf("%dn", sizeof(s = a + 4));//（）里面s=a+4不会进行计算，s仍旧为20
	printf("%dn", s);
	return 0;
}

 只会求出里面s的值属性（short型）

！

#include <stdio.h>
int main()
{
	printf("%dn", !2);
	printf("%dn", !0);
	return 0;
}

逻辑反操作符，将真（非零）转化为假（零），将假（零）转化为真（规定转化为1）

五.逻辑操作符

&&      逻辑与

||         逻辑或

#include <stdio.h>
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++ && ++b && d++;
    //i = a++||++b||d++;
    printf("a = %dn b = %dn c = %dnd = %dn", a, b, c, d);
    return 0;
}

&&,左边操作数为假，则右边不计算

例如图中i = a++ && ++b && d++,a++&&++b,左边操作数a++为0，则右边不计算（a++&&++b）结果为0。同理因为（a++&&++b）=0，所以i=（a++&&++b）&& d++，左边操作数为0，右边d++也不计算，i的结果为0。

||，左边操作数为真（与&&相反），则右边不计算

同时需要区分：

1.&  按位与     |      按位或    是针对二进制的

2.&&    逻辑与     ||    逻辑或     只关注真假

六.下标引用、结构成员操作符

结构成员操作符       '  ->  '       '  .  '

#include <stdio.h>
struct Stu
{
	char name[20];
	int age;
	double score;
};
int main()
{
	struct Stu z = { "张三",18,95 };
	struct Stu* p = &z;
	printf("%s %d %lfn", z.name, z.age, z.score);
	printf("%s %d %lfn", p->name, p->age, p->score);
	return 0;
}

下标引用操作符       [  ]

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//printf("%dn", arr[7]);//[] 就是下标引用操作符，arr,7是操作数
	//也可以换种书写形式   arr[7]--> *(arr+7) --> *(7+arr)-->7[arr]
	printf("%dn", arr[7]);
	printf("%dn", 7[arr]);
	return 0;
}

arr[7]等价于7[arr]，无用的小知识又增加了

整型提升

表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为 整型

提升 。

#include <stdio.h>
int main()
{
	char a = -1;
    //补码
    //11111111111111111111111111111111
	//char 变量a（二进制补码）只有8个比特位：
    //会发生截断
	//11111111
    //整型提升时，高位补充符号位
  //即11111111111111111111111111111111
	return 0;
}

1.整数负数的整型提升，高位补充符号位。

2.无符号的整型提升，高位补充0。

进行运算才会整型提升

分析两段代码：

int main()
{
 char a = 0xb6;
 short b = 0xb600;
 int c = 0xb6000000;
 if(a==0xb6)//比较也属于运算，a,b均进行了整型提升
 printf("a");
 if(b==0xb600)
 printf("b");
 if(c==0xb6000000)
 printf("c");
 return 0;
 }

整型提升分两种方式：

1.算术提升：在最前面补符号位数字，直到32位

2.逻辑提升：无论什么都只补0，直到32位

大多数计算器都是进行算术提升，这里也是算术提升

0xb6的二进制为

00000000000000000000000010110110

存进a（char，1个字节），发生截断，得到10110110

0xb600的二进制为

00000000000000001011011000000000

存进b（short，2个字节），发生截断，得到10110110 00000000

0xb6000000的二进制为

10110110000000000000000000000000

存进C（int，4个字节）中刚刚好满足

如a进行了整型提升，变为

11111111111111111111111110110110

所以整型提升后的a与0xb6不相等了

int main()
{
 char c = 1;
 printf("%un", sizeof(c));
 printf("%un", sizeof(+c));
 printf("%un", sizeof(-c));
 return 0;
 }

c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字

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

---

算术转换

long double

double

float

unsigned long int

long int

unsigned int

int

上面是等级表， 从上往下 ， 从高到低 。

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

算。

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

此时int等级小于float，会把a算术转换为float型再进行计算

---

操作符篇完结