动态链接库

人造人

1. $ ls
   
2. main.c
   
3. $ cat main.c
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <string.h>
   
7. #include <stdint.h>
   
8. 
   
9. void and_gate(char a, char b, char *c) {
   
10.     *c = a == '1' && b == '1' ? '1' : '0';
    
11. }
    
12. 
    
13. void or_gate(char a, char b, char *c) {
    
14.     *c = a == '0' && b == '0' ? '0' : '1';
    
15. }
    
16. 
    
17. #if 0
    
18. void xor_gate(char a, char b, char *c) {
    
19.     *c = a != b ? '1' : '0';
    
20. }
    
21. #else
    
22. void not_gate(char a, char *b) {
    
23.     *b = a == '1' ? '0' : '1';
    
24. }
    
25. 
    
26. void xor_gate(char a, char b, char *c) {
    
27.     char na, nb;
    
28.     char r0, r1;
    
29.     not_gate(a, &na);
    
30.     not_gate(b, &nb);
    
31.     and_gate(a, nb, &r0);
    
32.     and_gate(b, na, &r1);
    
33.     or_gate(r0, r1, c);
    
34. }
    
35. #endif
    
36. 
    
37. void half_adder_1bit(char a, char b, char *s, char *c) {
    
38.     xor_gate(a, b, s);
    
39.     and_gate(a, b, c);
    
40. }
    
41. 
    
42. void full_adder_1bit(char a, char b, char ci, char *s, char *co) {
    
43.     char temp_s, temp_c[2];
    
44.     half_adder_1bit(a, b, &temp_s, &temp_c[0]);
    
45.     half_adder_1bit(temp_s, ci, s, &temp_c[1]);
    
46.     or_gate(temp_c[0], temp_c[1], co);
    
47. }
    
48. 
    
49. void full_adder_2bit(const char *a, const char *b, char ci, char *s, char *co) {
    
50.     char temp_c;
    
51.     full_adder_1bit(a[1], b[1], ci, &s[1], &temp_c);
    
52.     full_adder_1bit(a[0], b[0], temp_c, &s[0], co);
    
53. }
    
54. 
    
55. void full_adder_4bit(const char *a, const char *b, char ci, char *s, char *co) {
    
56.     char temp_c;
    
57.     full_adder_2bit(&a[2], &b[2], ci, &s[2], &temp_c);
    
58.     full_adder_2bit(&a[0], &b[0], temp_c, &s[0], co);
    
59. }
    
60. 
    
61. void full_adder_8bit(const char *a, const char *b, char ci, char *s, char *co) {
    
62.     char temp_c;
    
63.     full_adder_4bit(&a[4], &b[4], ci, &s[4], &temp_c);
    
64.     full_adder_4bit(&a[0], &b[0], temp_c, &s[0], co);
    
65. }
    
66. 
    
67. void full_adder_16bit(const char *a, const char *b, char ci, char *s, char *co) {
    
68.     char temp_c;
    
69.     full_adder_8bit(&a[8], &b[8], ci, &s[8], &temp_c);
    
70.     full_adder_8bit(&a[0], &b[0], temp_c, &s[0], co);
    
71. }
    
72. 
    
73. void full_adder_32bit(const char *a, const char *b, char ci, char *s, char *co) {
    
74.     char temp_c;
    
75.     full_adder_16bit(&a[16], &b[16], ci, &s[16], &temp_c);
    
76.     full_adder_16bit(&a[0], &b[0], temp_c, &s[0], co);
    
77. }
    
78. 
    
79. void binary(char dest[const 32], const char *src) {
    
80.     memset(dest, '0', 32);
    
81.     size_t l = strlen(src);
    
82.     strncpy(dest + (32 - l), src, l);
    
83. }
    
84. 
    
85. void format(char *dest, const char src[const 32]) {
    
86.     const char *p = NULL;
    
87.     for(size_t i = 0; i < 32; ++i) {
    
88.         if(src[i] == '1') {p = &src[i]; break;}
    
89.     }
    
90.     if(!p) p = src + 31;
    
91.     while(p != src + 32) *dest++ = *p++;
    
92.     *dest = '\0';
    
93. }
    
94. 
    
