原码、反码、补码与操作符

算术操作符

如+ - * ，不作过多讨论。
/，两边都为整数，执行整数除法。只要有浮点数，就执行浮点数除法。
%，两边操作数要均为整数，返回整除后的余数。、

移位操作符

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

左移操作符

左移操作符 移位规则：
左边抛弃、右边补0
如
3 << 2，则是将数字3左移2位 计算过程： 3 << 2 首先把3转换为二进制数字0000 0011，然后把该数字高位(左侧)的两个零移出，其他的数字都朝左平移2位，最后在低位(右侧)的两个空位补零。则得到的最终结果是0000 1100，则转换为十进制是12。

右移操作符

首先右移运算分两种：

1. 逻辑移位 左边用0填充，右边丢弃
2. 算术移位 左边用原该值的符号位填充，右边丢弃
3. 对于移位运算符，不要移动负数位，这个是标准未定义的。

位操作符

& 按位与

运算规则：只有两个数的二进制同时为1，结果才为1，否则为0。（负数按补码形式参加按位与运算）

| 按位或

运算规则：参加运算的两个数只要两个数中的一个为1，结果就为1。
例：3 &5 即 00000011 & 00000101 = 00000001 ，所以 3 & 5的值为1。

^ 按位异或

运算规则：参加运算的两个数，如果两个相应位为“异”（值不同），则该位结果为1，否则为0。

原码、反码和补码

三种表示方法均有符号位和数值位两部分，符号位都是0表示正，用1表示负。

原码

直接将二进制按照正负数的形式翻译

反码

原码的符号位不变，其他位依次按位取反

补码

反码+1
注意：正数的原码、反码、补码都相同

概括

! 逻辑反操作

• 负值

• 正值
  & 取地址
  sizeof 操作数的类型长度（以字节为单位）
  ~ 对一个数的二进制按位取反
  – 前置、后置–
  ++ 前置、后置++

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

(类型) 强制类型转换

++和–

前置++和前置–

#include <stdio.h>
int main()
{
int a = 10;
int x = ++a;
//先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。
int y = --a;
//先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;
return 0;
}

后置++和–

#include <stdio.h>
int main()
{
int a = 10;
int x = a++;
//先对a先使用，再增加，这样x的值是10；之后a变成11；
int y = a--;
//先对a先使用，再自减，这样y的值是11；之后a变成10；
return 0;
}

sizeof

sizeof可以求变量（类型）所占空间的大小
注意：1、sizeof是操作符，不是函数
2、sizeof是计算变量或者类型创建变量的内存大小，和内存中存放什么数没有关系。
以32位为例子

int a = 0;
sizeof(a);//为4
sizeof a;//等同
sizeof(int);//也为4
sizeof int;//编译器不允许
short s = 0;
sizeof(s = a + 2);//发生阶段，为2，sizeof内部不参与运算
int arr[10] = { 1,2.3,4,5 };
sizeof(arr);//为10
strlen(arr);//为5

关系操作符

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

逻辑操作符

&& 逻辑与，两边为真则才为真，一边假为假。
|| 逻辑或，一边为真就为真，两边为假则为假。
但注意，当逻辑操作符的左边能判断出真假，就不会执行右边的
例子

#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++为后置++，++前a为0，逻辑与已经为假，后面不执行，然后i=0，a=1，bcd不变。

三目操作符

条件操作符

exp1 ? exp2 : exp3
解析：exp1为真，则该操作符结果为exp2，否则为exp3
如

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

能改成

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

逗号表达式

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

int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);

最后结果为a=12，b=13，c=13。

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

[]下标引用操作符

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

int arr[10];//创建数组
arr[9] = 10;//实用下标引用操作符。

[ ]的两个操作数是arr和9。
如果是引用，arr[4]与*(arr+4)效果是一样的

2.( ) 函数调用操作符

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

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

3.访问一个结构的成员
. 结构体.成员名
-> 结构体指针->成员名

#include <stdio.h>
struct Book
{
	char name[20];
	float price;
	char id[10];
};
void print1(struct Book b)
{
	printf("书名:%s\n", b.name);//结构成员访问
	printf("价格:%f\n", b.price);
	printf("书号:%s\n", b.id);
}
int main()
{
	struct Book b = { "C语言程序设计",55.5f,"C20190201" };//称这本书为b，进行初始化
	print1(b);
	return 0;
}

可以把print1写成这样：

void pirnt2(struct Book* pb)
{
	printf("书名:%s\n", (*pb).name);//结构成员访问
	printf("价格:%f\n", (*pb).price);
	printf("书号:%s\n",(*pb).id);
}

传参时把b的地址传过去：print2(&b)
也能打印。
但这样并不好
改成下面这样个更清晰

void pirnt2(struct Book* pb)
{
	printf("书名:%s\n", pb->name);
	printf("价格:%f\n", pb->price);
	printf("书号:%s\n", pb->id);
}

表达式求值

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

隐式类型转换

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

整型提升的意义：

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

例子

char a = 3;//char 是1字节，8bit
//00000000000000000000000000000011          计算时是int，4字节，32bit,进行整形提升，内存存储补码
//00000011 - a
char b = 127;
//00000000000000000000000001111111也是补码
//01111111 - b
char c= a+b;
//00000000000000000000000000000011
//00000000000000000000000001111111+
//=00000000000000000000000010000010  补码

//10000010 - c，1是符号位
//11111111111111111111111110000010  因为是负数，进行整形提升，补符符号位
//11111111111111111111111110000001  补码-1反码
//11111111111111111111111110000010  除符号位之外，按位取反，原码
//为-126
printf("%d",c);

例子2

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) 是4个字节.表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof© ,就是1个字节

算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。
long double
double
float
unsigned long int
long int
unsigned int
int
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
警告： 但是算术转换要合理，要不然会有一些潜在的问题。

操作符的属性

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

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

a*b + c*d +  e*f