C语言模块化编程

1.多文件编译、链接的原理

在讲解和关键字的时候，我们已经给出了几个简单的多文件的例子，现在不妨再看一个例子。

main.c ：

1. #include
2. #include
3.  
4. // 也可以不写 extern；为了程序可读性，建议写上
5. extern long sum(int, int);
6. // 必须写 extern
7. extern char* os;
8.  
9. int main()
10. {
11. int n1 = 1, n2 = 100;
12. printf("从%d加到%d的和为%ld [by %s]", n1, n2, sum(n1, n2), os);
13.  
14. getch();
15. return 0;
16. }

module.c 源码：

1. #include
2.  
3. // 当前操作
4. char *os = "windows 7";
5.  
6. long sum(int fromnum, int endnum){
7. int i;
8. long result = 0;
9.  
10. // 参数不符合规则，返回 -1
11. if(fromnum<0 || endnum<0 || endnum
12. return -1;
14. }
15.  
16. for(i=fromnum; i<=endnum; i++){
17. result += i;
18. }
19.  
20. // 返回大于等于0的值
21. return result;
22. }

运行结果：
从1加到100的和为5050 [by windows 7]

这个程序，我们按照“编译 --> 链接 --> 运行”的步骤来生成，不要按 f5 或者 f7（对于 visual c++）直接生成 exe。如果已经生成，可以清理掉相关文件。

注意：一个程序有且只能有一个 main() 函数，即使它有多个源文件。main() 函数是程序的入口函数，双击运行程序时就从这里开始执行。

编译和链接的原理

对于c，首先要把源文件编译（compile）成目标文件（object file），也就是windows下的 .obj 文件。然后再把单个或多个 object file 合并成可执行文件，也就是windows下是 .exe 文件，这个动作叫作链接（link）。

编译时，编译器需要检查语法是否正确，函数、变量的声明是否正确；只有函数、变量的声明但没有定义是完全正确的。函数声明是告诉编译器该函数已经存在，但是入口地址还未确定，暂时在此做个标记，链接时编译器会找到函数入口地址，并将标记替换掉。

这些都校验通过，编译器就可以编译出中间目标文件。一般来说，编译是针对单个源文件的，多个源文件需要编译多次，每个源文件都会生成一个对应的目标文件。

编译产生的 .obj 文件已经是二进制文件，与 .exe 的组织形式类似，只是有些函数的入口地址还未找到，程序不能执行。链接的作用就是找到函数入口地址，将所有的源文件组织成一个可以执行的二进制文件。

链接时，主要是链接函数和全局变量。链接器并不管函数或变量所在的源文件，只管中间目标文件（object file）。

总结一下：源文件首先会生成中间目标文件，再由中间目标文件生成可执行文件。在编译时，编译器只检测程序语法、函数声明、变量声明是否正确。如果函数未被声明，编译器会给出一个警告，但可以生成object file。而在链接程序时，链接器会在所有的object file中找寻函数的实现，如果找不到，那到就会报链接错误码（linker error），在vc下，这种错误一般是 link 2001 错误，意思说是说，链接器未能找到函数的实现。你需要指定函数的object file。

一步一步生成 exe 文件

知道了编译链接的原理，接下来我们使用vc一步步的生成 .exe 文件。

首先切换到 main.c 面板，按下 ctrl+f7 键（编译），打开项目目录下的release 或 debug 文件夹，可以看到多出了一个 main.obj 文件，这就是 main.c 生成的目标文件。

再切换到 module.c 面板，进行同样的操作，会生成 module.obj 文件，至此编译完毕（所有的源文件都编译过了）。

最后，按下 f7 键（链接），就生成了 main.exe，双击运行就可以看到上面的输出结果了。

 

 

2.c语言模块化编程中的头文件

上节我们编写了 main.c 和 module.c 两个源文件，并在 module.c 中定义了一个函数和一个全局变量，然后在 main.c 中进行了声明。