95. char *add(const char *a, const char *b) {
    
96.     char *a_ = malloc(32), *b_ = malloc(32);
    
97.     char *c = malloc(33);
    
98.     binary(a_, a); binary(b_, b);
    
99.     char ci = '0', co;
    
100.     full_adder_32bit(a_, b_, ci, c, &co);
     
101.     //format(c, c);
     
102.     c[32] = '\0';
     
103.     free(a_); free(b_);
     
104.     return c;
     
105. }
     
106. 
     
107. void neg(char num[const 32]) {
     
108.     for(size_t i = 0; i < 32; ++i) {
     
109.         xor_gate('1', num[i], &num[i]);
     
110.     }
     
111.     char ci = '0', co;
     
112.     char one[32] = "00000000000000000000000000000001";
     
113.     full_adder_32bit(num, one, ci, num, &co);
     
114. }
     
115. 
     
116. char *sub(const char *a, const char *b) {
     
117.     char *a_ = malloc(32), *b_ = malloc(32);
     
118.     char *c = malloc(33);
     
119.     binary(a_, a); binary(b_, b);
     
120.     neg(b_);
     
121.     char ci = '0', co;
     
122.     full_adder_32bit(a_, b_, ci, c, &co);
     
123.     //format(c, c);
     
124.     c[32] = '\0';
     
125.     free(a_); free(b_);
     
126.     return c;
     
127. }
     
128. 
     
129. uint32_t number(const char n[const 32]) {
     
130.     uint32_t rv = 0;
     
131.     const char *p = n;
     
132.     for(uint32_t mask = 0x80000000; mask; mask >>= 1) {
     
133.         if(*p++ == '1') rv |= mask;
     
134.     }
     
135.     return rv;
     
136. }
     
137. 
     
138. int main(void) {
     
139.     char a[33];
     
140.     char b[33];
     
141.     scanf("%32s", a);
     
142.     scanf("%32s", b);
     
143.     char *c0 = add(a, b);
     
144.     puts(c0);
     
145.     uint32_t cu0 = number(c0);
     
146.     printf("%u\n", cu0);
     
147.     if((int32_t)cu0 > 1) printf("大于1\n");
     
148.     free(c0);
     
149.     char *c1 = sub(a, b);
     
150.     puts(c1);
     
151.     uint32_t cu1 = number(c1);
     
152.     printf("%d\n", (int32_t)cu1);
     
153.     if((int32_t)cu1 < -1) printf("小于-1\n");
     
154.     free(c1);
     
155.     return 0;
     
156. }
     
157. $ gcc -g -Wall -shared -o main.dll main.c
     
158. $ ls
     
159. main.c  main.dll
     
160. $ file main.dll
     
161. main.dll: PE32+ executable (DLL) (console) x86-64, for MS Windows
     
162. $ python
     
163. Python 3.8.12 (default, Nov 23 2021, 20:18:25)
     
164. [GCC 11.2.0] on cygwin
     
165. Type "help", "copyright", "credits" or "license" for more information.
     
166. >>> import ctypes
     
167. >>> dll = ctypes.cdll.LoadLibrary('main.dll')
     
168. >>> dll
     
169. <CDLL 'main.dll', handle 509660000 at 0x6fffffec79d0>
     
170. >>> dll.main()
     
171. 10110110
     
172. 1001
     
173. 00000000000000000000000010111111
     
174. 191
     
175. 大于1
     
176. 00000000000000000000000010101101
     
177. 173
     
178. 0
     
179. >>> dll.add(b'10011100', b'100101')
     
180. 1633360
     
181. >>> dll.add.restype = ctypes.c_char_p
     
182. >>> dll.add(b'10011100', b'100101')
     
183. b'00000000000000000000000011000001'
     
184. >>>
     
185. $
     

复制代码

人造人

学会百度，百度上面啥都有

人造人

2wsx 发表于 2022-10-21 08:41
大佬你这个代码怎么用啊，我没看懂

代码都给你贴出来了，使用的指令也给你贴出来了
你哪里看不懂？
你得有基础才能玩这些东西呀


上面那个C代码是一个32位的全加器
用add函数包装了一下，让这个全加器更方便使用
上面的例子首先把这个C代码编译成dll
然后在python中调用
调用了C代码中的main函数和add函数