[已解决]如何把若干个函数单独放在一个文件里

wp231957

以前的写法，就随便放在某个文件里，命名XX.C   然后在主文件里  include  <xx.c>    但是被告知 这是不规范用法

最佳答案

月排行榜 / 总排行榜

hrpzcf

2022-5-19 15:37:42

函数单独放.c文件，新建一个.h文件，定义所有函数原型，主xx.c文件内include .h文件，编译的时候指定所有.c文件，比如 gcc xx.c a.c b.c d.c -o main

跳转到最佳答案楼层

hrpzcf

函数单独放.c文件，新建一个.h文件，定义所有函数原型，主xx.c文件内include .h文件，编译的时候指定所有.c文件，比如 gcc xx.c a.c b.c d.c -o main

wp231957

hrpzcf 发表于 2022-5-19 15:37
函数单独放.c文件，新建一个.h文件，定义所有函数原型，主xx.c文件内include .h文件，编译的时候指定所有.c ...

带点h的  在编译时 不用到对应的lib吗   我用你的办法并没有生成中间文件
直接就是一个EXE

hrpzcf

wp231957 发表于 2022-5-19 15:52
带点h的  在编译时 不用到对应的lib吗   我用你的办法并没有生成中间文件
直接就是一个EXE

要使用静态库lib的话，要改变编译方式。
1. 先把单独函数的 a.c b.c ... 文件生成编译成静态库 x.lib，百度；
2. 新建 .h 写上述.c文件的函数原型；
3. 主文件 xxx.c 中 include 有函数原型的 .h，把主文件和 x.lib 一起编译成完整的可执行文件，百度。

wp231957

hrpzcf 发表于 2022-5-19 17:03
要使用静态库lib的话，要改变编译方式。
1. 先把单独函数的 a.c b.c ... 文件生成编译成静态库 x.lib ...

我不是这个意思，换个问法，我们最常用的printf的实现部分在哪里

人造人

wp231957 发表于 2022-5-19 17:58
我不是这个意思，换个问法，我们最常用的printf的实现部分在哪里

1. /lib/libc.so.6

复制代码

人造人

1. $ nm libc.so.6 | grep "\<printf\>"
   
2. 0000000000074c04 T printf

复制代码

人造人

1. $ nm lib/libc.so.6 | grep "\<printf\>"
   
2. 0000000000074c04 T printf
   
3. $

复制代码

1. 0000000000074c04 <_IO_printf>:
   
2. 
   
3. /* Write formatted output to stdout from the format string FORMAT.  */
   
4. /* VARARGS1 */
   
5. int
   
6. __printf (const char *format, ...)
   
