16.预处理、动态库、静态库

C语言编译过程

1.预处理
将.c中的头文件展开、宏展开
生成的文件是.i文件
2.编译
将预处理之后的.i文件生成.s汇编文件
3.汇编
将.s汇编文件生成.o目标文件
4.链接
将.o文件链接成目标文件（可执行程序）

Linux下GCC编译器编译过程

gcc -E hello.c -o hello.i 1.预处理
gcc -S hello.i -o hello.s 2.编译
gcc -c hello.s -o hello.o 3.汇编
gcc hello.o -o hello_elf 4.链接

include预处理

#include<> //用尖括号包含头文件，在系统指定的路径下找头文件

#include" " //用双引号包含头文件，先在当前目录下找头文件，再到系统指定路径下查找。

注意：include经常用来包含头文件，可以包含.c文件，但include包含的文件会在预编译被展开，如果一个.c被包含多次，在预处理时会被展开多次，导致函数重复定义。尽量避免包含.c文件。
预处理只是对include等预处理操作进行处理并不会进行语法检查，这个阶段有语法错误不会报错，第二个阶段即编译阶段才会进行语法检查。

define定义宏

宏是在预编译的时候进行替换。

1.不带参宏

#define PI 3.14

在预编译的时候如果代码中出现了PI就用3.14去替换。
宏的好处：只需要修改宏定义，其他地方在预编译的时候就会重新替换。

注意：宏定义后边不要加分号。

宏定义的作用范围：从定义的地方到本文件末尾。
如果想在中间终止宏的定义范围

#undef PI //终止PI的作用

#include
#define PI 3.1415926
int main()
{
	double f;
	printf("PI=%lf\n", PI);
#undef PI
#define PI 3.14
	f = PI;
	printf("f=%lf\n", f);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

2.带参宏

#define S(a,b) a*b

注意带参宏的形参a和b没有类型名
S( 2, 4 )将来在预处理的时候替换成 实参替代字符串的形参，其他字符保留

#include
#define S(a,b) a*b
int main()
{
	int num;
	num = S(2, 4);
	printf("num=%d\n", num);
	num = S(3, 5);
	printf("num=%d\n", num);
	num = S(4, 6);
	printf("num=%d\n", num);
	num = S(3+5, 7);//3+5*7
	printf("num=%d\n", num);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

解决方法：

#include
#define S(a,b) (a)*(b)
int main()
{
	int num;
	num = S(2, 4);
	printf("num=%d\n", num);
	num = S(3+5, 7);//(3+5)*(7)
	printf("num=%d\n", num);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

3.带参宏和带参函数的区别

带参宏被调用多少次就会展开多少次，执行代码的时候没有函数调用的过程，不需要圧栈弹栈。所以带参宏浪费空间，因为被展开多次，节省时间。
带参函数，代码只有一份，存在代码段，调用的时候去代码段取指令，调用的时候要圧栈弹栈。有调用的过程。所以说，带参函数是浪费了时间，节省了空间。
带参函数的形参是有类型的，带参宏的形参没有类型名。

选择性编译

1.#ifdef

#ifdef AAA
代码段1
#else
代码段2
#endif

如果在当前.c ifdef上定义过AAA，就编译代码段一，否则编译代码段二
注意和if else 语句的区别，if else 语句都会被编译，通过条件选择执行代码，而选择性编译，只有一块代码被编译。

#include
#define AAA
int main()
{
#ifdef AAA
	printf("hello world!\n");
#else
	printf("hello china!\n");
#endif
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12

2.#ifndef

#ifndef AAA
代码段1
#else
代码段2
#endif

和 #ifdef 互补。
这种方法，经常用在防止头文件重复包含。

#include"5.h"
#include"5.h"
int main()
{
	return 0;
}
1
2
3
4
5
6

5.h：

#ifndef __5_H__ //防止头文件重复包含
#define __5_H__
extern int fun(int x, int y);
#endif

1
2
3
4
5

3.#if

#if 表达式
程序段一
#else
程序段二
#endif

如果表达式为真，编译第一段代码，否则编译第二段代码。

#include
int main()
{
#if 1
	printf("hello world\n");
#else
	printf("hello china!\n");
#endif
	return 0;
}
1
2
3
4
5
6
7
8
9
10

选择性编译都是在预编译阶段干得事情。

静态库

1.动态编译

动态编译使用的是动态库文件进行编译

gcc hello.c -o hello

默认使用动态编译方法。

2.静态编译

静态编译使用静态库文件进行编译

gcc -static hello.c -o hello

3.静态编译和动态编译的区别

• 使用的库文件格式不一样，动态编译使用动态库，静态编译使用静态库。

• 静态编译要把静态库文件打包编译到可执行程序中。

• 动态编译不会把动态库文件打包编译到可执行程序中，它只是编译链接关系。

4.静态库文件的制作

gcc -c mylib.c -o mylib.o
ar rc libtestlib.a mylib.o

注意：静态库起名必须以lib开头，以.a结尾。

编译程序：
方法a

gcc -static mytest.c libtestlib.a -o mytest

方法b
可以指定头文件及库文件的路径：
比如将libtestlib.a mylib.h 移动到/home/edu下

mv libtestlib.a mylib.h /home/edu

编译程序命令：

gcc -static mytest.c -o mytest -L/home/edu -ltestlib -I/home/edu

注意：
-L 是指定库文件的路径
-l(小L) 指找哪个库，只需要库文件名lib后面，.a前面的部分
-I(大i) 指头文件的路径

方法c
将库文件及头文件放到系统默认路径下
库文件的默认路径 /lib 或者是 /usr/lib
头文件的默认路径是 /usr/include

sudo mv libtestlib.a /usr/lib
sudo mv mylib.h /usr/include

编译程序命令

gcc -static mytest.c -o mytest -Itestlib

5.动态库的制作

制作动态链接库

gcc -shared mylib.c -o libtestlib.so
//使用gcc编译、制作动态链接库

动态链接库的使用：
方法a
库文件、头文件均在当前目录下

gcc mytest.c libtestlib.so -o mytest
export LD_LIBRARYA_PATH=./:$LD_LIBRARY_PATH
./mytest

方法b
库文件、头文件假设在/opt目录

gcc mytest.c -o mytest -L/home/teacher -ltestlib -I/home/teacher

编译通过，运行时出错，编译时找到了库函数，但链接时找不到库，执行以下操作，把当前目录加入搜索路径

export LD_LIBRARYA_PATH=./home/edu:$LD_LIBRARY_PATH
./mytest //可找到动态链接库

方法c
库函数、头文件均在系统路径下

cp libtestlib.so /usr/lib
cp mylib.h /usr/include
gcc mytest.c -o mytest -ltestlib