函数文件编译成  .o  提高编译速度

.h    声明函数类型参数

gcc -c  xxx.c  -o xx.o

gcc xx.o  xx.o xx.c 

将不需要改动的一些公共类文件编译后弄成静态库可以大大增加运行效率

例子

gcc -c max.c -o max.o

调用

 gcc max.o hello.c

也可以用.h头文件声明函数，进行头文件调用

//4-2 头文件与函数分离

max.c 需要编译成max.o

int max(int a,int b)

{

if(a > b){

return a;

}else{

return b;

}

}

max.h 头文件

int max(int a,int b);

main.c 主入口

#include <stdio.h>

#include "max.h"

int main(){

int a = 22;

int b = 33;

int maxNum = max(a, b);

printf("the max value is %d\n",maxNum);

return 0;

}

编译结果：

flys@ubuntu:~/Fly/Test/demo1$ gcc max.o main.c -o main.out 编译

flys@ubuntu:~/Fly/Test/demo1$ ./main.out 运行

the max value is 33 结果

gcc -c max.c -o max.o：将max.c编译为.o文件，里面是机器码，主要用于节约时间，不用改动的程序可以像这样提前编译，最后一起放入静态库。

max.o和hello.c一起编译的时候，hello.c里面的max.c声明要取消。

你编译max.o可能不知道里面的具体内容，这个时候可以用vi指令创建一个.h文件，里面写上代码内容，最后再在hello.c里面加上.h文件的声明（#include"xxx.h"）

cat xxx.c查看代码

gcc max.o hello.c进行编译

wu

gcc -c max.c -o max.o

部分文件编译，先翻译成不可执行的机器码

//#include "max.c"

在主函数文件中注释掉编译已完成的文件，不然会重复出现max()

gcc max.o hello.c

完成编译

目的：节约时间（使编译可以碎片化，不然单次编译时间可能过长）

使用头文件声明函数，放入主函数文件预处理，方便查看函数返回值类型及参数类型。

一、函数可以先编译成.o文件，然后再和主函数文件一起编译成可执行文件。在源代码多的时候可以提高效率。例如：1、gcc-c min.c -o min.o 2、gcc min.o hello.c 

二、cat+文件名 命令可以查看源代码。 

三、.o文件为机器码，可以编写一个.h文件，然后在主文件中进行预处理声明 #include".h"。 通过cat +.h文件别人就可以知道你编写的函数的类型及参数。

四、.c C语言源代码 .o编译过的二进制机器码文件 .h函数说明文件（没有源代码时，看.h就知道函数使用方法）PS：.h没有实际代码作用，仅供查看。

五、把不常改动的函数，类和框架提前编译好生成静态库（.o文件，减少主函数编译时间）

查看文件，cat a.c

拷贝，cp max.c min.c

计算机将代码编译成机器码很耗时间，可以把其他文件转换为.o

gcc -c A.c -o A.o

4-1

ESC模式下：

• :sp xxx.c    分割屏幕

• CTRL + W + ↓   切换到下面的编辑区域（反之亦然）

• :set nu   显示行号

• 从光标位置输入 数字+dd   从该位置往下n行剪切

• p   粘贴

• :wqa 保存/退出/全部文件

• :ZZ 保存并退出

同时编译两个文件并输出一个文件 gcc A.c B.c -o main.out

若A.c引用B.c中的相关函数，则需要在开头进行声明 #include "B.c"

声明过后则只需要编译A.c文件即可得到同样的输出

分开编译

gcc max.o min.o hello.c

一、函数可以先编译成.o文件，然后再和主文件一起编译成可执行文件。在源代码多的时候可以提高效率。例如：1、gcc-c min.c -o min.o 2、gcc min.o hello.c 二、cat命令可以查看源代码。 三、.o文件不能被其他人查看，可以编写一个.h文件，然后在主文件中进行预处理声明 #include".h"。 通过.h文件别人就可以知道你编写的函数的类型了。