7. {
   
8.    74c04:        55                           pushq  %rbp
   
9.    74c05:        48 89 e5                     movq   %rsp,%rbp
   
10.    74c08:        48 81 ec e0 00 00 00         subq   $0xe0,%rsp
    
11.    74c0f:        48 89 bd 28 ff ff ff         movq   %rdi,-0xd8(%rbp)
    
12.    74c16:        48 89 b5 58 ff ff ff         movq   %rsi,-0xa8(%rbp)
    
13.    74c1d:        48 89 95 60 ff ff ff         movq   %rdx,-0xa0(%rbp)
    
14.    74c24:        48 89 8d 68 ff ff ff         movq   %rcx,-0x98(%rbp)
    
15.    74c2b:        4c 89 85 70 ff ff ff         movq   %r8,-0x90(%rbp)
    
16.    74c32:        4c 89 8d 78 ff ff ff         movq   %r9,-0x88(%rbp)
    
17.    74c39:        84 c0                        testb  %al,%al
    
18.    74c3b:        74 20                        je     74c5d <_IO_printf+0x59>
    
19.    74c3d:        0f 29 45 80                  movaps %xmm0,-0x80(%rbp)
    
20.    74c41:        0f 29 4d 90                  movaps %xmm1,-0x70(%rbp)
    
21.    74c45:        0f 29 55 a0                  movaps %xmm2,-0x60(%rbp)
    
22.    74c49:        0f 29 5d b0                  movaps %xmm3,-0x50(%rbp)
    
23.    74c4d:        0f 29 65 c0                  movaps %xmm4,-0x40(%rbp)
    
24.    74c51:        0f 29 6d d0                  movaps %xmm5,-0x30(%rbp)
    
25.    74c55:        0f 29 75 e0                  movaps %xmm6,-0x20(%rbp)
    
26.    74c59:        0f 29 7d f0                  movaps %xmm7,-0x10(%rbp)
    
27.   va_list arg;
    
28.   int done;
    
29. 
    
30.   va_start (arg, format);
    
31.    74c5d:        c7 85 30 ff ff ff 08         movl   $0x8,-0xd0(%rbp)
    
32.    74c64:        00 00 00
    
33.    74c67:        c7 85 34 ff ff ff 30         movl   $0x30,-0xcc(%rbp)
    
34.    74c6e:        00 00 00
    
35.    74c71:        48 8d 45 10                  leaq   0x10(%rbp),%rax
    
36.    74c75:        48 89 85 38 ff ff ff         movq   %rax,-0xc8(%rbp)
    
37.    74c7c:        48 8d 85 50 ff ff ff         leaq   -0xb0(%rbp),%rax
    
38.    74c83:        48 89 85 40 ff ff ff         movq   %rax,-0xc0(%rbp)
    
39.   done = __vfprintf_internal (stdout, format, arg, 0);
    
40.    74c8a:        48 8b 05 97 62 1d 00         movq   0x1d6297(%rip),%rax        # 24af28 <stdout@@GLIBC_2.2.5-0x1928>
    
41.    74c91:        48 8b 00                     movq   (%rax),%rax
    
42.    74c94:        48 8d 95 30 ff ff ff         leaq   -0xd0(%rbp),%rdx
    
43.    74c9b:        48 8b b5 28 ff ff ff         movq   -0xd8(%rbp),%rsi
    
44.    74ca2:        b9 00 00 00 00               movl   $0x0,%ecx
    
45.    74ca7:        48 89 c7                     movq   %rax,%rdi
    
46.    74caa:        e8 f0 4c 01 00               callq  8999f <__vfprintf_internal>
    
47.    74caf:        89 85 4c ff ff ff            movl   %eax,-0xb4(%rbp)
    
48.   va_end (arg);
    
49. 
    
50.   return done;
    
51.    74cb5:        8b 85 4c ff ff ff            movl   -0xb4(%rbp),%eax
    
52. }
    
53.    74cbb:        c9                           leaveq
    
54.    74cbc:        c3                           retq   
    

复制代码

wp231957

人造人 发表于 2022-5-19 18:49

那为什么只是引用stdio.h就可以访问这个lib里面的函数？这又是啥机制？

人造人

1. $ ls
   
2. list.c  list.h  main.c
   
3. $ cat list.h
   
4. #ifndef _LIST_H_
   
5. #define _LIST_H_
   
6. 
   
7. #include <stddef.h>
   
8. #include <stdbool.h>
   
9. 
   
10. struct list_node_tag {
    
11.     void *data; size_t size;
    
12.     struct list_node_tag *next;
    
13. };
    
14. 
    
15. typedef struct {
    
16.     struct list_node_tag *head;
    
17.     size_t size;
    
18. } list_t;
    
19. 
    
20. list_t *list_init(void);
    
21. void list_deinit(list_t *list);
    
22. bool list_clean(list_t *list);
    
23. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
24. bool list_delete(list_t *list, size_t index);
    
25. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
26. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
27. bool list_append(list_t *list, const void *data, size_t size);
    
28. size_t list_size(const list_t *list);
    
29. bool list_empty(const list_t *list);
    
30. 
    
31. #endif
    
32. $ cat list.c
    
33. #include "list.h"
    
34. #include <stdlib.h>
    
35. #include <memory.h>
    
