GCC是一款广泛使用的开源编译器，它支持多种编程语言，并且具有强大的编译能力。在软件开发中，我们经常需要将代码编译成可执行文件或者库文件。本文将详细介绍GCC编译过程以及如何制作静态库和动态库。
文章目录
- 一、GCC编译过程
- 1. 预处理阶段
- 2. 编译阶段
- 3. 汇编阶段
- 4. 链接阶段
- 二、静态库制作
- 1. 静态库制作
- 2. 使用静态库
- 补充：头文件对应
- 三、动态库制作
- 1. 动态库制作
- 2. 使用动态库
- 补充：动态库加载错误及解决方法
- 四、总结
- 补充：gcc使用技巧
一、GCC编译过程
GCC编译过程主要分为四个阶段：预处理、编译、汇编和链接。下面我们将逐一介绍每个阶段的作用。
1. 预处理阶段
预处理阶段主要是对源代码进行宏展开、头文件包含、条件编译等预处理操作。预处理器会根据源文件中的预处理指令，生成一个新的文件，通常以.i作为扩展名。
示例代码：
// main.c
#include <stdio.h>
#define PI 3.1415926
int main() {
printf("PI = %f\n", PI);
return 0;
}
预处理后的代码：
// main.i
# 1 "main.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "main.c"
# 1 "/usr/include/stdio.h" 1 3 4
# 27 "/usr/include/stdio.h" 3 4
...
2. 编译阶段
编译阶段将预处理后的代码转换成汇编代码，即将高级语言代码翻译成汇编语言代码。编译器会检查语法错误、类型错误等，并生成一个汇编文件，通常以.s作为扩展名。
示例代码：
// main.i
# 1 "main.c"
...
int main() {
printf("PI = %f\n", PI);
return 0;
}
编译后的汇编代码：
// main.s
.file "main.c"
.section .rodata
.LC0:
.string "PI = %f\n"
.text
.globl main
.type main, @function
main:
pushq %rbp
movq %rsp, %rbp
subq $16, %rsp
movsd .LC0(%rip), %xmm0
movl $1, %eax
movl $.LC1, %edi
movl $0, %eax
call printf
movl $0, %eax
leave
ret
.size main, .-main
.section .rodata
.LC1:
.string "PI = %f\n"
.text
.section .note.GNU-stack,"",@progbits
3. 汇编阶段
汇编阶段将汇编代码转换成机器代码。汇编器会将汇编代码转换成二进制指令，生成一个目标文件，通常以.o作为扩展名。
示例代码：
// main.s
.file "main.c"
...
汇编后的目标文件：
// main.o
...
4. 链接阶段
链接阶段将目标文件与所需的库文件进行链接，生成最终的可执行文件。链接器会解析目标文件中的符号引用，并将其与库文件中的符号定义进行匹配。
示例代码：
// main.o
...
链接后的可执行文件：
// main
...
二、静态库制作
好的，下面我将给出一个更详细的例子来说明如何制作和使用静态库。
1. 静态库制作
首先，我们需要创建两个源文件add.c和sub.c，分别实现加法和减法的功能。
add.c：
int add(int a, int b) {
return a + b;
}
sub.c：
int sub(int a, int b) {
return a - b;
}
然后，我们使用gcc命令将这两个源文件编译成目标文件。
$ gcc -c add.c sub.c
生成add.o和sub.o文件。
接下来，我们使用ar命令将目标文件打包成一个静态库文件libmath.a。
$ ar rcs libmath.a add.o sub.o
这一步完之后你的目录里会包含
add.c /sub.c /add.o /sub.o /libmath.a
2. 使用静态库
现在我们已经制作好了一个静态库libmath.a，接下来我们将使用这个静态库。
首先，我们创建一个main.c文件，调用静态库中的函数。
main.c：
#include <stdio.h>
extern int add(int a, int b);
extern int sub(int a, int b);
int main() {
int a = 10;
int b = 5;
int sum = add(a, b);
int difference = sub(a, b);
printf("Sum: %d\n", sum);
printf("Difference: %d\n", difference);
return 0;
}
要进行声明函数，要不系统会默认隐形声明，容易导致错误。
然后，我们使用gcc命令将main.c文件与静态库链接起来生成可执行文件。
$ gcc main.c -L. -lmath -o main
最后，我们运行可执行文件main。
$ ./main
输出结果：
Sum: 15
Difference: 5
补充：头文件对应
假设我们有一个名为example的静态库，其中包含了一个函数void print_hello()。为了使用这个函数，我们需要有一个头文件example.h，其中包含了函数的声明。
example.h：
#ifndef EXAMPLE_H
#define EXAMPLE_H
void print_hello();
#endif
在使用这个静态库的源文件中，我们需要包含example.h头文件，并调用其中的函数。
main.c：
#include <stdio.h>
#include "example.h"
int main() {
printf("Hello, world!\n");
print_hello();
return 0;
}
在编译时，我们需要指定静态库文件的搜索路径和要链接的库文件。假设libexample.a是我们的静态库文件，可以使用以下命令进行编译：
gcc -o program main.c -L/path/to/library -lexample
其中-L/path/to/library指定了静态库文件的搜索路径，-lexample指定要链接的静态库。
总结一下：首先，我们需要将多个目标文件打包成一个静态库文件，然后在编译时指定静态库的路径和名称。最后，我们可以通过调用静态库中的函数来使用其中的功能。希望这个例子能够帮助你更好地理解静态库的制作和使用过程。
三、动态库制作
动态库是在程序运行时被加载的库文件，它可以被多个程序共享使用，减少了内存的占用。
1. 动态库制作
首先，我们需要创建两个源文件add.c和sub.c，分别实现加法和减法的功能。
add.c：
int add(int a, int b) {
return a + b;
}
sub.c：
int sub(int a, int b) {
return a - b;
}
然后，我们使用gcc命令将这两个源文件编译成目标文件，并使用-fPIC选项生成位置无关的代码。
$ gcc -c -fPIC add.c sub.c
同样生成add.o和sub.o文件。
接下来，我们使用gcc命令将目标文件打包成一个动态库文件libmath.so。
$ gcc -shared -o libmath.so add.o sub.o
2. 使用动态库
现在我们已经制作好了一个动态库libmath.so，接下来我们将使用这个动态库。
首先，我们创建一个main.c文件，调用动态库中的函数。
main.c：
#include <stdio.h>
#include <dlfcn.h>
int main() {
void* handle = dlopen("./libmath.so", RTLD_LAZY);
if (!handle) {
fprintf(stderr, "Failed to open library: %s\n", dlerror());
return 1;
}
int (*add)(int, int) = dlsym(handle, "add");
int (*sub)(int, int) = dlsym(handle, "sub");
int a = 10;
int b = 5;
int sum = add(a, b);
int difference = sub(a, b);
printf("Sum: %d\n", sum);
printf("Difference: %d\n", difference);
dlclose(handle);
return 0;
}
/*
首先，在main函数中，我们声明了一个void指针变量handle，用于存储打开动态库后返回的句柄。然后，我们使用dlopen函数打开动态库文件libmath.so，指定RTLD_LAZY标志表示在需要时才解析符号。如果打开动态库失败，我们使用dlerror函数获取错误信息并打印到stderr流上，然后返回1表示出错。
接下来，我们使用dlsym函数获取动态库中的函数指针。dlsym函数的第一个参数是动态库的句柄，第二个参数是要获取的函数名。我们使用函数指针的方式来声明和初始化两个函数指针变量add和sub，分别指向动态库中的add函数和sub函数。
然后，我们定义了两个整型变量a和b，并分别赋值为10和5。
接下来，我们通过调用函数指针变量add和sub来调用动态库中的函数，得到加法和减法的结果，并分别赋值给sum和difference变量。
最后，我们使用dlclose函数关闭动态库句柄，释放资源。
*/
然后，我们使用gcc命令将main.c文件与动态库链接起来生成可执行文件，并指定动态库的路径和名称。
$ gcc main.c -L. -ldl -o main
最后，我们运行可执行文件main。
$ ./main
输出结果：
Sum: 15
Difference: 5
总结一下：首先，我们需要将多个目标文件编译成位置无关的代码，并使用gcc命令将它们打包成一个动态库文件。然后，在使用动态库的程序中，我们需要使用dlopen函数打开动态库，并使用dlsym函数获取动态库中的函数指针。最后，我们可以通过调用动态库中的函数来使用其中的功能。
补充：动态库加载错误及解决方法
如果动态库路径错误，可以按照以下方法解决：
- 检查动态库文件的路径是否正确：确保指定的路径是动态库文件所在的准确路径。
- 使用绝对路径或相对路径：可以使用绝对路径来指定动态库的路径，例如
/path/to/library/libexample.so。或者，使用相对路径来指定动态库的路径，相对路径是相对于当前工作目录的路径，例如./libexample.so。 - 设置LD_LIBRARY_PATH环境变量：可以通过设置LD_LIBRARY_PATH环境变量来指定动态库的搜索路径。例如，如果动态库文件在
/path/to/library目录中，可以执行以下命令：
这将把export LD_LIBRARY_PATH=/path/to/library:$LD_LIBRARY_PATH/path/to/library添加到动态库的搜索路径中。 - 使用rpath选项：可以在链接时使用-rpath选项来指定动态库的搜索路径。例如，使用以下命令来编译和链接程序：
这将在程序中设置动态库的搜索路径为gcc -o program main.c -L/path/to/library -Wl,-rpath=/path/to/library -lexample/path/to/library。
通过以上方法，您可以解决动态库路径错误的问题。请注意，在使用LD_LIBRARY_PATH环境变量或rpath选项时，确保指定的路径是正确的，并且动态库文件存在于该路径中。
四、总结
本文详细介绍了GCC编译过程以及如何制作静态库和动态库。通过预处理、编译、汇编和链接四个阶段，我们可以将源代码转换成可执行文件或者库文件。静态库将多个目标文件打包成一个文件，程序在编译时会将静态库的代码复制到可执行文件中；而动态库是在程序运行时被加载的库文件，它可以被多个程序共享使用，减少了内存的占用。
内容补充：
补充：gcc使用技巧
gcc是GNU Compiler Collection（GNU编译器套件）的缩写，是一个广泛使用的编程语言编译器。它支持多种编程语言，包括C、C++、Objective-C、Fortran、Ada和Go等。下面是gcc的常用参数和其作用的简要说明：
-c：只编译源文件，生成目标文件（.o文件），不进行链接操作。-o：指定输出文件的名称。-I：指定头文件的搜索路径。-L：指定库文件的搜索路径。-l：链接时使用的库文件。-g：生成调试信息，用于调试程序。-Wall：开启所有警告信息。-Werror：将警告视为错误。-std：指定使用的C或C++标准。-O：优化级别，包括-O0（无优化）、-O1（基本优化）、-O2（更多优化）和-O3（最大优化）等。-shared：生成一个共享库文件（动态库）。-fPIC：生成位置无关的代码，用于生成动态库。-pthread：链接多线程库。
