c语言编写双符号和进制位溢出怎么写

2861913457

c语言编写双符号和进制位溢出怎么写

jackz007

        举例说明什么是所谓的

双符号和进制位溢出

zhangjinxuan

什么意思？

2861913457

zhangjinxuan 发表于 2022-10-7 11:54
什么意思？

就是用c语言编写溢出，给出两个二进制数让其相加减，看其是否大于1或者小于-1

zhangjinxuan

2861913457 发表于 2022-10-16 16:29
就是用c语言编写溢出，给出两个二进制数让其相加减，看其是否大于1或者小于-1

意思是给出两个二进制数A,B，看相减大于1或小于-1？

人造人

2861913457 发表于 2022-10-16 16:29
就是用c语言编写溢出，给出两个二进制数让其相加减，看其是否大于1或者小于-1

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. void and_gate(char a, char b, char *c) {
   
6.     *c = a == '1' && b == '1' ? '1' : '0';
   
7. }
   
8. 
   
9. void or_gate(char a, char b, char *c) {
   
10.     *c = a == '0' && b == '0' ? '0' : '1';
    
11. }
    
12. 
    
13. #if 0
    
14. void xor_gate(char a, char b, char *c) {
    
15.     *c = a != b ? '1' : '0';
    
16. }
    
17. #else
    
18. void not_gate(char a, char *b) {
    
19.     *b = a == '1' ? '0' : '1';
    
20. }
    
21. 
    
22. void xor_gate(char a, char b, char *c) {
    
23.     char na, nb;
    
24.     char r0, r1;
    
25.     not_gate(a, &na);
    
26.     not_gate(b, &nb);
    
27.     and_gate(a, nb, &r0);
    
28.     and_gate(b, na, &r1);
    
29.     or_gate(r0, r1, c);
    
30. }
    
31. #endif
    
32. 
    
33. void half_adder_1bit(char a, char b, char *s, char *c) {
    
34.     xor_gate(a, b, s);
    
35.     and_gate(a, b, c);
    
36. }
    
37. 
    
38. void full_adder_1bit(char a, char b, char ci, char *s, char *co) {
    
39.     char temp_s, temp_c[2];
    
40.     half_adder_1bit(a, b, &temp_s, &temp_c[0]);
    
41.     half_adder_1bit(temp_s, ci, s, &temp_c[1]);
    
42.     or_gate(temp_c[0], temp_c[1], co);
    
43. }
    
44. 
    
45. void full_adder_2bit(const char *a, const char *b, char ci, char *s, char *co) {
    
46.     char temp_c;
    
47.     full_adder_1bit(a[1], b[1], ci, &s[1], &temp_c);
    
48.     full_adder_1bit(a[0], b[0], temp_c, &s[0], co);
    
49. }
    
50. 
    
51. void full_adder_4bit(const char *a, const char *b, char ci, char *s, char *co) {
    
52.     char temp_c;
    
53.     full_adder_2bit(&a[2], &b[2], ci, &s[2], &temp_c);
    
54.     full_adder_2bit(&a[0], &b[0], temp_c, &s[0], co);
    
55. }
    
56. 
    
57. void full_adder_8bit(const char *a, const char *b, char ci, char *s, char *co) {
    
58.     char temp_c;
    
59.     full_adder_4bit(&a[4], &b[4], ci, &s[4], &temp_c);
    
60.     full_adder_4bit(&a[0], &b[0], temp_c, &s[0], co);
    
61. }
    
62. 
    
63. void full_adder_16bit(const char *a, const char *b, char ci, char *s, char *co) {
    
64.     char temp_c;
    
65.     full_adder_8bit(&a[8], &b[8], ci, &s[8], &temp_c);
    
66.     full_adder_8bit(&a[0], &b[0], temp_c, &s[0], co);
    
67. }
    
68. 
    
69. void full_adder_32bit(const char *a, const char *b, char ci, char *s, char *co) {
    
70.     char temp_c;
    
71.     full_adder_16bit(&a[16], &b[16], ci, &s[16], &temp_c);
    
72.     full_adder_16bit(&a[0], &b[0], temp_c, &s[0], co);
    
73. }
    
74. 
    
75. void binary(char dest[const 32], const char *src) {
    
76.     memset(dest, '0', 32);
    
77.     size_t l = strlen(src);
    
78.     strncpy(dest + (32 - l), src, l);
    
79. }
    
80. 
    
81. void format(char *dest, const char src[const 32]) {
    
82.     const char *p = NULL;
    
83.     for(size_t i = 0; i < 32; ++i) {
    
84.         if(src[i] == '1') {p = &src[i]; break;}
    
85.     }
    
86.     if(!p) p = src + 31;
    
87.     while(p != src + 32) *dest++ = *p++;
    
88.     *dest = '\0';
    
89. }
    
90. 
    
91. char *add(const char *a, const char *b) {
    
92.     char *a_ = malloc(32), *b_ = malloc(32);
    
93.     char *c = malloc(33);
    
94.     binary(a_, a); binary(b_, b);
    
95.     char ci = '0', co;
    
96.     full_adder_32bit(a_, b_, ci, c, &co);
    
97.     //format(c, c);
    
98.     c[32] = '\0';
    
99.     free(a_); free(b_);
    
100.     return c;
     
101. }
     