36. 
    
37. list_t *list_init(void) {
    
38.     list_t *list = malloc(sizeof(*list));
    
39.     if(!list) return NULL;
    
40.     list->head = NULL;
    
41.     list->size = 0;
    
42.     return list;
    
43. }
    
44. 
    
45. void list_deinit(list_t *list) {
    
46.     if(!list) return;
    
47.     list_clean(list);
    
48.     free(list);
    
49. }
    
50. 
    
51. bool list_clean(list_t *list) {
    
52.     if(!list) return false;
    
53.     while(!list_empty(list)) list_delete(list, 0);
    
54.     return true;
    
55. }
    
56. 
    
57. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
    
58.     if(!list) return false;
    
59.     if(list_size(list) < index) return false;
    
60.     if(!data) return false;
    
61.     struct list_node_tag **current = &list->head;
    
62.     while(index--) current = &(*current)->next;
    
63.     struct list_node_tag *node = malloc(sizeof(*node));
    
64.     if(!node) return false;
    
65.     node->data = malloc(size);
    
66.     if(!node->data) {free(node); return false;}
    
67.     memcpy(node->data, data, size);
    
68.     node->size = size;
    
69.     node->next = *current;
    
70.     *current = node;
    
71.     ++list->size;
    
72.     return true;
    
73. }
    
74. 
    
75. bool list_delete(list_t *list, size_t index) {
    
76.     if(!list) return false;
    
77.     if(list_size(list) <= index) return false;
    
78.     struct list_node_tag **current = &list->head;
    
79.     while(index--) current = &(*current)->next;
    
80.     struct list_node_tag *temp = *current;
    
81.     *current = temp->next;
    
82.     free(temp->data); free(temp);
    
83.     --list->size;
    
84.     return true;
    
85. }
    
86. 
    
87. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
    
88.     if(!list) return false;
    
89.     if(list_size(list) <= index) return false;
    
90.     if(!data) return false;
    
91.     struct list_node_tag *const *current = &list->head;
    
92.     while(index--) current = &(*current)->next;
    
93.     struct list_node_tag *temp = *current;
    
94.     if(temp->size > size) return false;
    
95.     memcpy(data, temp->data, temp->size);
    
96.     return true;
    
97. }
    
98. 
    
99. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
    
100.     bool res = list_delete(list, index);
     
101.     return res ? list_insert(list, index, data, size) : res;
     
102. }
     
103. 
     
104. bool list_append(list_t *list, const void *data, size_t size) {
     
105.     if(!list) return false;
     
106.     return list_insert(list, list_size(list), data, size);
     
107. }
     
108. 
     
109. size_t list_size(const list_t *list) {
     
110.     if(!list) return 0;
     
111.     return list->size;
     
112. }
     
113. 
     
114. bool list_empty(const list_t *list) {
     
115.     if(!list) return true;
     
116.     return list_size(list) == 0;
     
117. }
     
118. $ cat main.c
     
119. #include "list.h"
     
120. #include <stdio.h>
     
121. 
     
122. void output(const list_t *list, size_t index) {
     
123.     if(index >= list_size(list)) return;
     
124.     output(list, index + 1);
     
125.     int temp; list_get(list, index, &temp, sizeof(temp));
     
126.     printf("%d ", temp);
     
127. }
     
128. 
     
129. int main(void) {
     
130.     list_t *list = list_init();
     
131.     for(size_t i = 0; i < 5; ++i) {
     
132.         int temp; scanf("%d", &temp);
     
133.         list_append(list, &temp, sizeof(temp));
     
134.     }
     
135.     output(list, 0); puts("");
     
136.     list_deinit(list);
     
137.     return 0;
     
138. }
     
139. $ gcc-debug -o main main.c list.c
     
140. $ ./main
     
141. 1 2 3 4 5
     
142. 5 4 3 2 1
     
143. $

复制代码

wp231957

人造人 发表于 2022-5-19 19:05

这个和我问的那个stdio的有关系吗？实在是没看懂啊