不过实际开发中很少这样做，一般是将函数和变量的声明放到头文件，再在当前的源文件中 #include 进来。而且，全局变量最好声明为 static，只在当前文件中可见，不要对外暴露；如果必须对外暴露，可以使用宏定义代替，请看下面的代码。

main.c 源码：

1. #include
2. #include
3. #include "module.h"
4.  
5. int main()
6. {
7. int n1 = 1, n2 = 100;
8. printf("从%d加到%d的和为%ld [by %s]", n1, n2, sum(n1, n2), os);
9.  
10. getch();
11. return 0;
12. }

module.c 源码：

1. #include
2.  
3. long sum(int fromnum, int endnum){
4. int i;
5. long result = 0;
6.  
7. // 参数不符合规则，返回 -1
8. if(fromnum<0 || endnum<0 || endnum
9. return -1;
11. }
12.  
13. for(i=fromnum; i<=endnum; i++){
14. result += i;
15. }
16.  
17. // 返回大于等于0的值
18. return result;
19. }

module.h 源码：

1. // 用宏定义来代替全局变量
2. #define os "windows 7"
3.  
4. // 也可以省略 extern；不过为了程序可读性，建议写上
5. extern long sum(int, int);

运行结果：
从1加到100的和为5050 [by windows 7]

与上节中的例子相比，我们用宏定义代替了全局变量，将函数声明和宏定义都放在了头文件 module.h，这样在 main.c 中只需要将 module.h 包含就来就可以。

.c 文件和 .h 文件都是源文件，除了后缀不一样便于区分外和管理外，其他的几乎相同，在 .c 中编写的代码同样也可以写在 .h 中，例如函数定义、预处理等。

但是 .h 文件和 .c 文件在项目中承担的角色不一样：.c 文件主要负责实现，也就是定义函数；.h 文件主要负责声明，比如函数声明、宏定义等。这些不是c语法规定的内容，而是约定成俗的规范。

下面是关于头文件的事实标准：

