C语言编译过程

C语言编译过程

  • 1、C语言编译过程
  • 2、单c文件编译实践
  • 3、多c文件编译实践
  • 4、define
    • 4.1、不带参宏
    • 4.2、带参宏
    • 4.3、带参宏和带参函数的区别
  • 5、选择性编译ifdef、ifndef、if
    • 5.1、#ifdef
    • 5.2、#ifndef
    • 5.3、#if
  • 6、静态库和动态链接库
    • 6.1、静态库实践
      • 6.1.1、将mylib.c制作成静态库
      • 6.1.2、编译源程序
    • 6.2、动态库实践
      • 6.2.1、将mylib.c制作成动态链接库
      • 6.2.2、动态链接库的使用

1、C语言编译过程

1、预编译
.c 中的头文件展开、宏展开。生成的文件是 .i 文件。预处理操作过程不会进行语法检查。
2、编译
将预处理之后的 .i 文件生成 .s 汇编文件
3、汇编
.s 汇编文件生成 .o 目标文件
4、链接
.o 文件链接成 可执行目标文件

C语言编译过程_第1张图片 C语言编译过程_第2张图片

2、单c文件编译实践

hello.c文件

#include

int main() {
	printf("Hello World! \n");
	return 0;
}
Linux 下GCC 编译器编译过程
1、预处理
gcc -E hello.c -o hello.i
2、编译
gcc -S hello.i -o hello.s
3、汇编
gcc -c hello.s -o hello.o
4、链接
gcc hello.o -o hello
C语言编译过程_第3张图片

3、多c文件编译实践

#include // 用尖括号包含头文件,在系统指定的路径下找头文件
#include "xxx.h" // 用双引号包含头文件,先在当前目录下找头文件,找不到,再到系统指定的路径下找。
注意:include 经常用来包含头文件,可以包含.c 文件,但是大家不要包含.c。
因为 include 包含的文件会在预编译被展开,如果一个.c 被包含多次,展开多次,会导致函数重复定义。所以不要包含.c 文件。

test.c文件

#include
#include "max.h"
#include "min.h"

int main() {
	int maxVal = max(1, 5);
	int minVal = min(1, 5);
	printf("最大值maxVal = %d;最小值minVal = %d \n", maxVal, minVal);
	return 0;
}

max.c文件

int max(int v1, int v2) {
	int z;
	if (v1>v2) {
		z = v1;
	}else {
		z = v2;
	}
	return z;
}

min.c文件

int min(int v1, int v2) {
	int z;
	if (v1 < v2) {
		z = v1;
	}else {
		z = v2;
	}
	return z;
}

max.h文件

extern int max(int v1, int v2);

min.h文件

extern int min(int v1, int v2);
gcc -E test.c -o test.i
gcc -S test.i -o test.s
gcc -c test.s -o test.o

gcc -E max.c -o max.i
gcc -S max.i -o max.s
gcc -c max.s -o max.o

gcc -E min.c -o min.i
gcc -S min.i -o min.s
gcc -c min.s -o min.o

gcc test.o max.o min.o -o test
C语言编译过程_第4张图片

4、define

定义宏用 define 关键字,宏是在预编译的时候进行替换。

4.1、不带参宏

#define PI 3.1415926

在预编译的时候如果代码中出现了 PI 就用 3.1415926 去替换。
宏定义的好处:只要修改宏定义,其他地方在预编译的时候就会重新替换。
注意:宏定义后边不要加分号。

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

//终止PI 的作用
#undef PI

4.2、带参宏

#define S(a,b) a*b

注意带参宏的形参 a 和 b 没有类型名:(注意歧义)
S(1,5) 即【1*5
S(3+4,3) 即【3+4 * 3
S((3+4),3) 即【(3+4)*3

4.3、带参宏和带参函数的区别

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

带参函数是浪费了时间,节省了空间。
带参函数的形参是有类型的,带参宏的形参没有类型名。

5、选择性编译ifdef、ifndef、if

选择性编译都是在预编译阶段处理的事情。

5.1、#ifdef

#ifdef AAA
	代码段一
#else
	代码段二
#endif
#include
#define AAA

int main(int argc, char *argv[]){
#ifdef AAA
	printf("Hello World!\n");
#else
	printf("Hello China!\n");
#endif
	return 0;
}