人造人

wp231957 发表于 2022-5-19 19:02
那为什么只是引用stdio.h就可以访问这个lib里面的函数？这又是啥机制？

stdio.h 里面就是有一个printf函数的声明，你自己声明一下printf函数，就不需要#include <stdio.h> 了

每一个c程序都会用到libc，你在编译代码的时候，即使你没有要求连接libc库，gcc也默认连接了这个库

1. $ cat main.c
   
2. //#include <stdio.h>
   
3. 
   
4. int printf(const char *format, ...);
   
5. 
   
6. int main(void) {
   
7.     printf("hello world!\n");
   
8.     return 0;
   
9. }
   
10. $ gcc-debug -o main main.c
    
11. $ ./main
    
12. hello world!
    
13. $

复制代码

人造人

wp231957 发表于 2022-5-19 19:08
这个和我问的那个stdio的有关系吗？实在是没看懂啊

如何把若干个函数单独放在一个文件里

这个代码是我写的一个通用list

人造人

一个.c源文件到可执行文件其实是有好多步骤的
gcc一条命令就可以完成全部的任务，当然它也允许你在某一个位置停下来

1. $ ls
   
2. main.c
   
3. $ cat main.c
   
4. //#include <stdio.h>
   
5. 
   
6. int printf(const char *format, ...);
   
7. 
   
8. int main(void) {
   
9.     printf("hello world!\n");
   
10.     return 0;
    
11. }
    
12. $ cpp main.c >main.i          # 预处理
    
13. $ ls
    
14. main.c  main.i
    
15. $ gcc -S -o main.s main.i     # 编译
    
16. $ ls
    
17. main.c  main.i  main.s
    
18. $ as -o main.o main.s         # 汇编
    
19. $ ls
    
20. main.c  main.i  main.o  main.s
    
21. $ ld -o main main.o -dynamic-linker /lib/ld-linux-x86-64.so.2 /lib/Scrt1.o /lib/libc.so.6    # 连接
    
22. $ ls
    
23. main  main.c  main.i  main.o  main.s
    
24. $ ./main
    
25. hello world!
    
26. $

复制代码

人造人

1. $ cat main.i
   
2. # 0 "main.c"
   
3. # 0 "<built-in>"
   
4. # 0 "<command-line>"
   
5. # 1 "/usr/include/stdc-predef.h" 1 3 4
   
6. # 0 "<command-line>" 2
   
7. # 1 "main.c"
   
8. 
   
9. 
   
10. int printf(const char *format, ...);
    
11. 
    
12. int main(void) {
    
13.     printf("hello world!\n");
    
14.     return 0;
    
15. }
    
16. $ cat main.s
    
17.         .file        "main.c"
    
18.         .text
    
19.         .section        .rodata
    
20. .LC0:
    
21.         .string        "hello world!"
    
22.         .text
    
23.         .globl        main
    
24.         .type        main, @function
    
25. main:
    
26. .LFB0:
    
27.         .cfi_startproc
    
28.         pushq        %rbp
    
29.         .cfi_def_cfa_offset 16
    
30.         .cfi_offset 6, -16
    
31.         movq        %rsp, %rbp
    
32.         .cfi_def_cfa_register 6
    
33.         leaq        .LC0(%rip), %rax
    
34.         movq        %rax, %rdi
    
35.         call        puts@PLT
    
36.         movl        $0, %eax
    
37.         popq        %rbp
    
38.         .cfi_def_cfa 7, 8
    
39.         ret
    
40.         .cfi_endproc
    
41. .LFE0:
    
42.         .size        main, .-main
    
43.         .ident        "GCC: (GNU) 12.1.0"
    
44.         .section        .note.GNU-stack,"",@progbits
    
45. $ objdump -S -M suffix main.o
    
46. 
    
47. main.o:     file format elf64-x86-64
    
48. 
    
49. 
    
50. Disassembly of section .text:
    
51. 
    
52. 0000000000000000 <main>:
    