• 可以声明函数，但不可以定义函数。可以申明常量，但不可以定义变量。可以“定义”一个宏函数。注意：宏函数很象函数，但却不是函数。其实还是一个声明。结构的定义、自定义数据类型一般也放在头文件中。除了主文件（有 main() 函数的文件），其他的 .c 文件一般只定义函数，并向外暴露（可以使用 extern，也可以不使用）。可以将一个或多个相关的函数定义在一个 .c 文件。
  在很多场合，为了商业目的，项目的源代码不便（或不准）向用户公布，必须编译成 .obj 文件（二进制库）。我们只要向用户提供库文件和头文件就可以，用户会按照头文件中的函数的声明来调用库中的函数，而不需要知道函数是怎么实现的，这就很好的保护了我们的版权。
  

   

   

  3.c语言标准库以及标准头文件

  源文件通过编译可以生成 .obj 文件（二进制库文件），并提供一个头文件向外暴露接口，除了保护版权，还可以将散乱的文件打包，便于发布和使用。
  
  实际上我们一般不直接向用户提供 .obj 文件，而是将多个 .obj 文件打包成 .lib 文件（静态库）或 .dll 文件（动态库）。
  
  .obj 打包成 .lib 或 .dll 也要经过链接的过程来找到函数入口、变量声明等，在vc中可以直接创建相应的工程来生成（与创建 win32 console application 类似，后续会讲解）。
  
  .lib 和 .dll 可以看成是一堆 .obj 的集合，虽然有入口函数，但不能直接运行，必须被链接到 .exe 或被 .exe 调用。
  
  c语言在发布时已经将常用的函数、宏、类型定义等打包到了静态库，并提供了相应的头文件。如果你使用的是vc，那么在安装目录下的\vc98\include\ 文件夹中会看到很多头文件，包括我们常用的 stdio.h、stdlib.h 等；在\vc98\lib\ 文件夹中有很多 .lib 文件，这就是我们链接时要用到的静态库。
  
  例如我的 vc6.0 安装在c:\program files\microsoft visual studio\ 目录，那么 vc6.0 附带的所有头文件都在c:\program files\microsoft visual studio\vc98\include\ 目录下，所有 .lib 文件都在 c:\program files\microsoft visual studio\vc98\include\lib\ 目录下。
  
  如果忘记 vc6.0 的安装目录或者头文件不在安装目录下，可以通过以下方式找到：
  
  1) 在工具栏中点击“工具”按钮
  
  2) 在二级菜单中选择“选项”
  
  3) 在弹出的对话框中选择“目录”标签
  
  4) 然后选择名字为“目录”的下拉菜单中的“include files”一项，如下图所示：
  
  
  ansi c 规范共定义了 15 个头文件，称为“c标准库”，所有的编译器都必须支持，如何正确并熟练的使用这些标准库，可以反映出一个程序员的水平：

  • 合格程序员：、、、熟练程序员：、、、优秀程序员：、、、、、、
    各个头文件的具体内容请查看：c语言标准库
    
    除了c标准库，编译器一般也会附带自己的库，以增加功能，方便用户开发，争夺市场份额。这些库中的每一个函数都在对应的头文件中声明，可以通过 #include 预处理命令导入，编译时会被合并到当前文件。
    
    注意：引入编译器自带的头文件（包括标准头文件）用尖括号，引入自定义头文件用双引号，例如：

    复制纯文本新窗口

    1. #include
    2. #include "myfile.h"
    
    

     

    4.c语言头文件的特性和规范

    头文件通过 #include 命令包含到当前文件，效果与直接复制头文件的内容相同；编译器在预处理阶段实际上也是这样做的。
    
    不管是标准头文件还是我们自己编写的头文件，都应该遵循等幂性：可以多次包含相同的头文件，但效果与只包含一次相同。
    
    等幂性很容易实现，对于大多数的头文件可以使用宏保护。例如，在 stdio.h 中可以有如下的宏定义：

    1. #ifndef _stdio_h
    2. #define _stdio_h
    3. /* 声明部分 */
    4. #endif
    第一次包含头文件，会定义宏 _stdio_h，并执行声明部分的代码；第二次因为已经定义了宏 _stdio_h，不会重复执行声明部分的代码。也就是说，头文件只在第一次包含时起作用，再次包含无效。
    
    c标准库的头文件，也具有相互独立性：任何标准头文件的正常工作都不需要以包含其他标准头文件为前提，也没有任何标准头文件包含了其他标准头文件。
    
    在c程序员中所达成的一个约定是：c源文件的开头部分要包含所有要用到的头文件。在 #include 指令之前只能有一句注释语句。引入的头文件可以按任意顺序排列。
    
    如果我们自己编写的头文件（例如a.h）会用到其他头文件（例如 b.h）中的定义或声明，也可以在 a.h 的开头 #include “b.h”。这样，就不会在 .c 文件中忘记包含 b.h，也不会有顺序问题。这正是利用了头文件的等幂性。
    

     

     

    5.c语言头文件的路径

    引入编译器自带的头文件（包括标准头文件）用尖括号，引入自定义头文件用双引号，例如：

    1. #include
    2. #include "myfile.h"
    这是由头文件的路径决定的。理论上，你可以将头文件放在磁盘上的任何位置，只要带路径包含进来就可以。下面我们以 vc 6.0 为例进行讲解。
    
    vc 6.0 在安装时会自动添加多个环境变量。例如我的 vc 6.0 安装在 c:\program files\microsoft visual studio 目录下，那么：
    • 环境变量 include 中会包含c:\program files\microsoft visual studio\vc98\include，用以指向头文件所在的目录（编译时需要头文件）；环境变量 lib 中会包含c:\program files\microsoft visual studio\vc98\lib，用以指向静态库所在的目录（链接时需要静态库）。
      使用尖括号，编译器会到环境变量 include 指定的目录去查找头文件。
      
      使用双引号，编译器首先会在当前目录查找，找到就包含就来，找不到再到环境变量 include 指定的目录去查找。
      
      注意：这里说的当前目录不是指当前工程的根目录，而是要编译的文件所在的目录。
      
      例如我们通过 vc 6.0 创建了一个工程，命名为 demo，保存在 e:\demo（工程根目录）。现在e:\demo 目录下有 main.c，e:\demo\include 下有 func.h，e:\demo\module 下有 func.c，如下图所示：
      
      
      如果main.c 需要包含func.h，就要：
      1. #include "include/func.h"
      如果 func.c 需要包含 func.h，就要：
      1. #include "../include/func.h" /* ../ 表示上级目录 */
      
      注意，包含头文件时你可以使用正斜杠(/)，也可以使用反斜杠(/)，它们都可以表示目录的层次。
      
      上面说的是相对路径，以当前文件所在的目录为起点开始查找。一般情况下头文件都在工程目录，使用相对路径比较方便。
      
      如果头文件不在工程目录并且离当前文件比较远，你也可以使用绝对路径，例如：
      1. #include "e:\demo\include\func.h"
      绝对路径以分区（盘符）为起点开始查找。
      

       

       

      6.一个比较规范的c语言多文件编程的例子

      这一节向大家展示一个比较规范的多文件编程的例子，将前面几节的知识运用起来。
      
      通过 vc 6.0 创建一个工程，保存到 e:\demo 目录，工程文件有：
      
      
      main.c 源码：

      1. #include
      2. #include
      3. #include "include/func.h"
      4.  
      5. int main()
      6. {
      7. int n1 = 1, n2 = 10;
      8. printf("从%d加到%d的和为%ld\n", n1, n2, sum(n1, n2));
      9. printf("从%d乘到%d的积为%ld\n", n1, n2, mult(n1, n2));
      10. printf("os：%s\n",os);
      11. printf("power by %s（%s）", getwebname(), getweburl());
      12.  
      13. getch();
      14. return 0;
      15. }
      math.c 源码：
      1. // 没有使用到 func.h 中的函数声明或宏定义，也可以不包含进来
      2. #include "../include/func.h"
      3.  
      4. // 从 fromnum 加到 endnum
      5. long sum(int fromnum, int endnum){
      6. int i;
      7. long result = 0;
      8.  
      9. // 参数不符合规则，返回 -1
      10. if(fromnum<0 || endnum<0 || endnum
      11. return -1;
      13. }
      14.  
      15. for(i=fromnum; i<=endnum; i++){
      16. result += i;
      17. }
      18.  
      19. // 返回大于等于0的值
      20. return result;
      21. }
      22.  
      23. // 从 fromnum 乘到 endnum
      24. long mult(int fromnum, int endnum){
      25. int i;
      26. long result = 1;
      27.  
      28. // 参数不符合规则，返回 -1
      29. if(fromnum<0 || endnum<0 || endnum
      30. return -1;
      32. }
      33.  
      34. for(i=fromnum; i<=endnum; i++){
      35. result *= i;
      36. }
      37.  
      38. // 返回大于等于0的值
      39. return result;
      40. }
web.c 源码：

1. // 使用到了 func.h 中的宏定义，必须包含进来，否则编译错误
2. #include "../include/func.h"
3.  
4. char* getwebname(){
5. return web_name;
6. }
7.  
8. char* getweburl(){
9. return web_url;
10. }

func.h 源码：

1. #ifndef _func_h
2. #define _func_h
3.  
4. // 用宏定义来代替全局变量
5. #define os "windows 7"
6. #define web_url "http://c.biancheng.net"
7. #define web_name "c语言中文网"
8.  
9. // 也可以省略 extern，不过为了程序可读性，建议都写上
10. extern long sum(int, int);
11. extern long mult(int, int);
12. extern char* getwebname();
13. extern char* getweburl();
14.  
15. #endif

运行结果：
从1加到10的和为55
从1乘到10的积为3628800
os：windows 7
power by c语言中文网（http://c.biancheng.net）