重温c语言之，7天开整，就是任意的写写，第十天

一：操作符

　　&：按位与----2进制
　　|：按位或----2进制
　　^：按位异或----2进制
　　~：按位取反---2进制
　　
　　&：先上代码，然后表明

1. 1 #define _CRT_SECURE_NO_WARNINGS
2. 2
3. 3 #include<stdio.h>
4. 4 int main()
5. 5 {
6. 6     int a = 3;
7. 7     int b = -5;
8. 8     int c = a & b;
9. 9     printf("%d\n", c);
10. 10     return 0;
11. 11 }

复制代码

　　这里的结果是：3
　　为什么呢，a=5，是正数，以是原码，反码，补码都是一样的，---->00000000000000000000000000000011
　　b=-5，是负数，先写原码，首位是1，由于负数是1，　　　　  ---->10000000000000000000000000000101
　　再写反码，　　　　　　　　　　　　　　　　　　　　　　   ---->11111111111111111111111111111010
　　最后再写补码　　　　　　　　　　　　　　　　　　　　　　---->11111111111111111111111111111011
　　由于机器上面，运算都是用补码来举行的，以是用a=5与b=-5的补码举行&运算，（&运算：全1得1，有0则0），以是：
　　00000000000000000000000000000011，最后再换算成为：原码，由于开头的地方是0，以是这个是正数，原码，反码，补码都是一样的，
　　%d这个打印的是一个有符号的整数，以是最终的结果是：3
 
　　|：先上代码，然后表明

1. 1 #define _CRT_SECURE_NO_WARNINGS
2. 2
3. 3 #include<stdio.h>
4. 4
5. 5 int main()
6. 6 {
7. 7     int a = 3;
8. 8     int b = -5;
9. 9     int c = a | b;
10. 10     printf("%d\n", c);
11. 11     return 0;
12. 12 }

复制代码

　　这里的结果是：-5
　　先写上a的补码：00000000000000000000000000000011
　　再写上b的补码：11111111111111111111111111111011
　　|：（|运算：全0得0，有1则1），以是：11111111111111111111111111111011　　
　　由于答案求原码，以是：先有补码转换成反码：11111111111111111111111111111010
　　最后再转化成原码：10000000000000000000000000000101
　　%d这个打印的是一个有符号的整数，以是最终的结果是：-5
 
　　^：先上代码，然后表明

1. 1 #define _CRT_SECURE_NO_WARNINGS
2. 2
3. 3 #include<stdio.h>
4. 4
5. 5 int main()
6. 6 {
7. 7     int a = 3;
8. 8     int b = -5;
9. 9     int c = a ^ b;
10. 10     printf("%d\n", c);
11. 11     return 0;
12. 12 }

复制代码

　　这里的结果是：-8
　　先写上a的补码：00000000000000000000000000000011
　　再写上b的补码：11111111111111111111111111111011
　　^：（^运算：相同为0，相异位1），以是：11111111111111111111111111111000
　　由于答案求原码，以是：先有补码转换成反码：11111111111111111111111111110111
　　最后再转化成原码：10000000000000000000000000001000
　　%d这个打印的是一个有符号的整数，以是最终的结果是：-8
 
　　再将异或的操作，5^5=0；00-------101^00-------101=00-------000，--->这里就可以得出结论：a^a=0
　　　　　　　　　　5^0=0；00-------101^00-------000=00-------101，--->这里就可以得出结论：a^0=a
　　　　　　　　　　2^5^2=5;
　　　　2:00000000000000000000000000000010
　　　　5:00000000000000000000000000000101
　　　　2^5=00000000000000000000000000000111
　　　　2^5^2=00000000000000000000000000000101
　　　　故由上述运算流程可以得知，异或操作支持交换律
　　　　以是完全可以得知，2^5^2=2^2^5=5
　　
 
二：小程序题

　　不能创建暂时变量（第三个变量），实现两个数的交换
　　先写一个可以创建暂时变量的，直接上代码

1. 1 #include<stdio.h>
2. 2
3. 3 void swap(int* n1,int* n2)
4. 4 {
5. 5    int num=*n1;
6. 6    *n1=*n2;
7. 7    *n2=num;
8. 8 }
9. 9 int main()
10. 10 {
11. 11    int n1=0;
12. 12    int n2=0;
13. 13    scanf("%d %d",&n1,&n2);
14. 14    swap(&n1,&n2);
15. 15    printf("%d %d\n",n1,n2);              
16. 16    return 0;
17. 17 }

复制代码

　　这里就是直接利用暂时变量来举行两个数的交换的
　　而题目要求是不能创建暂时变量，以是先上第一个有点问题的代码

1. 1 #include<stdio.h>
2. 2 void swap(int* n1,int* n2)
3. 3 {
4. 4     *n1=*n1+*n2;
5. 5     *n2=*n1-*n2;
6. 6     *n1=*n1-*n2;
7. 7 }
8. 8 int main()
9. 9 {
10. 10     int n1=0,n2=0;
11. 11     scanf("%d %d",&n1,&n2);
12. 12     swap(&n1,&n2);
13. 13     printf("%d %d\n",n1,n2);
14. 14 }

复制代码

　　这里的小问题就是：n1，n2这两个变量是Int范例的，是存在最大值的，以是会出现溢出的情况，以是在这里会出现小问题，故有第二个改进方法
　　直接上代码

1. 1 #include<stdio.h>
2. 2 void swap(int* n1,int* n2)
3. 3 {
4. 4     *n1=*n1^*n2;
5. 5     *n2=*n1^*n2;
6. 6     *n1=*n1^*n2;
7. 7 }
8. 8 int main()
9. 9 {
10. 10     int n1=0,n2=0;
11. 11     scanf("%d %d",&n1,&n2);
12. 12     swap(&n1,&n2);
13. 13     printf("%d %d\n",n1,n2);
14. 14 }

复制代码

　　这里就不存在溢出的问题，这里直接利用操作符异或（^），相同则0，相异为1，来直接举行操作
　　但这里还有一个限定条件：只是实用于整形，不能用在浮点型
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。