5.2、#ifndef

#ifndef AAA
	代码段一
#else
	代码段二
#endif

#ifndef#ifdef 是一种互补。这种方法,经常用在防止头文件重复包含。

5.3、#if

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

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

6、静态库和动态链接库

一、动态编译
动态编译使用的是动态库文件进行编译,默认使用的就是动态编译。

gcc hello.c -o hello1

二、静态编译
静态编译使用的静态库文件进行编译。

gcc -static hello.c -o hello2
C语言编译过程_第5张图片

三、静态编译和动态编译区别
1、使用的库文件的格式不一样:动态编译使用动态库,静态编译使用静态库。
2、静态编译要把静态库文件打包编译到可执行程序中。
3、动态编译不会把动态库文件打包编译到可执行程序中,它只是编译链接关系。

=== mytest.c ====================================
#include 
#include "mylib.h"

int main(int argc, char* argv[]) {
	int a = 10, b = 20, max_num, min_num;
	max_num = max_fun(a, b);
	min_num = min_fun(a, b);
	printf("max_num = %d \n", max_num);
	printf("min_num = %d \n", min_num);
	return 0;
}

=== mylib.c ====================================
int max_fun(int x, int y) {
	return (x > y) ? x : y;
}

int min_fun(int x, int y) {
	return (x < y) ? x : y;
}

=== mylib.h ====================================
#ifndef __MYLIB_H__
#define __MYLIB_H__
extern int max_fun(int x, int y);
extern int min_fun(int x, int y);
#endif

6.1、静态库实践

6.1.1、将mylib.c制作成静态库

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

注意:静态库文件 起名的时候必须以 lib 开头以 .a 结尾

6.1.2、编译源程序

方法1:在同一目录下编译
编译源程序命令:

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

方法2:可以指定头文件及库文件的路径
如将 libmylib.a mylib.h 移动到 /root/staticlib

mv libmylib.a mylib.h /root/staticlib

编译源程序命令:

gcc mytest.c \
-static \
-o mytest \
-L /root/staticlib \
-l mylib \
-I /root/staticlib

注意:
-L 是指定库文件的路径
-l 指定找哪个库,指定的只要库文件名 lib 后面 .a 前面的部分
-I 指定头文件的路径

方法3:将库文件及头文件存放到系统默认指定路径
库文件 默认路径是 /lib 或者是 /usr/lib
头文件 默认路径是 /usr/include

mv libmylib.a /usr/lib
mv mylib.h /usr/include

编译源程序的命令

gcc mytest.c -o mytest -l mylib -static 

6.2、动态库实践

6.2.1、将mylib.c制作成动态链接库

使用gcc 编译、制作动态链接库

gcc -shared mylib.c -o libmylib.so

注意:动态链接库文件 起名的时候必须以 lib 开头以 .so 结尾

6.2.2、动态链接库的使用

方法1:库函数、头文件均在当前目录下

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

此时就可以在执行了哦: ./mytest

方法2:库函数、头文件假设在 /opt/ 目录

mv libmylib.so mylib.h /opt
gcc mytest.c -o mytest -L/opt -lmylib -I/opt

编译通过,运行 mytest 时出错,编译时找到了库函数,但运行链接时找不到库,要把链接库文件所在目录加入默认搜索路径
export LD_LIBRARY_PATH=/opt:$LD_LIBRARY_PATH

此时就可以在执行了哦: ./mytest

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

cp libmylib.so /usr/lib
cp mylib.h /usr/include
gcc mytest.c -o mytest -lmylib

如果出现如下错误,则添加查找路径,解决问题

[root@michael cc]# ./mytest 
./mytest: error while loading shared libraries: libmylib.so: cannot open shared object file: No such file or directory

解决方案:
export LD_LIBRARY_PATH=/usr/lib:$LD_LIBRARY_PATH

此时就可以在执行了哦: ./mytest

注:
问:此时有个问题出现了?静态库 和 动态库 都在 /usr/lib 下,那么默认链接的到底是动态库还是静态库呢?
答:当静态库与动态库重名时,系统会优先连接动态库,或者编译时加入-static 指定使用静态库。

你可能感兴趣的:(数据结构与算法,c++,linux,开发语言)