C语言初阶-操作符详解（1）
1.操作符分类：
算数操作符、移位操作符、位操作符、赋值操作符、单目操作符、关系操作符、逻辑操作符、条件操作符、逗号操作符、下标引用、函数调用和结构体成员
2.算数操作符
+ - * / %
加减乘都很简单，下面主要介绍除法 / 和取余 %
/ 除法：
1.整数除法（除号两端都是整数）
2.浮点数除法（除号两端只要有一个小数就执行小数除法）
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 7 / 2;
printf("%d\n", a);
return 0;
} 上述代码运行结果是：3。因为除号两端都是整数，所以进行整数除法，7/2=3余1，结果保留整数2。这时有人说了，要得到3.5不是要用浮点型进行接收吗？
下面我们来实验一下：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 7 / 2;
printf("%d\n", a);
double b = 7 / 2;
printf("%lf\n", b);
return 0;
} 运行结果：
结果我们可以看到还是3，所以说不管我们用什么类型，只要除号两端的数都是整数，它计算的结果都是只保留整数部分的结果。那么我们要怎么得到小数呢？
只需将除号两端的数中的任意一个改成小数就可以了：
上图将7改为7.0，最终结果变为3.5。当然也可以将2改为2.0。
注意：除法中，除数不能为0。否则编译器会报错：
% 取余：得到的是整除后的余数。
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int b = 19 % 5;
printf("%d\n", b);
return 0;
} 以上代码结果为：4。因为18/5=3余4，%操作符得到的结果就是余数4。
注意：取余操作符的两个操作数必须都是整数。
3.移位操作符
<< 左移操作符
>> 右移操作符
注： 移位操作符的操作数只能为整数
移位操作符移动的是二进制的信息。因为计算机识别的都是二进制数，我们在输入十进制数或者其他进制的数时，在计算机中都是以二进制存储的。
学过计算机的应该都知道，整数的二进制表示形式有三种：原码、反码和补码。
正整数的原码、反码、补码是相同的。而负整数的原码、反码、补码是要计算的。
首先不管是正整数还是负整数都可以写出二进制原码
1.根据正负直接写出的二进制序列就是原码
例如：int a = 15;
a写成二进制就是：1111。因为1个整型是4个字节 = 32bit位，a为正整数，所以a的原码、反码和补码用二进制表示为：00000000000000000000000000001111
其中最高位是符号位：
那 int b = -15，b的原码就是 10000000000000000000000000001111
而负数的反码是符号位不变，其他位按位取反：11111111111111111111111111110000
负数的补码是在它的反码的基础上加1:11111111111111111111111111110001
注意：整数在内存中存储的是补码，所以计算的时候也是用补码，比如我们一会要说的移位就是在补码上操作的。
移位移动的是补码的二进制序列。
>> 右移操作符
在学习右移操作符之前我们要知道右移有两种：
1.算数右移：右边丢弃，左边补原来的符号位
2.逻辑右移：右边丢弃，左边补0
C语言没有明确规定使用算数右移还是逻辑右移，但是一般编译器使用的是算数右移
下面我们看一段代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 15;
int b = a >> 1;
printf("%d\n", b);
printf("%d\n", a);
return 0;
} 运行结果：
上述代码中a = 15经过右移一位后得到的结果是7。下面我们来分析一下为什么会得到7：
因为a是正数，它的原码、反码和补码都是：00000000000000000000000000001111
经过算数右移后变为：00000000000000000000000000000111，输出十进制数就得到了7
以上是正整数的移位操作，下面我们来看一下负整数的移位操作，它们的移位过程是否一样呢？
看下面的一段代码及运行结果：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = -15;
int b = a >> 1;
printf("%d\n", b);
return 0;
} 运行结果为：-8。
我们先写出-15的原码二进制表示形式：10000000000000000000000000001111（负数符号位为1）
将-15的原码转换为补码为：11111111111111111111111111110001
将其补码右移一位：11111111111111111111111111111000
我们知道在内存中存储的是补码的二进制形式，但是在打印输出时用的是原码，所以再将右移后的补码转换为原码的二进制表示为：10000000000000000000000000001000，输出十进制数就得到了-8。
这里再补充说明一下负数的补码化为原码的两种方法：
方法1 由于负数的原码转化为补码的过程是，将其原码除符号位以外的其他位取反再加一，那么负数的补码转化为原码的过程完全可以反向进行，即将补码先减一，再将除符号位的其他位取反。
方法2 直接将负数的补码除符号位以外的其他位取反再加一，这样也可以得到原码。
<< 左移操作符
左移操作符的规则很简单：左边丢弃，右边补0
下面我们看一段代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 6;
int b = a << 1;
printf("%d\n", b);
return 0;
} 运行结果：12。
因为a是正整数，原、反、补码都是：00000000000000000000000000000110
左移一位补码为：00000000000000000000000000001100，
原码同补码：00000000000000000000000000001100，输出十进制数就得到12。
注意：对于移位操作符来说，不要移动负数位，这是标准未定义的。
4.位操作符
& 按位与
| 按位或
^ 按位异或
注：位操作符的操作数必须为整数
& 按位与
看下面一段代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 3;
int b = -5;
int c = a & b;
printf("%d\n", c);
return 0;
} 运行结果：3
在计算机中a的补码为：00000000000000000000000000000011
b的补码为：11111111111111111111111111111011
按位与的规则是：对应的二进制位只要有一个为0，则按位与后的结果为0，两边同时为1，按位与后的结果才为1
那么a&b的补码就是：00000000000000000000000000000011
化为原码：00000000000000000000000000000011，输出十进制数就得到3
| 按位或
看下面一段代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 3;
int b = -5;
int c = a | b;
printf("%d\n", c);
return 0;
} 运行结果：-5
在计算机中a的补码为：00000000000000000000000000000011
b的补码为：11111111111111111111111111111011
在计算机中按位或的规则是：对应的二进制位只要有一个1按位或后的结果就是1，两边同时为0，按位或的结果才为0
那么a | b的补码用二进制表示为：11111111111111111111111111111011
化为原码：10000000000000000000000000000101，输出十进制数为-5
^ 按位异或
看下面一段代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 3;
int b = -5;
int c = a ^ b;
printf("%d\n", c);
return 0;
} 运行结果：-8
在计算机中a的补码为：00000000000000000000000000000011
b的补码为：11111111111111111111111111111011
在计算机中按位异或的规则是：对应的二进制位相同为0，相异为1
那么a^b的补码用二进制表示为：11111111111111111111111111111000
化为原码：10000000000000000000000000001000，输出十进制数为-8
位操作符的使用示例：
1.规定不能创建临时变量，实现两数的交换
前面我们学过交换两个变量的值，通过创建临时变量tmp实现：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 3;
int b = 5;
printf("交换前：a=%d b=%d\n", a, b);
int tmp = a;
a = b;
b = tmp;
printf("交换后：a=%d b=%d\n",a,b);
return 0;
} 那如果规定不能创建临时变量，如何实现两数的交换？
这时就要用到我们的按位异或操作符 ^ 了。
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 3;
int b = 5;
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);
return 0;
} 运行结果：
这就是代码实现啦，具体过程可以根据按位异或的规则自己分析一下。
下面还有几种常见的使用方法：
a ^ a = 0 a ^ 0 = a a ^ b ^ a = a ^ a ^ b = b（异或满足交换律）
这个也可以用来解释上述代码：将a = a ^ b带入b = a ^ b得到b = (a ^ b) ^ b = a
然后将a = a ^ b和b = a代入a = a ^ b得到a = (a ^ b) ^ a = b，这样就实现了两数的交换。
2.编写代码实现：求一个整数存储在内存中的二进制中的1的个数
直接看代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 0;
int count = 0;
scanf("%d", &a);
int i = 0;
for (i = 0; i < 32; i++)
{
if ((a>>i) & 1 == 1)
{
count++;
}
}
printf("%d\n", count);
return 0;
}
任何数和1相与就能得到它的最低位，比如5&1，如下图：
我们要求一个整数存储在内存中的二进制中的1的个数，就要知道它的补码的每一位，任何数和1相与都能得到最低位，那我们每次将这个整数向右移1位再和1相与就能得到这个整数的每一位，然后写if语句判断每一位是否等于1，满足条件计数器加一，又因为整数在计算机中有32个bit位，外面再写for循环直到将32位每一位都判断完就结束循环，如此以来就实现了题目要求。
5.赋值操作符
=
复合赋值操作符：
+= -= *= /= %= >>= <<= &= |= ^=
赋值操作符很好用，他可以将你不喜欢的值进行修改。初始化一个变量的值不是你想要的，那就可以在后面用赋值操作符进行修改。
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 10;
a = 20;
printf("%d\n", a);
return 0;
} 上述代码初始化a为10，下面可以将a重新赋值位20，最终输出的也是20.
复合赋值操作符用法都相似，这里只说一下+=，其他的与之用法相同
看下面一段代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 10;
a += 1;
printf("%d\n", a);
return 0;
}
运行结果：11
由此可见，a += 1;和a = a + 1;的效果一样，前者可以看做是后者的一种简写方式。
以此类推，-=，*=，/=，.......与其用法相似。
6.单目操作符
单目操作符只有一个操作数
！ 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof 操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
-- 前置、后置--
++ 前置、后置++
* 间接访问操作符（解引用操作符）
（类型）强制类型转换
！ 逻辑反操作
逻辑反操作符的作用就是将真的变成假的，假的变成真的
比如下面代码中的两个if语句的作用都是一样的：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 0;
if (a == 0)
{
printf("hehe\n");
}
if (!a)
{
printf("hehe\n");
}
return 0;
}
运行结果：
第一个if语句是当满足a=0的时候执行，第二个if中a=0为假，而!a将其变为真，也执行了if语句，其作用就是当a为假时，打印hehe。
-、+这两个操作符很简单，就不多讲了。
& 取地址和 * 间接访问操作符（解引用操作符）
这两个都用于指针，可以放在一块讲。
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 10;
//pa是指针变量
int* pa = &a;//&-取地址操作符-取出a的地址
*pa = 20;//解引用操作符（间接访问操作符）-单目操作符-通过pa中存放的地址，找到其指向的空间（内容）
printf("%d\n", a);
return 0;
} 运行结果：20
代码中&a是取出a的地址，pa是指针变量，用来存放a的地址，而*pa=20是通过pa中存放的地址，找到其存放的a的值并将其改为20.
sizeof 操作数的类型长度（以字节为单位）
注意：sizeof是操作符不是函数，sizeof计算的是类型创建变量的大小，以字节为单位
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 10;
printf("%d\n", sizeof(int));
printf("%d\n", sizeof(a));
printf("%d\n", sizeof a);
return 0;
} 运行结果：
由此可证明sizeof计算的是类型创建变量的大小，以字节为单位
它既可以通过类型计算大小（sizeof(int)），也可以通过变量计算大小（sizeof(a)）。
sizeof 后面跟变量时也可以不用带括号，由此可证明sizeof确实不是函数，因为我们在使用函数时都是要带括号的。
我们在前面也学过用sizeof计算数组的大小，如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int arr[10] = { 0 };
printf("%d\n", sizeof(arr));
return 0;
}
运行结果：40
因为数组中有10个元素，每个元素都是int型，4个字节，所以数组大小为40个字节
同样我们也可以通过类型计算数组的大小，数组的类型是：int [10]（即去掉数组名arr）
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int arr[10] = { 0 };
printf("%d\n", sizeof(int [10]));//通过类型计算数组大小
return 0;
} ~ 对一个数的二进制按位取反
看下面代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 0;
printf("%d\n", ~a);
return 0;
} 运行结果：-1
为什么是-1呢？
a在计算机中二进制表示形式为：00000000000000000000000000000000
~a在计算机中二进制表示形式为：11111111111111111111111111111111，这是补码，转化为原码为：10000000000000000000000000000001，输出十进制数为-1。
那学完~操作符，我们就可以来举一个示例了：
题目：要求把13的第五位二进制改成1，其他位不变
要实现只将第五位给为1，其他位不变，给它或上00000000000000000000000000010000就行，而00000000000000000000000000010000可以通过将1左移4位得到。
代码实现：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 13;
a |= (1 << 4);
printf("%d\n", a);
return 0;
} 运行结果：29。即（00000000000000000000000000011101）
同样也可以通过按位取反操作符~将其还原：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 13;
a |= (1 << 4);
a &= (~(1 << 4));
printf("%d\n", a);
return 0;
} 运行代码：13。
在这里按位取反操作符还可以应用于多组输入类问题：
下面是前面我们学习的多组输入的写法：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 0;
while (scanf("%d", &a) != EOF)//scanf读取失败返回EOF
{
printf("%d\n", a);
}
return 0;
}
上面代码可以实现多组输入，下面我们可以用按位取反操作符来实现多组输入类问题：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 0;
while (~scanf("%d", &a))
{
printf("%d\n", a);
}
return 0;
}
那原理是什么呢？
因为读取失败返回EOF，而EOF相当于-1（我们可以右击EOF点击查看定义看到），而前面加~，-1就变成0,0为假，循环结束。所以只要没有读取失败，就会多组输入，直到读取失败返回EOF。
前置、后置--和前置、后置++
前置++：先自增，再使用
后置++：先使用，后自增
前置++：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 3;
int b =++a;//先自增为4，然后赋值给b
printf("a=%d b=%d\n",a, b);
return 0;
} 运行结果：
后置++：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = 3;
int b =a++;//先赋值给b，再自增为4
printf("a=%d b=%d\n",a, b);
return 0;
}
运行结果：
前置、后置--和前置、后置++ 的用法相似，不再多讲。
（类型）强制类型转换
给变量初始化的值与其类型不符时，为了避免警告就可以用强制类型转换来实现。
如下，初始化时将整型a的值初始化为3.14，为了避免警告，此时使用强制类型转换
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int a = (int)3.14;
return 0;
} 
注意：强制类型转换时将类型写在括号里，例：int a = (int)3.14;
int a = int(3.14);这种写法是错误的。
7.关系操作符
>
>=
<
<=
!= 用于测试“不相等”
== 用于测试“相等”
8.逻辑操作符
&& 逻辑与
|| 逻辑或
逻辑与就相当于“并且”，逻辑或就相当于“或者”
逻辑与必须&&两边的条件同时满足才能执行后面程序
逻辑或||两边的条件满足其中一个就能执行后面程序
前面我们讲过的判断闰年就是典型的例子：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int f = 0;
scanf("%d", &f);
//1.能被4整除，并且不能被100整除
//2.能被400整除是闰年
if (f % 4 == 0 && f % 100 != 0 || f % 400 == 0)
{
printf("是闰年\n");
}
else
{
printf("不是闰年\n");
}
return 0;
} 下面来看一个例题：
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;
printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
return 0;
}
打印出来的结果是什么呢？
为什么是这个结果呢？
因为a++,先使用a=0的值，再将a自增，而逻辑与左边为假，右边就不计算了，所以后面的++b和d++都没有执行。
那我们换成逻辑或看打印结果是否会发生变化呢？
#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ || ++b || d++;
printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
return 0;
} 运行结果：
为什么是这个结果呢？
因为逻辑或左边为真，右边就不计算了，a++先将a=0的值和++b的值逻辑或，++b的值是3为真，逻辑或的结果为真，后面的d++不再执行。所以结果是1,3,3,4
注意：逻辑操作符计算结果为真，使用1表示。计算结果为假，使用0表示。
今天就学到这里，未完待续。。。