.c C语言源代码 .o编译过的二进制机器码文件 .h函数说明文件（没有源代码时，看.h就知道函数使用方法）PS：.h没有实际代码作用，仅供查看。 gcc编译流程分为4步 预处理(Pre-Processing) －> 编译(Compling) -> 汇编(Assembling) -> 连接(Linking) 预处理：处理#include、#define、#ifdef 等宏命令 编译：把预处理完的文件编译为汇编程序.s 汇编：把汇编程序.s编译为.o二进制文件 链接：把多个二进制文件.o集合（链接）成一个可执行文件 cp A  B   ----将A文件中的内容复制到B文件 cat A -----显示A 文件中的内容

gcc - c max.c -o max.o

//#include<stdio.h>

gcc max.o hello.c

编译之后生成  .o文件

拷贝文件   cp 

把不常改动的函数，类和框架提前编译好生成静态库

查看源代码 cat hello.c

.o文件不可读

.h文件放声明   int max(int a,int b);

#include"max.h"  便于让没有编写max函数的人使用max函数

gcc max.o min.o hello.c  3个文件一起写，否则找不到max，min函数

c语言的入口文件是main 函数

：sp max.c  新建了一个max.c,光标在上面

ctrl+w+/downarrow 光标跳转到下面

:set nu 显示行数

：9(行数字)+dd 剪切复制这几行代码到剪切板

:ctrl+w+/uparrow 

p粘贴

gcc -c max.c -o max.o 编译成机器码

cc -c a.c -o a.o

将c文件转换成二进制文件

cc a.o main.c

cp a.c b.c拷贝

cat 终端显示查看

a.h 自创头文件

gcc -c 文件名.c  -o 文件名.o

将文件编译成机器码文件；

gcc 文件1.o  文件2.c

此时不需要在文件2.c中 include 文件1，节约CPU资源；

实际上.c执行的是.o中的文件;通过.h文件 可以知道 .o 的参数类型 参数个数 返回值  这些声明 （.o 二进制文件）（.h文件实现类似备注的效果）

头文件中只需要声明就可以；

gcc -c 文件名.c -o 文件名.o

预处理编译,静态库,不需再次编译

gcc 文件.o 文件.c (-o 文件名)//将已编译的o文件与.c 文件链接

翻译成.o文件（机器语言），节省时间提升效率；实际上.c执行的是.o中的文件;通过.h文件 可以知道 .o 的参数类型 参数个数 返回值  这些声明 （.o 二进制文件）（.h文件实现类似备注的效果）

cp 复制文件     cat 查看文件内容

通过.h文件 可以知道 .o 的参数类型 参数个数 返回值  这些声明 （.o 二进制文件）（.h文件实现类似备注的效果）

分开编译：gcc -c 文件名.c -o 文件名.o

编译成文件名.o后，需修改主函数文件，注意原文件.c的声明

然后在编译主程序时：gcc 文件名.o 文件名.c————节省时间，加快速度

拷贝文件：cp 文件名.c（复制文件） 文件名.c（粘贴文件）

把不常修改的程序编译后保存为“静态库”，方便使用，加快编译速度。

查看源代码程序：cat 文件名.c

使用别人的静态库.o文件可以创建.h文件，然后在源程序中#include<文件名.h>来引用

不会再修改的函数公共框架和公共类生成静态库

使用#include"file.c"在编译的时候相当于把file.c整个copy到main.c文件中，依然很慢。 解决方案：先将file.c单独编译后调用file.o文件（编译后文件），避免了在main.c中file.c可能的多次重复编译。 也就是将一部分不常改动（但是常用）的函数提前编译好，可以极大地提高效率。 可以把main.c先编译成不可执行的main.o gcc -c main.c -o main.o 再将main.o和hello.c一起快速编译成可执行的main.out gcc main.o hello.c -o main.out