102. 
     
103. void neg(char num[const 32]) {
     
104.     for(size_t i = 0; i < 32; ++i) {
     
105.         xor_gate('1', num[i], &num[i]);
     
106.     }
     
107.     char ci = '0', co;
     
108.     char one[32] = "00000000000000000000000000000001";
     
109.     full_adder_32bit(num, one, ci, num, &co);
     
110. }
     
111. 
     
112. char *sub(const char *a, const char *b) {
     
113.     char *a_ = malloc(32), *b_ = malloc(32);
     
114.     char *c = malloc(33);
     
115.     binary(a_, a); binary(b_, b);
     
116.     neg(b_);
     
117.     char ci = '0', co;
     
118.     full_adder_32bit(a_, b_, ci, c, &co);
     
119.     //format(c, c);
     
120.     c[32] = '\0';
     
121.     free(a_); free(b_);
     
122.     return c;
     
123. }
     
124. 
     
125. int main(void) {
     
126.     char a[33];
     
127.     char b[33];
     
128.     scanf("%32s", a);
     
129.     scanf("%32s", b);
     
130.     char *c0 = add(a, b);
     
131.     puts(c0);
     
132.     if(c0[0] != '1') printf("大于1\n");
     
133.     free(c0);
     
134.     char *c1 = sub(a, b);
     
135.     puts(c1);
     
136.     if(c1[0] == '1' && c1[31] != '1') printf("小于-1\n");
     
137.     free(c1);
     
138.     return 0;
     
139. }
     

复制代码

人造人

判断的部分不对，改一改

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <stdint.h>
   
5. 
   
6. void and_gate(char a, char b, char *c) {
   
7.     *c = a == '1' && b == '1' ? '1' : '0';
   
8. }
   
9. 
   
10. void or_gate(char a, char b, char *c) {
    
11.     *c = a == '0' && b == '0' ? '0' : '1';
    
12. }
    
13. 
    
14. #if 0
    
15. void xor_gate(char a, char b, char *c) {
    
16.     *c = a != b ? '1' : '0';
    
17. }
    
18. #else
    
19. void not_gate(char a, char *b) {
    
20.     *b = a == '1' ? '0' : '1';
    
21. }
    
22. 
    
23. void xor_gate(char a, char b, char *c) {
    
24.     char na, nb;
    
25.     char r0, r1;
    
26.     not_gate(a, &na);
    
27.     not_gate(b, &nb);
    
28.     and_gate(a, nb, &r0);
    
29.     and_gate(b, na, &r1);
    
30.     or_gate(r0, r1, c);
    
31. }
    
32. #endif
    
33. 
    
34. void half_adder_1bit(char a, char b, char *s, char *c) {
    
35.     xor_gate(a, b, s);
    
36.     and_gate(a, b, c);
    
37. }
    
38. 
    
39. void full_adder_1bit(char a, char b, char ci, char *s, char *co) {
    
40.     char temp_s, temp_c[2];
    
41.     half_adder_1bit(a, b, &temp_s, &temp_c[0]);
    
42.     half_adder_1bit(temp_s, ci, s, &temp_c[1]);
    
43.     or_gate(temp_c[0], temp_c[1], co);
    
44. }
    
45. 
    
46. void full_adder_2bit(const char *a, const char *b, char ci, char *s, char *co) {
    
47.     char temp_c;
    
48.     full_adder_1bit(a[1], b[1], ci, &s[1], &temp_c);
    
49.     full_adder_1bit(a[0], b[0], temp_c, &s[0], co);
    
50. }
    
51. 
    
52. void full_adder_4bit(const char *a, const char *b, char ci, char *s, char *co) {
    
53.     char temp_c;
    
54.     full_adder_2bit(&a[2], &b[2], ci, &s[2], &temp_c);
    
55.     full_adder_2bit(&a[0], &b[0], temp_c, &s[0], co);
    
56. }
    
57. 
    
58. void full_adder_8bit(const char *a, const char *b, char ci, char *s, char *co) {
    
59.     char temp_c;
    
60.     full_adder_4bit(&a[4], &b[4], ci, &s[4], &temp_c);
    
61.     full_adder_4bit(&a[0], &b[0], temp_c, &s[0], co);
    
62. }
    
63. 
    
64. void full_adder_16bit(const char *a, const char *b, char ci, char *s, char *co) {
    
65.     char temp_c;
    
66.     full_adder_8bit(&a[8], &b[8], ci, &s[8], &temp_c);
    
67.     full_adder_8bit(&a[0], &b[0], temp_c, &s[0], co);
    
68. }
    
69. 
    
70. void full_adder_32bit(const char *a, const char *b, char ci, char *s, char *co) {
    
71.     char temp_c;
    
72.     full_adder_16bit(&a[16], &b[16], ci, &s[16], &temp_c);
    
73.     full_adder_16bit(&a[0], &b[0], temp_c, &s[0], co);
    
74. }
    
75. 
    
