目录
一.各种操作符的介绍
1.算术操作符
+ - * / %
int main()
{
int a = 10;
int b = 5;
int sum = a + b;
printf("%d\n", sum);// +
// 15
int jian = a - b;
printf("%d\n", jian);// -
// 5
int ji = a * b;
printf("%d\n", ji);// *
// 50
int chu = a / b;
printf("%d\n", chu);// /
// 2
int yu = a % b;
printf("%d\n", yu);// %
// 0
return 0;
}
注意：
- 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
- 对于 / 操作符如果两个操作数都为整数（除数中不可以为0），执行整数除法。而只要有浮点数执行的就是浮点数除法（除号两端至少有一个小数）。
- % 操作符的两个操作数必须为整数。返回的是整除之后的余数。
int main()
{
double a = 7 / 2.0;
printf("%lf\n", a);//3.500000
return 0;
}
2.移位操作符
<< 左移操作符
<< 右移操作符
注：移位操作符的操作数只能是整数。移动的是二进制。
计算机能够识别的是二进制的信息
比如15是十进制数字，要把它变成二进制计算机才能理解。
整数的三种二进制表示形式：
原码
反码
补码
1.正整数的原码、反码、补码是相同的
2.负整数的原码、反码、补码需要计算
首先不管是正整数还是负整数都可以写出二进制原码
1.根据正负直接写出的二进制序列就是原码（以15为例）
a=15————1111
1个整型是4个字节=32个bit位
00000000000000000000000000001111——原码、反码、补码
最高位是符号位，符号位是1，表示负数；符号位是0，表示正数
b=-15
10000000000000000000000000001111——原码
111111111111111111111111111111110000——反码（原码的符号位不变，其他按位取反）
111111111111111111111111111111110001——补码（反码+1）
整数在内存中存储的是补码，计算的时候也是使用补码计算的。
移位移动的是补码的二进制位
2.1右移
算术右移（右边丢弃，左边补原来的符号位）
逻辑右移（右边丢弃，左边补0）
一般编译器上采用的是算术右移
整数
int a = 15;
int b = a >> 1;
printf("%d\n", b);//7
补码是00000000000000000000000000000111，因为正整数的原码、反码、补码是相同的，所以结果为7
负数
int a = -15;
int b = a >> 1;
printf("%d\n", b);//-8
移位后得到的是补码，而最终的值是原码来表示的，所以计算的方法就按原码求补码的方式倒过来就行了。
2.2左移
左边丢弃，右边补0
int a = 6;
int b = a << 1;
printf("%d\n", b);//12
正整数6的补码是00000000000000000000000000000110，移位后00000000000000000000000000001100，结果为12
注意：对于移位运算符，不要移动负数位，这个是标准未定义的。
int num = 10;
num>>-1;//error
3.位操作符
& 按位与
| 按位或
^ 按位异或
注：他们的操作数必须是整数。
int a = 3;
int b = -5;
int c = a & b;
printf("%d\n", c);//3
3的补码是00000000000000000000000000000011，-5的原码是10000000000000000000000000000101，按位取反后反码是11111111111111111111111111111010，+1后补码是11111111111111111111111111111011
&——对应二进制位有0则为0，两个同时为1，才是1
3的补码是00000000000000000000000000000011
-5的补码是11111111111111111111111111111011
得到的是00000000000000000000000000000011，结果为3
int a = 3;
int b = -5;
int c = a | b;
printf("%d\n", c);//-5
| ——对应的二进制位有1则为1，两个同时为0才是0
3的补码是00000000000000000000000000000011
-5的补码是11111111111111111111111111111011
得到的是11111111111111111111111111111011（补码）
反码：11111111111111111111111111111010
原码：10000000000000000000000000000101，结果为-5
int a = 3;
int b = -5;
int c = a ^ b;
printf("%d\n", c);//-8
^ ——对应的二进制位相同为0，相异为1
3的补码是00000000000000000000000000000011
-5的补码是11111111111111111111111111111011
得到的是11111111111111111111111111111000（补码）
反码：11111111111111111111111111110111
原码：10000000000000000000000000001000，结果为-8
一道题：交换2个整型变量，不能创建临时变量
a^a=0
a^0=a
第一个表达式代入第二个表达式，b=a ^ b ^ b，因为b^b=0，a ^ 0=a，所以在第二个表达式时相当于把a赋给b；同理，第二个表达式代入第三个表达式，a=a ^ a ^ b，因为a ^ a=0，0 ^ b=b，所以在第三个表达式时相当于把b赋给a，就完成了两个数的交换。（不能创建临时变量导致这个代码可读性和效率不高，因此不常使用）
练习：编写代码实现：求一个整数存储在内存中的二进制中1的个数。
方法1：
1.整数有32个bit位
2.获得32个bit位的每一位
3.判断这一位是否为1
4.是1计数器就加1
代码：
int main()
{
int n = 0;
scanf("%d", &n);//15
int count = 0;
int i = 0;
for (i = 0; i < 32; i++)
{
if ((n >> i) & 1 == 1)
{
count++;
}
}
printf("%d\n", count);//4
return 0;
}
方法2：
每次让n这个数二进制中最右边的1消失，对应执行一次去掉一个1计数器+1
代码：
int main()
{
int n = 0;
scanf("%d", &n);//15
int count = 0;
while(n)
{
n = n & (n - 1);
count++;
}
printf("%d\n", count);//4
return 0;
}
4.赋值操作符
4.1赋值操作符=
可以给自己赋值，也可以给自己重新赋值
int weight = 120;//体重
weight = 89;//不满意就赋值
double salary = 10000.0;
salary = 20000.0;//使用赋值操作符赋值
赋值操作符可以连续使用：
int a = 10;
int x = 0;
int y = 20;
a = x = y+1;//连续赋值
但是这种写法不是很清晰，如果改成：
x = y+1;
a = x;
这样的写法是不是更加清晰爽朗而且易于调试。
4.2复合操作符
有：+=、-=、*=、/=、%=、>>=、<<=、&=、|=、^=
例：
int a = 10;
a += 2;//a = a + 2
printf("%d\n", a);//12
int b = 10;
b -= 2;//b = b - 2
printf("%d\n", b);//8
int c = 10;
c *= 2;//c = c * 2
printf("%d\n", c);//20
int d = 10;
d /= 2;//d = d / 2
printf("%d\n", d);//5
int e = 10;
e %= 3;//e = e % 3
printf("%d\n", e);//1
int f = 6;
f <<= 1;//f = f << 1
printf("%d\n", f);//12
int g = 15;
g >>= 1;//g = g >> 1
printf("%d\n", g);//7
int h = 13;
h &= 1;//h = h & 1
//00000000000000000000000000001101
//00000000000000000000000000000001
//00000000000000000000000000000001
printf("%d\n", h);//1
int i = 13;
i |= (1 << 4);//i = i | (1 << 4)
//00000000000000000000000000001101
//00000000000000000000000000010000
//00000000000000000000000000011101
printf("%d\n", i);//29
int j = 13;
j ^= 1;//j = j ^ 1
//00000000000000000000000000001101
//00000000000000000000000000000001
//00000000000000000000000000001100
printf("%d\n", j);//12
5.单目操作符
》 ! 逻辑反操作
》 - 负值
》 + 正值
》 & 取地址
》 sizeof 操作数的类型长度（以字节为单位）
》 ~ 对一个数的二进制按位取反
》 – 前置、后置–
》 ++ 前置、后置++
》 * 间接访问操作符(解引用操作符)
》 (类型) 强制类型转换
单目操作符只有一个操作数；双目操作符有两个操作数。
5.1 ! 逻辑反操作
int main()
{
int a = 0;//把a改成不为0，结果相反
if (!a)//a=0原来为假，逻辑反操作符让它变成真，所以打印hhh
{
printf("hhh\n");
}
if (a)//a=0为假，所以不打印
{
printf("ooo\n");
}
return 0;
}
5.2 - 负值
例如：
-5
-1
5.3 + 正值
例如：
3
6
5.4 & 取地址 和 * 间接访问操作符(解引用操作符)
int a = 10;
int* pa = &a;//取出a的地址
*pa = 20;//通过pa的中存放的地址，找到指向的空间
int c = *pa;
printf("%d\n", c);//20
5.5 sizeof 操作数的类型长度（以字节为单位）
sizeof计算的是类型创建变量的大小，单位是字节
int a = 9;
printf("%d\n", sizeof (int));//4
printf("%d\n", sizeof (a));//4
printf("%d\n", sizeof a);//4
int arr[10] = { 0 };
printf("%d\n", sizeof(arr));//40
printf("%d\n", sizeof(int [10]));//40
printf("%d\n", sizeof(int[5]));//20
char ch[10] = { 0 };
printf("%d\n", sizeof(ch));//10
printf("%d\n", sizeof(ch[0]));//1
注意：如果数组用函数调用传过去，传的是首元素的地址，也就是指针，char*，int* 都是占4个字节
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//4
}
void test2(char ch[])
{
printf("%d\n", sizeof(ch));//4
}
5.6 ~ 对一个数的二进制按位取反
int a = 0;
printf("%d\n", ~a);//-1
a的二进制补码：00000000000000000000000000000000
按位取反补码：11111111111111111111111111111111
反码：11111111111111111111111111111110
原码：10000000000000000000000000000001，结果为-1
一个数怎样还原回去：
int a = 12;
//00000000000000000000000000001100 12的补码
a |= 3;
//00000000000000000000000000000011 3的补码
printf("%d\n", a);//15
//00000000000000000000000000001111 15的补码
a &= (~3);
//11111111111111111111111111111100 3的补码按位取反
//00000000000000000000000000001111 15的补码
//00000000000000000000000000001100 12的补码
printf("%d\n", a);//12
多组输入的另一种写法：
//方法1
int a = 0;
//scanf 读取失败返回的是EOF
while (scanf("%d", &a) != EOF)
{
printf("%d\n", a);
}
//方法2
int b = 0;
//假设scanf 读取失败，返回EOF-->-1
//11111111111111111111111111111111 -1的补码
//00000000000000000000000000000000 按位取反为0，0为假
while (~scanf("%d", &b))
{
printf("%d\n", b);
}
5.7 前置、后置-- 和 前置、后置++
int a = 1;
int b = a++;//后置++ :先使用，后++
printf("a=%d b=%d\n", a, b);//a=2,b=1
int c = 1;
int d = c--;//后置-- :先使用，后--
printf("c=%d d=%d\n", c, d);//c=0,d=1
int e = 1;
int f = ++e;//前置++：先++，后使用
printf("e=%d f=%d\n", e, f);//e=2,f=2
int g = 1;
int h = --g;//前置--：先--，后使用
printf("g=%d h=%d\n", g, h);//g=0,h=0
5.8 (类型) 强制类型转换
int a = (int)3.55;//强制转换成int类型
printf("%d\n", a);//3
6.关系操作符
有：>、<、<=、>=、!=、==
!= 用于判断不相等
== 用于判断相等
7.逻辑操作符
&& 逻辑与 —— 并且
|| 逻辑或 —— 或者
int a = 8;
int b = 9;
if (a == 8 && b == 9)//两个条件都要满足
{
printf("hhh\n");//打印hhh
}
if (a == 6 || b == 9)//一个条件满足即可
{
printf("kkk\n");//打印kkk
}
一道题：
int main()
{
int i = 0, a = 1, b = 2, c = 3, d = 4;
// 一：i = a++ && ++b && d++;//2 3 3 5
// 二：i = a++||++b||d++;//2 2 3 4
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
return 0;
}
一：a=1为真，可以计算&&右边的内容，++b为3，a++为2，c不变，因为a++ && ++b 整体为真，所以可以计算d++为5；
二：a=1为真，不计算||右边的内容，b不变，a++为2，c不变，因为a++||++b 整体为真，所以不计算d++，d不变。
&& 操作符，左边为假，右边不计算；
|| 操作符，左边为真，右边不计算。
8.条件操作符
exp1 ? exp2 : exp3
也叫三目操作符（有3个操作数）
表达式1为真，表达式2计算，表达式3不计算；
表达式1为假，表达式3计算，表达式2不计算。
int a = 0;
int b = 0;
b = (a > 1) ? 4 : 6;//表达式为假
printf("%d", b);//6
9.逗号表达式
exp1, exp2, exp3, …expN
从左向右依次执行，整个表达式的结果是最后一个表达式的结果。
int a = 1;
int b = 2;
int c = (a > b, a = b + 10, a, b = a + 1);
printf("%d\n", c);//13
10.下标引用、函数调用和结构成员
[ ] 下标引用操作符
操作数：一个数组名 + 一个索引值
int arr[10];//创建数组
arr[9] = 10;//实用下标引用操作符。
[ ]的两个操作数是arr和9。
( ) 函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
int len = strlen("abc");//操作数是 strlen "abc"
printf("%d\n", len);//3
结构成员操作符
. 结构体.成员名
-> 结构体指针->成员名
在结构体中用到：
struct Book
{
char name[30];
char author[20];
int price;
};
void test(struct Book* p)
{
printf("%s %s %d\n", p->name, p->author, p->price);//西游记 , 吴承恩 ,101
}
int main()
{
struct Book b = { "西游记","吴承恩",101 };
printf("%s %s %d\n", b.name, b.author, b.price);//西游记 , 吴承恩 ,101
test(&b);
return 0;
}
二.表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。
1.隐式类型转换
C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
char c1 = 5;
char c2 = 127;
char c3 = c1 + c2;//发生整型提升
printf("%d\n", c3);//-124
整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度，一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。
如何进行整体提升：
整形提升是按照变量的数据类型的符号位来提升的
5的二进制位（补码）：00000000000000000000000000000101
把它放在char类型变量里面，一个char类型是一个字节=8个bit位
截断后：00000101 （c1存放8个bit位）
127的二进制位（补码）：00000000000000000000000001111111
同理，截断后：01111111 （c2存放8个bit位）
c1：00000101 整型提升，符号位是0，所以为：
00000000000000000000000000000101
c2：01111111 整型提升，符号位是0，所以为：
00000000000000000000000001111111
再相加，得 c3：00000000000000000000000010000100
c3再发生截断：10000100
c3 整型提升，符号位为1，所以为：
11111111111111111111111110000100 （补码）
11111111111111111111111110000011 （反码）
10000000000000000000000001111100 （原码）结果为-124
注意：以上是有符号整型；无符号整形提升，高位补0。
2.算术转换
如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
3.操作符的属性
复杂表达式的求值有三个影响的因素：
1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。
两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
通常情况下，我们可以直接选择用（）将其中的某些表达式括起来，这样就可以先计算（）里的表达式。
如果我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。
402
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