53.    0:        55                           pushq  %rbp
    
54.    1:        48 89 e5                     movq   %rsp,%rbp
    
55.    4:        48 8d 05 00 00 00 00         leaq   0x0(%rip),%rax        # b <main+0xb>
    
56.    b:        48 89 c7                     movq   %rax,%rdi
    
57.    e:        e8 00 00 00 00               callq  13 <main+0x13>
    
58.   13:        b8 00 00 00 00               movl   $0x0,%eax
    
59.   18:        5d                           popq   %rbp
    
60.   19:        c3                           retq
    
61. $ objdump -S -M suffix main
    
62. 
    
63. main:     file format elf64-x86-64
    
64. 
    
65. 
    
66. Disassembly of section .plt:
    
67. 
    
68. 0000000000401000 <puts@plt-0x10>:
    
69.   401000:        ff 35 02 30 00 00            pushq  0x3002(%rip)        # 404008 <_GLOBAL_OFFSET_TABLE_+0x8>
    
70.   401006:        ff 25 04 30 00 00            jmpq   *0x3004(%rip)        # 404010 <_GLOBAL_OFFSET_TABLE_+0x10>
    
71.   40100c:        0f 1f 40 00                  nopl   0x0(%rax)
    
72. 
    
73. 0000000000401010 <puts@plt>:
    
74.   401010:        ff 25 02 30 00 00            jmpq   *0x3002(%rip)        # 404018 <puts@GLIBC_2.2.5>
    
75.   401016:        68 00 00 00 00               pushq  $0x0
    
76.   40101b:        e9 e0 ff ff ff               jmpq   401000 <__abi_tag+0xcc0>
    
77. 
    
78. Disassembly of section .text:
    
79. 
    
80. 0000000000401020 <main>:
    
81.   401020:        55                           pushq  %rbp
    
82.   401021:        48 89 e5                     movq   %rsp,%rbp
    
83.   401024:        48 8d 05 d5 0f 00 00         leaq   0xfd5(%rip),%rax        # 402000 <_start+0xfc0>
    
84.   40102b:        48 89 c7                     movq   %rax,%rdi
    
85.   40102e:        e8 dd ff ff ff               callq  401010 <puts@plt>
    
86.   401033:        b8 00 00 00 00               movl   $0x0,%eax
    
87.   401038:        5d                           popq   %rbp
    
88.   401039:        c3                           retq
    
89.   40103a:        66 0f 1f 44 00 00            nopw   0x0(%rax,%rax,1)
    
90. 
    
91. 0000000000401040 <_start>:
    
92.   401040:        f3 0f 1e fa                  endbr64
    
93.   401044:        31 ed                        xorl   %ebp,%ebp
    
94.   401046:        49 89 d1                     movq   %rdx,%r9
    
95.   401049:        5e                           popq   %rsi
    
96.   40104a:        48 89 e2                     movq   %rsp,%rdx
    
97.   40104d:        48 83 e4 f0                  andq   $0xfffffffffffffff0,%rsp
    
98.   401051:        50                           pushq  %rax
    
99.   401052:        54                           pushq  %rsp
    
100.   401053:        45 31 c0                     xorl   %r8d,%r8d
     
101.   401056:        31 c9                        xorl   %ecx,%ecx
     
102.   401058:        48 c7 c7 20 10 40 00         movq   $0x401020,%rdi
     
103.   40105f:        ff 15 93 2f 00 00            callq  *0x2f93(%rip)        # 403ff8 <__libc_start_main@GLIBC_2.34>
     
104.   401065:        f4                           hlt
     
105. $

复制代码

wp231957

人造人 发表于 2022-5-19 19:57

原来，没有头文件  真的能运行呀

1. int        printf (const char *__restrict, ...);
   
2. double sqrt (double);
   
3. 
   
4. int main()
   
5. {
   
6.     printf("a+b=%lf\n",sqrt(15));
   
7.     return 0;
   
8. }
   

复制代码