76. void binary(char dest[const 32], const char *src) {
    
77.     memset(dest, '0', 32);
    
78.     size_t l = strlen(src);
    
79.     strncpy(dest + (32 - l), src, l);
    
80. }
    
81. 
    
82. void format(char *dest, const char src[const 32]) {
    
83.     const char *p = NULL;
    
84.     for(size_t i = 0; i < 32; ++i) {
    
85.         if(src[i] == '1') {p = &src[i]; break;}
    
86.     }
    
87.     if(!p) p = src + 31;
    
88.     while(p != src + 32) *dest++ = *p++;
    
89.     *dest = '\0';
    
90. }
    
91. 
    
92. char *add(const char *a, const char *b) {
    
93.     char *a_ = malloc(32), *b_ = malloc(32);
    
94.     char *c = malloc(33);
    
95.     binary(a_, a); binary(b_, b);
    
96.     char ci = '0', co;
    
97.     full_adder_32bit(a_, b_, ci, c, &co);
    
98.     //format(c, c);
    
99.     c[32] = '\0';
    
100.     free(a_); free(b_);
     
101.     return c;
     
102. }
     
103. 
     
104. void neg(char num[const 32]) {
     
105.     for(size_t i = 0; i < 32; ++i) {
     
106.         xor_gate('1', num[i], &num[i]);
     
107.     }
     
108.     char ci = '0', co;
     
109.     char one[32] = "00000000000000000000000000000001";
     
110.     full_adder_32bit(num, one, ci, num, &co);
     
111. }
     
112. 
     
113. char *sub(const char *a, const char *b) {
     
114.     char *a_ = malloc(32), *b_ = malloc(32);
     
115.     char *c = malloc(33);
     
116.     binary(a_, a); binary(b_, b);
     
117.     neg(b_);
     
118.     char ci = '0', co;
     
119.     full_adder_32bit(a_, b_, ci, c, &co);
     
120.     //format(c, c);
     
121.     c[32] = '\0';
     
122.     free(a_); free(b_);
     
123.     return c;
     
124. }
     
125. 
     
126. uint32_t number(const char n[const 32]) {
     
127.     uint32_t rv = 0;
     
128.     const char *p = n;
     
129.     for(uint32_t mask = 0x80000000; mask; mask >>= 1) {
     
130.         if(*p++ == '1') rv |= mask;
     
131.     }
     
132.     return rv;
     
133. }
     
134. 
     
135. int main(void) {
     
136.     char a[33];
     
137.     char b[33];
     
138.     scanf("%32s", a);
     
139.     scanf("%32s", b);
     
140.     char *c0 = add(a, b);
     
141.     puts(c0);
     
142.     uint32_t cu0 = number(c0);
     
143.     printf("%u\n", cu0);
     
144.     if(cu0 > 1 && cu0 < 0x80000000) printf("大于1\n");
     
145.     free(c0);
     
146.     char *c1 = sub(a, b);
     
147.     puts(c1);
     
148.     uint32_t cu1 = number(c1);
     
149.     printf("%d\n", (int32_t)cu1);
     
150.     if(cu1 >= 0x80000000 && cu1 < 0xffffffff) printf("小于-1\n");
     
151.     free(c1);
     
152.     return 0;
     
153. }
     

复制代码

人造人

我为什么不这么写呢？很奇怪

1. int main(void) {
   
2.     char a[33];
   
3.     char b[33];
   
4.     scanf("%32s", a);
   
5.     scanf("%32s", b);
   
6.     char *c0 = add(a, b);
   
7.     puts(c0);
   
8.     uint32_t cu0 = number(c0);
   
9.     printf("%u\n", cu0);
   
10.     if((int32_t)cu0 > 1) printf("大于1\n");
    
11.     free(c0);
    
12.     char *c1 = sub(a, b);
    
13.     puts(c1);
    
14.     uint32_t cu1 = number(c1);
    
15.     printf("%d\n", (int32_t)cu1);
    
16.     if((int32_t)cu1 < -1) printf("小于-1\n");
    
17.     free(c1);
    
18.     return 0;
    
19. }
    

复制代码

jhq999

人造人 发表于 2022-10-17 00:12
我为什么不这么写呢？很奇怪

你是写完了前面的才发现可以更简单，还是写一半时发现的？最恶心的是写一半时发现，是选择继续完成啊？还是重开？对于选择困难症的人太恶心了

人造人

jhq999 发表于 2022-10-17 07:38
你是写完了前面的才发现可以更简单，还是写一半时发现的？最恶心的是写一半时发现，是选择继续 ...

    printf("%d\n", (int32_t)cu1);
写完发现的，这条语句发现的

如果写一半发现不对，那就及时纠正
错误要及时纠正，不要一错再错

不重开，在已经写了的代码的基础上修改就好
如果你发现没办法在已有的代码的基础上修改
那说明你一开始在考虑这个问题的时候想的不够全面，或者没有给可能会发生的那些变化留出足够的余地
这是你的设计问题
写代码之前应该得想好，你得有这个程序的整体布局

jhq999

人造人 发表于 2022-10-17 13:28
printf("%d\n", (int32_t)cu1);
写完发现的，这条语句发现的

受教了